diff --git a/.eslintrc.js b/.eslintrc.js
index daec0f421c9..710873e1b56 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,4 +1,4 @@
-module.exports = { // E: 'module' is not defined.
+module.exports = {
     extends: ['turbo', '@solana/eslint-config-solana', '@solana/eslint-config-solana/jest'],
     root: true,
 };
diff --git a/.github/workflows/publish-rust.yml b/.github/workflows/publish-rust.yml
new file mode 100644
index 00000000000..923960e74aa
--- /dev/null
+++ b/.github/workflows/publish-rust.yml
@@ -0,0 +1,230 @@
+name: Publish Rust Crate
+
+on:
+  workflow_dispatch:
+    inputs:
+      package_path:
+        description: Path to directory with package to release
+        required: true
+        type: string
+      level:
+        description: Level
+        required: true
+        default: patch
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+          - rc
+          - beta
+          - alpha
+          - release
+          - version
+      version:
+        description: Version (used with level "version")
+        required: false
+        type: string
+      dry_run:
+        description: Dry run
+        required: true
+        default: true
+        type: boolean
+      create_release:
+        description: Create a GitHub release
+        required: true
+        type: boolean
+        default: true
+
+jobs:
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set env vars
+        run: |
+          source ci/rust-version.sh
+          echo "RUST_NIGHTLY=$rust_nightly" >> $GITHUB_ENV
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_NIGHTLY }}
+          components: rustfmt
+
+      - name: Run fmt
+        run: ./cargo-nightly fmt --all -- --check
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Remove unneeded packages for more space
+        run: bash ./ci/warning/purge-ubuntu-runner.sh
+
+      - name: Set env vars
+        run: |
+          source ci/rust-version.sh
+          echo "RUST_NIGHTLY=$rust_nightly" >> $GITHUB_ENV
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_NIGHTLY }}
+          components: clippy
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            cargo-clippy-
+
+      - name: Install dependencies
+        run: ./ci/install-build-deps.sh
+
+      - name: Run clippy
+        run: ./cargo-nightly clippy -Zunstable-options --workspace --all-targets --all-features -- --deny=warnings --deny=clippy::arithmetic_side_effects
+
+  cargo-build-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Remove unneeded packages for more space
+        run: bash ./ci/warning/purge-ubuntu-runner.sh
+
+      - name: Set env vars
+        run: |
+          source ci/rust-version.sh
+          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
+          source ci/solana-version.sh
+          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_STABLE }}
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE }}
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/rustfilt
+          key: cargo-sbf-bins-${{ runner.os }}
+
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/solana
+          key: solana-${{ env.SOLANA_VERSION }}
+
+      - name: Install dependencies
+        run: |
+          ./ci/install-build-deps.sh
+          ./ci/install-program-deps.sh
+          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
+
+      - name: Build and test
+        run: ./ci/cargo-build-test.sh
+
+  publish_crate:
+    name: Publish crate
+    runs-on: ubuntu-latest
+    needs: [rustfmt, clippy, cargo-build-test]
+    permissions:
+      contents: write
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # get the whole history for git-cliff
+
+      - name: Set env vars
+        run: |
+          source ci/rust-version.sh
+          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_STABLE }}
+
+      - name: Install dependencies
+        run: ./ci/install-build-deps.sh
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: cargo-publish-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            cargo-publish-
+
+      - name: Install Cargo Release
+        run: which cargo-release || cargo install cargo-release --version 0.25.11
+
+      - name: Ensure CARGO_REGISTRY_TOKEN variable is set
+        env:
+          token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        if: ${{ env.token == '' }}
+        run: |
+          echo "The CARGO_REGISTRY_TOKEN secret variable is not set"
+          echo "Go to \"Settings\" -> \"Secrets and variables\" -> \"Actions\" -> \"New repository secret\"."
+          exit 1
+
+      - name: Set Git Author
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      - name: Rebase
+        run: git pull --rebase origin
+
+      - name: Publish Crate
+        id: publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: |
+          if [ "${{ inputs.level }}" == "version" ]; then
+            LEVEL=${{ inputs.version }}
+          else
+            LEVEL=${{ inputs.level }}
+          fi
+
+          if [ "${{ inputs.dry_run }}" == "true" ]; then
+            OPTIONS="--dry-run"
+          else
+            OPTIONS=""
+          fi
+
+          ./ci/publish-rust.sh "${{ inputs.package_path }}" $LEVEL $OPTIONS
+
+      - name: Generate a changelog
+        if: github.event.inputs.create_release == 'true'
+        uses: orhun/git-cliff-action@v3
+        with:
+          config: "ci/cliff.toml"
+          args: |
+            "${{ steps.publish.outputs.old_git_tag }}"..master
+            --include-path "${{ inputs.package_path }}/**"
+            --github-repo "${{ github.repository }}"
+        env:
+          OUTPUT: TEMP_CHANGELOG.md
+          GITHUB_REPO: ${{ github.repository }}
+
+      - name: Create GitHub release
+        if: github.event.inputs.create_release == 'true' && github.event.inputs.dry_run != 'true'
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ steps.publish.outputs.new_git_tag }}
+          bodyFile: TEMP_CHANGELOG.md
+          name: ${{ steps.publish.outputs.release_title }}
diff --git a/.github/workflows/pull-request-account-compression.yml b/.github/workflows/pull-request-account-compression.yml
index 6341b02fe98..d11a636b2dd 100644
--- a/.github/workflows/pull-request-account-compression.yml
+++ b/.github/workflows/pull-request-account-compression.yml
@@ -10,7 +10,7 @@ on:
       - ".github/workflows/pull-request-account-compression.yml"
       - "!account-compression/sdk/**"
   push:
-    branches: [master]
+    branches: [master, ac-mainnet-tag]
     paths:
       - "account-compression/**"
       - "libraries/concurrent-merkle-tree/**"
@@ -18,6 +18,7 @@ on:
       - "ci/install-anchor.sh"
       - ".github/workflows/pull-request-account-compression.yml"
       - "!account-compression/sdk/**"
+  workflow_dispatch:
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -31,10 +32,11 @@ jobs:
 
       - name: Set env vars
         run: |
+          echo "RUST_STABLE_VERSION=1.78.0" >> $GITHUB_ENV
+          echo "SOLANA_VERSION=v2.0.14" >> $GITHUB_ENV
           source ci/rust-version.sh
           echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
           source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
           source ci/install-anchor.sh
           echo "ANCHOR_CLI_VERSION=$anchor_cli_version" >> $GITHUB_ENV
 
@@ -70,7 +72,7 @@ jobs:
         run: ./ci/cargo-test-sbf.sh account-compression
 
       - name: Upload programs
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: account-compression-programs
           path: "account-compression/target/deploy/*.so"
@@ -79,20 +81,20 @@ jobs:
   js-test-account-compression:
     runs-on: ubuntu-latest
     env:
-      NODE_VERSION: 16.x
+      NODE_VERSION: 20.X
     steps:
       - uses: actions/checkout@v4
       - name: Use Node.js ${{ env.NODE_VERSION }}
         uses: actions/setup-node@v4
         with:
           node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
+      - uses: pnpm/action-setup@v4
       - uses: actions/cache@v4
         with:
           path: ~/.npm
           key: node-${{ hashFiles('pnpm-lock.yaml') }}
           restore-keys: |
             node-
+      - name: Set env vars
+        run: echo "SOLANA_VERSION=v2.0.14" >> $GITHUB_ENV
       - run: ./ci/js-test-account-compression.sh
diff --git a/.github/workflows/pull-request-feature-proposal.yml b/.github/workflows/pull-request-feature-proposal.yml
deleted file mode 100644
index b88fbcb7a30..00000000000
--- a/.github/workflows/pull-request-feature-proposal.yml
+++ /dev/null
@@ -1,64 +0,0 @@
-name: Feature Proposal Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'feature-proposal/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - '!token/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'feature-proposal/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - '!token/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh feature-proposal
diff --git a/.github/workflows/pull-request-instruction-padding.yml b/.github/workflows/pull-request-instruction-padding.yml
deleted file mode 100644
index 17756f7c679..00000000000
--- a/.github/workflows/pull-request-instruction-padding.yml
+++ /dev/null
@@ -1,62 +0,0 @@
-name: Instruction Pad Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'instruction-padding/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-instruction-padding.yml'
-  push:
-    branches: [master]
-    paths:
-    - 'instruction-padding/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-instruction-padding.yml'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh instruction-padding
diff --git a/.github/workflows/pull-request-js.yml b/.github/workflows/pull-request-js.yml
index 09e3413a6a5..225874ebade 100644
--- a/.github/workflows/pull-request-js.yml
+++ b/.github/workflows/pull-request-js.yml
@@ -4,15 +4,8 @@ on:
   pull_request:
     paths:
       - 'account-compression/sdk/**'
-      - 'libraries/type-length-value/js/**'
-      - 'memo/js/**'
       - 'name-service/js/**'
-      - 'single-pool/js/**'
-      - 'stake-pool/js/**'
-      - 'token/js/**'
-      - 'token-group/js/**'
       - 'token-lending/js/**'
-      - 'token-metadata/js/**'
       - 'token-swap/js/**'
       - 'pnpm-lock.yaml'
       - '.github/workflows/pull-request-js.yml'
@@ -20,14 +13,7 @@ on:
     branches: [master]
     paths:
       - 'account-compression/sdk/**'
-      - 'libraries/type-length-value/js/**'
-      - 'memo/js/**'
-      - 'single-pool/js/**'
-      - 'stake-pool/js/**'
-      - 'token/js/**'
-      - 'token-group/js/**'
       - 'token-lending/js/**'
-      - 'token-metadata/js/**'
       - 'token-swap/js/**'
       - 'pnpm-lock.yaml'
       - '.github/workflows/pull-request-js.yml'
@@ -40,32 +26,26 @@ jobs:
   js-test:
     strategy:
       matrix:
+        node-version: [16.x, 18.x, 20.x]
         package:
           [
-            account-compression,
-            libraries,
-            memo,
             name-service,
-            single-pool,
-            stake-pool,
-            token,
-            token-group,
-            token-lending,
-            token-metadata,
             token-swap,
           ]
+        include:
+          # Restrict certain packages to supported Node.js versions.
+          - package: account-compression
+            node-version: 20.x
+          - package: token-lending
+            node-version: 18.5
     runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 20.5
     steps:
       - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
+      - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v4
         with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
+          node-version: ${{ matrix.node-version }}
+      - uses: pnpm/action-setup@v4
       - uses: actions/cache@v4
         with:
           path: ~/.npm
diff --git a/.github/workflows/pull-request-libraries.yml b/.github/workflows/pull-request-libraries.yml
index d84b383555c..7b7a06e424f 100644
--- a/.github/workflows/pull-request-libraries.yml
+++ b/.github/workflows/pull-request-libraries.yml
@@ -6,14 +6,12 @@ on:
     - 'libraries/**'
     - 'ci/*-version.sh'
     - '.github/workflows/pull-request-libraries.yml'
-    - '!libraries/**/js/**'
   push:
     branches: [master]
     paths:
     - 'libraries/**'
     - 'ci/*-version.sh'
     - '.github/workflows/pull-request-libraries.yml'
-    - '!libraries/**/js/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -62,24 +60,3 @@ jobs:
 
       - name: Build and test
         run: ./ci/cargo-test-sbf.sh libraries
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-libraries.sh
diff --git a/.github/workflows/pull-request-memo.yml b/.github/workflows/pull-request-memo.yml
deleted file mode 100644
index e908d9c8753..00000000000
--- a/.github/workflows/pull-request-memo.yml
+++ /dev/null
@@ -1,83 +0,0 @@
-name: Memo Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'memo/**'
-    - 'ci/*-version.sh'
-    - '!memo/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'memo/**'
-    - 'ci/*-version.sh'
-    - '!memo/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh memo
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-memo.sh
diff --git a/.github/workflows/pull-request-name-service.yml b/.github/workflows/pull-request-name-service.yml
index 1c3adb32926..70ce45a3168 100644
--- a/.github/workflows/pull-request-name-service.yml
+++ b/.github/workflows/pull-request-name-service.yml
@@ -61,13 +61,6 @@ jobs:
       - name: Build and test
         run: ./ci/cargo-test-sbf.sh name-service
 
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: name-service-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
   js-test:
     runs-on: ubuntu-latest
     env:
@@ -78,9 +71,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
+      - uses: pnpm/action-setup@v4
       - uses: actions/cache@v4
         with:
           path: ~/.npm
diff --git a/.github/workflows/pull-request-record.yml b/.github/workflows/pull-request-record.yml
deleted file mode 100644
index 6199fe98226..00000000000
--- a/.github/workflows/pull-request-record.yml
+++ /dev/null
@@ -1,60 +0,0 @@
-name: Record Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'record/**'
-    - 'ci/*-version.sh'
-  push:
-    branches: [master]
-    paths:
-    - 'record/**'
-    - 'ci/*-version.sh'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh record
diff --git a/.github/workflows/pull-request-single-pool.yml b/.github/workflows/pull-request-single-pool.yml
deleted file mode 100644
index 8cfe1968b79..00000000000
--- a/.github/workflows/pull-request-single-pool.yml
+++ /dev/null
@@ -1,141 +0,0 @@
-name: Single-Validator Stake Pool Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'single-pool/**'
-    - 'token/**'
-    - 'associated-token-account/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-single-pool.yml'
-    - '!single-pool/js/**'
-    - '!token/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'single-pool/**'
-    - 'token/**'
-    - 'associated-token-account/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-single-pool.yml'
-    - '!single-pool/js/**'
-    - '!token/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh single-pool/program
-
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: single-pool-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
-  cargo-build-test-cli:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build dependent programs
-        run: |
-          cargo build-sbf --manifest-path=single-pool/program/Cargo.toml
-
-      - name: Build and test
-        run: |
-          cargo build --manifest-path ./single-pool/cli/Cargo.toml
-          cargo test --manifest-path ./single-pool/cli/Cargo.toml
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 20.5
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-single-pool.sh
diff --git a/.github/workflows/pull-request-stake-pool.yml b/.github/workflows/pull-request-stake-pool.yml
deleted file mode 100644
index 9d73859956b..00000000000
--- a/.github/workflows/pull-request-stake-pool.yml
+++ /dev/null
@@ -1,131 +0,0 @@
-name: Stake Pool Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'stake-pool/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - 'ci/warning/purge-ubuntu-runner.sh'
-    - '.github/workflows/pull-request-stake-pool.yml'
-    - '!stake-pool/js/**'
-    - '!token/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'stake-pool/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - 'ci/warning/purge-ubuntu-runner.sh'
-    - '.github/workflows/pull-request-stake-pool.yml'
-    - '!stake-pool/js/**'
-    - '!token/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Check disk space
-        run: df -h
-
-      - name: Remove unneeded packages for more space
-        run: bash ./ci/warning/purge-ubuntu-runner.sh
-
-      - name: Check disk space again
-        run: df -h
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: ./ci/cargo-test-sbf.sh stake-pool
-
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: stake-pool-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-stake-pool.sh
-
-  py-test:
-    runs-on: ubuntu-latest
-    needs: cargo-test-sbf
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Python version
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.8
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: pip-stake-pool-${{ hashFiles('stake-pool/py/requirements.txt') }}
-
-      - name: Download programs
-        uses: actions/download-artifact@v3
-        with:
-          name: stake-pool-programs
-          path: target/deploy
-
-      - run: ./ci/py-test-stake-pool.sh
diff --git a/.github/workflows/pull-request-token-group.yml b/.github/workflows/pull-request-token-group.yml
deleted file mode 100644
index 3d954d47a93..00000000000
--- a/.github/workflows/pull-request-token-group.yml
+++ /dev/null
@@ -1,93 +0,0 @@
-name: Token-Group Pull Request
-
-on:
-  pull_request:
-    paths:
-      - 'token-group/**'
-      - 'token/program-2022/**'
-      - 'ci/*-version.sh'
-      - '.github/workflows/pull-request-token-group.yml'
-      - '!token-group/js/**'
-  push:
-    branches: [master]
-    paths:
-      - 'token-group/**'
-      - 'token/program-2022/**'
-      - 'ci/*-version.sh'
-      - '.github/workflows/pull-request-token-group.yml'
-      - '!token-group/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Test token-group interface
-        run: |
-          cargo test \
-            --manifest-path=token-group/interface/Cargo.toml \
-            -- --nocapture
-
-      - name: Build and test example
-        run: ./ci/cargo-test-sbf.sh token-group/example
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-token-group.sh
diff --git a/.github/workflows/pull-request-token-lending.yml b/.github/workflows/pull-request-token-lending.yml
index b2acd9296f0..9add4942a50 100644
--- a/.github/workflows/pull-request-token-lending.yml
+++ b/.github/workflows/pull-request-token-lending.yml
@@ -65,13 +65,6 @@ jobs:
       - name: Build and test
         run: ./ci/cargo-test-sbf.sh token-lending
 
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: token-lending-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
   js-test:
     runs-on: ubuntu-latest
     env:
@@ -82,9 +75,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
+      - uses: pnpm/action-setup@v4
       - uses: actions/cache@v4
         with:
           path: ~/.npm
diff --git a/.github/workflows/pull-request-token-metadata.yml b/.github/workflows/pull-request-token-metadata.yml
deleted file mode 100644
index 47d7b4e3309..00000000000
--- a/.github/workflows/pull-request-token-metadata.yml
+++ /dev/null
@@ -1,94 +0,0 @@
-name: Token-Metadata Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'token-metadata/**'
-    - 'token/program-2022/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-token-metadata.yml'
-    - '!token-metadata/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'token-metadata/**'
-    - 'token/program-2022/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-token-metadata.yml'
-    - '!token-metadata/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Test token-metadata with "serde" activated
-        run: |
-          cargo test \
-            --manifest-path=token-metadata/interface/Cargo.toml \
-            --features serde-traits \
-            -- --nocapture
-
-      - name: Build and test example
-        run: ./ci/cargo-test-sbf.sh token-metadata/example
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-token-metadata.sh
diff --git a/.github/workflows/pull-request-token-swap.yml b/.github/workflows/pull-request-token-swap.yml
index 57222a41d8e..c86865137c7 100644
--- a/.github/workflows/pull-request-token-swap.yml
+++ b/.github/workflows/pull-request-token-swap.yml
@@ -80,13 +80,6 @@ jobs:
         run: |
           mv target/deploy-production/spl_token_swap.so target/deploy/spl_token_swap_production.so
 
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: token-swap-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
   js-test:
     runs-on: ubuntu-latest
     env:
@@ -97,9 +90,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
+      - uses: pnpm/action-setup@v4
       - uses: actions/cache@v4
         with:
           path: ~/.npm
diff --git a/.github/workflows/pull-request-token.yml b/.github/workflows/pull-request-token.yml
deleted file mode 100644
index 72b9c28d844..00000000000
--- a/.github/workflows/pull-request-token.yml
+++ /dev/null
@@ -1,351 +0,0 @@
-name: Token Pull Request
-
-on:
-  pull_request:
-    paths:
-    - 'associated-token-account/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-token.yml'
-    - '!token/js/**'
-  push:
-    branches: [master]
-    paths:
-    - 'associated-token-account/**'
-    - 'token/**'
-    - 'ci/*-version.sh'
-    - '.github/workflows/pull-request-token.yml'
-    - '!token/js/**'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  cargo-test-sbf:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Remove unneeded packages for more space
-        run: bash ./ci/warning/purge-ubuntu-runner.sh
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test token
-        run: ./ci/cargo-test-sbf.sh token
-
-      - name: Upload programs
-        uses: actions/upload-artifact@v3
-        with:
-          name: token-programs
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
-  cargo-test-token-2022-serde:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - name: Test token-2022 with "serde" activated
-        run: |
-          cargo test \
-            --manifest-path=token/program-2022/Cargo.toml \
-            --features serde-traits \
-            -- --nocapture
-
-  cargo-test-sbf-transfer-hook:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test transfer hook example
-        run: ./ci/cargo-test-sbf.sh token/transfer-hook/example
-
-      - name: Upload program
-        uses: actions/upload-artifact@v3
-        with:
-          name: spl-transfer-hook-example
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
-  cargo-test-sbf-associated-token-account:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/rustfilt
-          key: cargo-sbf-bins-${{ runner.os }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test ATA
-        run: ./ci/cargo-test-sbf.sh associated-token-account
-
-      - name: Upload program
-        uses: actions/upload-artifact@v3
-        with:
-          name: associated-token-account-program
-          path: "target/deploy/*.so"
-          if-no-files-found: error
-
-  cargo-test-sbf-twoxtx:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Remove unneeded packages for more space
-        run: bash ./ci/warning/purge-ubuntu-runner.sh
-
-      - name: Set env vars
-        run: |
-          echo "RUST_STABLE_VERSION=1.72.0" >> $GITHUB_ENV
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE_VERSION }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test token-2022 twoxtx (TEMPORARY)
-        run: |
-          cargo build-sbf --manifest-path token/program-2022/Cargo.toml
-          cargo build-sbf --manifest-path instruction-padding/program/Cargo.toml
-          ./token/twoxtx-setup.sh
-          ./token/twoxtx-solana/cargo-test-sbf --manifest-path token/program-2022-test/Cargo.toml -- --nocapture
-
-  js-test:
-    runs-on: ubuntu-latest
-    env:
-      NODE_VERSION: 16.x
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: node-${{ hashFiles('pnpm-lock.yaml') }}
-          restore-keys: |
-            node-
-      - run: ./ci/js-test-token.sh
-
-  cargo-build-test-cli:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Build and test
-        run: |
-          BUILD_DEPENDENT_PROGRAMS=1 cargo build --manifest-path ./token/cli/Cargo.toml
-          cargo test --manifest-path ./token/cli/Cargo.toml
-
-  cargo-build-test-transfer-hook-cli:
-    runs-on: ubuntu-latest
-    needs: [cargo-test-sbf]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set env vars
-        run: |
-          source ci/rust-version.sh
-          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
-          source ci/solana-version.sh
-          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE }}
-
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/solana
-          key: solana-${{ env.SOLANA_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          ./ci/install-build-deps.sh
-          ./ci/install-program-deps.sh
-          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
-
-      - name: Download spl-transfer-hook-example program
-        uses: actions/download-artifact@v3
-        with:
-          name: spl-transfer-hook-example
-          path: target/deploy
-
-      - name: Build and test
-        run: |
-          cargo test --manifest-path ./token/transfer-hook/cli/Cargo.toml
diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
index 0bf72e36d8a..7e730b72183 100644
--- a/.github/workflows/pull-request.yml
+++ b/.github/workflows/pull-request.yml
@@ -47,6 +47,9 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Remove unneeded packages for more space
+        run: bash ./ci/warning/purge-ubuntu-runner.sh
+
       - name: Set env vars
         run: |
           source ci/rust-version.sh
@@ -71,7 +74,7 @@ jobs:
         run: ./ci/install-build-deps.sh
 
       - name: Run clippy
-        run: ./cargo-nightly clippy -Zunstable-options --workspace --all-targets --features test-sbf -- --deny=warnings --deny=clippy::arithmetic_side_effects
+        run: ./cargo-nightly clippy -Zunstable-options --workspace --all-targets --all-features -- --deny=warnings --deny=clippy::arithmetic_side_effects
 
   audit:
     runs-on: ubuntu-latest
diff --git a/.npmrc b/.npmrc
new file mode 100644
index 00000000000..6c59086d862
--- /dev/null
+++ b/.npmrc
@@ -0,0 +1 @@
+enable-pre-post-scripts=true
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 00000000000..7bfa0e8650f
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,11 @@
+docs
+lib
+test-ledger
+node_modules
+dist
+generated
+.mypy_cache
+*.yml
+*.yaml
+*.md
+*.json
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 00000000000..173a61f766c
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,9 @@
+{
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5",
+    "useTabs": false,
+    "tabWidth": 4,
+    "arrowParens": "always",
+    "printWidth": 80
+}
diff --git a/Anchor.toml b/Anchor.toml
index 841e85f7475..5ec1ebb7bf3 100644
--- a/Anchor.toml
+++ b/Anchor.toml
@@ -1,15 +1,11 @@
 [toolchain]
 anchor_version = "0.29.0"
-solana_version = "1.18.11"
+solana_version = "2.1.0"
 
 [workspace]
 members = [
   "governance/program",
   "governance/chat/program",
-  "memo/program",
-  "stake-pool/program",
-  "token/program",
-  "token/program-2022",
 ]
 exclude = [
   "account-compression/"
@@ -22,6 +18,3 @@ wallet = "~/.config/solana/id.json"
 [programs.mainnet]
 spl_governance = "GovER5Lthms3bLBqWub97yVrMmEogzX7xNjdXpPPCVZw"
 spl_governance_chat = "gCHAtYKrUUktTVzE4hEnZdLV4LXrdBf6Hh9qMaJALET"
-spl_stake_pool = "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy"
-spl_token = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
-spl_token_2022 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
diff --git a/Cargo.lock b/Cargo.lock
index 5e300fb514c..cdb00c16039 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -27,32 +27,38 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+
 [[package]]
 name = "aead"
-version = "0.4.3"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b613b8e1e3cf911a086f53f03bf286f52fd7a7258e4fa606f0ef220d39d8877"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
+ "crypto-common",
  "generic-array 0.14.7",
 ]
 
 [[package]]
 name = "aes"
-version = "0.7.5"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
 dependencies = [
  "cfg-if 1.0.0",
  "cipher",
  "cpufeatures",
- "opaque-debug 0.3.0",
 ]
 
 [[package]]
 name = "aes-gcm-siv"
-version = "0.10.3"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589c637f0e68c877bbd59a4599bbe849cac8e5f3e4b5a3ebae8f528cd218dcdc"
+checksum = "ae0784134ba9375416d469ec31e7c5f9fa94405049cf08c5ce5b4698be673e0d"
 dependencies = [
  "aead",
  "aes",
@@ -65,14 +71,24 @@ dependencies = [
 
 [[package]]
 name = "agave-geyser-plugin-interface"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92179e90ad74e3f881c954a2cdbcc4ff4ec29382c7eb4f110e35a0a12a5ba8c7"
+checksum = "9291468d48d46cfe92d7807990e19c6ee9a07b05a75cda5e118f48597e079391"
 dependencies = [
  "log",
  "solana-sdk",
  "solana-transaction-status",
- "thiserror",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "agave-transaction-view"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a249374d6349eeb31348a849666f3d47cacb18e0e05454fbd11a1fc69fae8e7e"
+dependencies = [
+ "solana-sdk",
+ "solana-svm-transaction",
 ]
 
 [[package]]
@@ -88,9 +104,9 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.8.9"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d713b3834d76b85304d4d525563c1276e2e30dc97cc67bfb4585a4a29fc2c89f"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
  "getrandom 0.2.10",
@@ -117,12 +133,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "aliasable"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
-
 [[package]]
 name = "alloc-no-stdlib"
 version = "2.0.3"
@@ -138,6 +148,12 @@ dependencies = [
  "alloc-no-stdlib",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -162,68 +178,11 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "anstream"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a30da5c5f2d5e72842e00bcb57657162cdabef0931f40e2deb9b4140440cecd"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
-dependencies = [
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
-dependencies = [
- "anstyle",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "anyhow"
-version = "1.0.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb07d2053ccdbe10e2af2995a2f116c1330396493dc1269f6a91d0ae82e19704"
-
-[[package]]
-name = "approx"
-version = "0.5.1"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
-dependencies = [
- "num-traits",
-]
+checksum = "c042108f3ed77fd83760a5fd79b53be043192bb3b9dba91d8c574c0ada7850c8"
 
 [[package]]
 name = "aquamarine"
@@ -232,7 +191,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1da02abba9f9063d786eab1509833ebb2fac0f966862ca59439c76b9c566760"
 dependencies = [
  "include_dir",
- "itertools",
+ "itertools 0.10.5",
  "proc-macro-error",
  "proc-macro2",
  "quote",
@@ -241,9 +200,9 @@ dependencies = [
 
 [[package]]
 name = "arbitrary"
-version = "1.3.2"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
 dependencies = [
  "derive_arbitrary",
 ]
@@ -277,7 +236,7 @@ dependencies = [
  "ark-std",
  "derivative",
  "hashbrown 0.13.2",
- "itertools",
+ "itertools 0.10.5",
  "num-traits",
  "zeroize",
 ]
@@ -294,8 +253,8 @@ dependencies = [
  "ark-std",
  "derivative",
  "digest 0.10.7",
- "itertools",
- "num-bigint 0.4.4",
+ "itertools 0.10.5",
+ "num-bigint 0.4.6",
  "num-traits",
  "paste",
  "rustc_version",
@@ -318,7 +277,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
 dependencies = [
- "num-bigint 0.4.4",
+ "num-bigint 0.4.6",
  "num-traits",
  "proc-macro2",
  "quote",
@@ -347,7 +306,7 @@ dependencies = [
  "ark-serialize-derive",
  "ark-std",
  "digest 0.10.7",
- "num-bigint 0.4.4",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
@@ -373,15 +332,15 @@ dependencies = [
 
 [[package]]
 name = "arrayref"
-version = "0.3.7"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "ascii"
@@ -401,7 +360,7 @@ dependencies = [
  "nom",
  "num-traits",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
@@ -428,21 +387,6 @@ dependencies = [
  "syn 1.0.107",
 ]
 
-[[package]]
-name = "assert_cmd"
-version = "2.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
-dependencies = [
- "anstyle",
- "bstr 1.6.0",
- "doc-comment",
- "predicates 3.0.3",
- "predicates-core",
- "predicates-tree",
- "wait-timeout",
-]
-
 [[package]]
 name = "assert_matches"
 version = "1.5.0"
@@ -456,7 +400,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
 dependencies = [
  "concurrent-queue",
- "event-listener",
+ "event-listener 2.5.2",
  "futures-core",
 ]
 
@@ -475,12 +419,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "async-mutex"
-version = "1.4.0"
+name = "async-lock"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479db852db25d9dbf6204e6cb6253698f175c15726470f78af0d918e99d6156e"
+checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
 dependencies = [
- "event-listener",
+ "event-listener 5.3.1",
+ "event-listener-strategy",
+ "pin-project-lite",
 ]
 
 [[package]]
@@ -506,13 +452,13 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.80"
+version = "0.1.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
+checksum = "3f934833b4b7233644e5848f235df3f57ed8c80f1528a26c3dfa13d2147fa056"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -610,7 +556,7 @@ dependencies = [
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "miniz_oxide",
+ "miniz_oxide 0.7.1",
  "object",
  "rustc-demangle",
 ]
@@ -639,21 +585,15 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
-[[package]]
-name = "base64ct"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dea908e7347a8c64e378c17e30ef880ad73e3b4498346b055c2c00ea342f3179"
-
 [[package]]
 name = "binary-option"
 version = "0.1.0"
 dependencies = [
  "arrayref",
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "solana-program",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
  "uint",
 ]
 
@@ -668,39 +608,38 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.65.1"
+version = "0.69.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfdf7b466f9a4903edc73f95d6d2bcd5baf8ae620638762244d3f60143643cc5"
+checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
+ "itertools 0.12.1",
  "lazy_static",
  "lazycell",
- "peeking_take_while",
- "prettyplease 0.2.4",
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "bit-set"
-version = "0.5.2"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
  "bit-vec",
 ]
 
 [[package]]
 name = "bit-vec"
-version = "0.6.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
 [[package]]
 name = "bitflags"
@@ -710,9 +649,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.4.2"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 dependencies = [
  "serde",
 ]
@@ -728,9 +667,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.5.0"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87"
+checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -746,7 +685,7 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
 dependencies = [
- "block-padding 0.1.5",
+ "block-padding",
  "byte-tools",
  "byteorder",
  "generic-array 0.12.4",
@@ -758,7 +697,6 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "block-padding 0.2.1",
  "generic-array 0.14.7",
 ]
 
@@ -780,22 +718,6 @@ dependencies = [
  "byte-tools",
 ]
 
-[[package]]
-name = "block-padding"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
-
-[[package]]
-name = "borsh"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15bf3650200d8bffa99015595e10f1fbd17de07abbc25bb067da79e769939bfa"
-dependencies = [
- "borsh-derive 0.9.3",
- "hashbrown 0.11.2",
-]
-
 [[package]]
 name = "borsh"
 version = "0.10.3"
@@ -808,35 +730,22 @@ dependencies = [
 
 [[package]]
 name = "borsh"
-version = "1.5.1"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6362ed55def622cddc70a4746a68554d7b687713770de539e59a739b249f8ed"
+checksum = "2506947f73ad44e344215ccd6403ac2ae18cd8e046e581a441bf8d199f257f03"
 dependencies = [
- "borsh-derive 1.5.1",
+ "borsh-derive 1.5.3",
  "cfg_aliases",
 ]
 
-[[package]]
-name = "borsh-derive"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6441c552f230375d18e3cc377677914d2ca2b0d36e52129fe15450a2dce46775"
-dependencies = [
- "borsh-derive-internal 0.9.3",
- "borsh-schema-derive-internal 0.9.3",
- "proc-macro-crate 0.1.5",
- "proc-macro2",
- "syn 1.0.107",
-]
-
 [[package]]
 name = "borsh-derive"
 version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0754613691538d51f329cce9af41d7b7ca150bc973056f1156611489475f54f7"
 dependencies = [
- "borsh-derive-internal 0.10.3",
- "borsh-schema-derive-internal 0.10.3",
+ "borsh-derive-internal",
+ "borsh-schema-derive-internal",
  "proc-macro-crate 0.1.5",
  "proc-macro2",
  "syn 1.0.107",
@@ -844,27 +753,15 @@ dependencies = [
 
 [[package]]
 name = "borsh-derive"
-version = "1.5.1"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ef8005764f53cd4dca619f5bf64cafd4664dada50ece25e4d81de54c80cc0b"
+checksum = "c2593a3b8b938bd68373196c9832f516be11fa487ef4ae745eb282e6a56a7244"
 dependencies = [
  "once_cell",
  "proc-macro-crate 3.1.0",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
- "syn_derive",
-]
-
-[[package]]
-name = "borsh-derive-internal"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5449c28a7b352f2d1e592a8a28bf139bc71afb0764a14f3c02500935d8c44065"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -878,17 +775,6 @@ dependencies = [
  "syn 1.0.107",
 ]
 
-[[package]]
-name = "borsh-schema-derive-internal"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdbd5696d8bfa21d53d9fe39a714a18538bad11492a42d066dbbc395fb1951c0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
 [[package]]
 name = "borsh-schema-derive-internal"
 version = "0.10.3"
@@ -923,28 +809,20 @@ dependencies = [
 
 [[package]]
 name = "bs58"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
-
-[[package]]
-name = "bstr"
-version = "0.2.17"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
- "memchr",
+ "tinyvec",
 ]
 
 [[package]]
 name = "bstr"
-version = "1.6.0"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
 dependencies = [
  "memchr",
- "regex-automata 0.3.0",
- "serde",
 ]
 
 [[package]]
@@ -971,22 +849,22 @@ checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
 
 [[package]]
 name = "bytemuck"
-version = "1.16.0"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78834c15cb5d5efe3452d58b1e8ba890dd62d21907f867f383358198e56ebca5"
+checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
 dependencies = [
  "bytemuck_derive",
 ]
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.4.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aca418a974d83d40a0c1f0c5cba6ff4bc28d8df099109ca459a2118d40b6322"
+checksum = "3fa76293b4f7bb636ab88fd78228235b5248b4d05cc589aed610f954af5d7c7a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -997,9 +875,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.5.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da"
 
 [[package]]
 name = "bzip2"
@@ -1029,7 +907,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "190baaad529bcfbde9e1a19022c42781bdb6ff9de25721abdb8fd98c0807730b"
 dependencies = [
  "libc",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -1053,14 +931,21 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.0.83"
+version = "1.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+checksum = "c2e7962b54006dcfcc61cb72735f4d89bb97061dd6a7ed882ec6b8ee53714c6f"
 dependencies = [
  "jobserver",
  "libc",
+ "shlex",
 ]
 
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -1088,6 +973,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "cfg_eval"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45565fc9416b9896014f5732ac776f810ee53a66730c17e4020c3ec064a8f88f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "cgen"
 version = "0.1.0"
@@ -1097,9 +993,9 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -1107,7 +1003,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-targets 0.52.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1121,11 +1017,12 @@ dependencies = [
 
 [[package]]
 name = "cipher"
-version = "0.3.0"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
 dependencies = [
- "generic-array 0.14.7",
+ "crypto-common",
+ "inout",
 ]
 
 [[package]]
@@ -1150,7 +1047,7 @@ dependencies = [
  "bitflags 1.3.2",
  "strsim 0.8.0",
  "textwrap 0.11.0",
- "unicode-width",
+ "unicode-width 0.1.9",
  "vec_map",
 ]
 
@@ -1162,8 +1059,7 @@ checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123"
 dependencies = [
  "atty",
  "bitflags 1.3.2",
- "clap_derive 3.2.25",
- "clap_lex 0.2.4",
+ "clap_lex",
  "indexmap 1.9.3",
  "once_cell",
  "strsim 0.10.0",
@@ -1171,53 +1067,6 @@ dependencies = [
  "textwrap 0.16.0",
 ]
 
-[[package]]
-name = "clap"
-version = "4.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64"
-dependencies = [
- "clap_builder",
- "clap_derive 4.4.7",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex 0.6.0",
- "strsim 0.10.0",
-]
-
-[[package]]
-name = "clap_derive"
-version = "3.2.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae6371b8bdc8b7d3959e9cf7b22d4435ef3e79e138688421ec654acf8c81b008"
-dependencies = [
- "heck 0.4.1",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
-dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "quote",
- "syn 2.0.46",
-]
-
 [[package]]
 name = "clap_lex"
 version = "0.2.4"
@@ -1227,12 +1076,6 @@ dependencies = [
  "os_str_bytes",
 ]
 
-[[package]]
-name = "clap_lex"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
-
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
@@ -1240,15 +1083,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
  "termcolor",
- "unicode-width",
+ "unicode-width 0.1.9",
 ]
 
-[[package]]
-name = "colorchoice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
-
 [[package]]
 name = "combine"
 version = "3.8.1"
@@ -1262,26 +1099,36 @@ dependencies = [
  "unreachable",
 ]
 
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
 [[package]]
 name = "concurrent-queue"
-version = "2.2.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62ec6771ecfa0762d24683ee5a32ad78487a3d3afdc0fb8cae19d2c5deb50b7c"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "ea3c6ecd8059b57859df5c69830340ed3c41d30e3da0c1cbed90a96ac853041b"
 dependencies = [
  "encode_unicode",
- "lazy_static",
  "libc",
- "unicode-width",
- "windows-sys 0.52.0",
+ "once_cell",
+ "unicode-width 0.2.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1304,12 +1151,6 @@ dependencies = [
  "web-sys",
 ]
 
-[[package]]
-name = "const-oid"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3"
-
 [[package]]
 name = "constant_time_eq"
 version = "0.3.0"
@@ -1352,9 +1193,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.1"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
 dependencies = [
  "libc",
 ]
@@ -1370,9 +1211,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.11"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176dc175b78f56c0f321911d9c8eb2b77a78a4860b9c19db83835fea1a46649b"
+checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -1415,11 +1256,12 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.3"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.7",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -1435,27 +1277,55 @@ dependencies = [
 
 [[package]]
 name = "ctr"
-version = "0.8.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
 dependencies = [
  "cipher",
 ]
 
 [[package]]
 name = "curve25519-dalek"
-version = "3.2.1"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
+checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
 dependencies = [
  "byteorder",
  "digest 0.9.0",
  "rand_core 0.5.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "rand_core 0.6.4",
+ "rustc_version",
  "serde",
  "subtle",
  "zeroize",
 ]
 
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "cxx"
 version = "1.0.80"
@@ -1521,7 +1391,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.10.0",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1532,7 +1402,7 @@ checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1542,7 +1412,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
  "cfg-if 1.0.0",
- "hashbrown 0.14.1",
+ "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
  "parking_lot_core 0.9.9",
@@ -1556,28 +1426,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
 
 [[package]]
-name = "der"
-version = "0.5.1"
+name = "der-parser"
+version = "8.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6919815d73839e7ad218de758883aae3a257ba6759ce7a9992501efbb53d705c"
-dependencies = [
- "const-oid",
-]
-
-[[package]]
-name = "der-parser"
-version = "8.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d4bc9b0db0a0df9ae64634ac5bdefb7afcb534e182275ca0beadbe486701c1"
+checksum = "42d4bc9b0db0a0df9ae64634ac5bdefb7afcb534e182275ca0beadbe486701c1"
 dependencies = [
  "asn1-rs",
  "displaydoc",
  "nom",
- "num-bigint 0.4.4",
+ "num-bigint 0.4.6",
  "num-traits",
  "rusticata-macros",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "derivation-path"
 version = "0.2.0"
@@ -1597,13 +1467,13 @@ dependencies = [
 
 [[package]]
 name = "derive_arbitrary"
-version = "1.3.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+checksum = "d475dfebcb4854d596b17b09f477616f80f17a550517f2b3615d8c205d5c802b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1727,15 +1597,9 @@ checksum = "a6cbae11b3de8fce2a456e8ea3dada226b35fe791f0dc1d360c0941f0bb681f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
-[[package]]
-name = "doc-comment"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
-
 [[package]]
 name = "downcast"
 version = "0.11.0"
@@ -1763,11 +1627,11 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
 dependencies = [
- "curve25519-dalek",
+ "curve25519-dalek 3.2.0",
  "ed25519",
  "rand 0.7.3",
  "serde",
- "sha2 0.9.8",
+ "sha2 0.9.9",
  "zeroize",
 ]
 
@@ -1803,9 +1667,9 @@ checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
 
 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "encoding_rs"
@@ -1833,7 +1697,7 @@ checksum = "03cdc46ec28bd728e67540c528013c6a10eb69a02eb31078a1bda695438cbfb8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1842,7 +1706,7 @@ version = "3.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b166c9e378360dd5a6666a9604bb4f54ae0cac39023ffbac425e917a2a04fef"
 dependencies = [
- "num-bigint 0.4.4",
+ "num-bigint 0.4.6",
  "num-traits",
  "proc-macro2",
  "quote",
@@ -1858,7 +1722,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1890,15 +1754,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "escape8259"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4911e3666fcd7826997b4745c8224295a6f3072f1418c3067b97a67557ee"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "etcd-client"
 version = "0.11.1"
@@ -1921,6 +1776,27 @@ version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71"
 
+[[package]]
+name = "event-listener"
+version = "5.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
+dependencies = [
+ "event-listener 5.3.1",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "fake-simd"
 version = "0.1.2"
@@ -1938,9 +1814,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
 [[package]]
 name = "feature-probe"
@@ -1948,6 +1824,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "835a3dc7d1ec9e75e2b5fb4ba75396837112d2060b03f7d43bc1897c7f7211da"
 
+[[package]]
+name = "fiat-crypto"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
+
 [[package]]
 name = "filetime"
 version = "0.2.15"
@@ -1960,6 +1842,21 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "five8_const"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b4f62f0f8ca357f93ae90c8c2dd1041a1f665fde2f889ea9b1787903829015"
+dependencies = [
+ "five8_core",
+]
+
+[[package]]
+name = "five8_core"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94474d15a76982be62ca8a39570dccce148d98c238ebb7408b0a21b2c4bdddc4"
+
 [[package]]
 name = "fixedbitset"
 version = "0.4.1"
@@ -1972,17 +1869,17 @@ version = "1.0.0"
 dependencies = [
  "arrayref",
  "solana-program",
- "spl-token 4.0.1",
+ "spl-token 7.0.0",
 ]
 
 [[package]]
 name = "flate2"
-version = "1.0.28"
+version = "1.0.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
 dependencies = [
  "crc32fast",
- "miniz_oxide",
+ "miniz_oxide 0.8.0",
 ]
 
 [[package]]
@@ -2044,9 +1941,9 @@ checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
 
 [[package]]
 name = "futures"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -2059,9 +1956,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -2069,15 +1966,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -2087,38 +1984,44 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures 0.1.31",
  "futures-channel",
@@ -2208,7 +2111,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
 dependencies = [
  "aho-corasick 0.7.18",
- "bstr 0.2.17",
+ "bstr",
  "fnv",
  "log",
  "regex",
@@ -2221,7 +2124,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8af59a261bcf42f45d1b261232847b9b850ba0a1419d6100698246fb66e9240"
 dependencies = [
  "arc-swap",
- "futures 0.3.30",
+ "futures 0.3.31",
  "log",
  "reqwest",
  "serde",
@@ -2234,14 +2137,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "goblin"
-version = "0.5.4"
+name = "governor"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7666983ed0dd8d21a6f6576ee00053ca0926fb281a5522577a4dbd0f1b54143"
+checksum = "68a7f542ee6b35af73b06abc0dad1c1bae89964e4e253bc4b587b91c9637867b"
 dependencies = [
- "log",
- "plain",
- "scroll",
+ "cfg-if 1.0.0",
+ "dashmap",
+ "futures 0.3.31",
+ "futures-timer",
+ "no-std-compat",
+ "nonzero_ext",
+ "parking_lot 0.12.0",
+ "portable-atomic",
+ "quanta",
+ "rand 0.8.5",
+ "smallvec",
+ "spinning_top",
 ]
 
 [[package]]
@@ -2256,7 +2168,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http",
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "slab",
  "tokio",
  "tokio-util 0.7.1",
@@ -2274,36 +2186,37 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.11.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 dependencies = [
  "ahash 0.7.8",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash 0.7.8",
+ "ahash 0.8.11",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
- "ahash 0.8.9",
+ "ahash 0.8.11",
+ "allocator-api2",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.14.1"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12"
+checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
 
 [[package]]
 name = "headers"
@@ -2345,12 +2258,6 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -2362,9 +2269,9 @@ dependencies = [
 
 [[package]]
 name = "hermit-abi"
-version = "0.3.3"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
 [[package]]
 name = "hex"
@@ -2374,14 +2281,15 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hidapi"
-version = "2.4.1"
+version = "2.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "723777263b0dcc5730aec947496bd8c3940ba63c15f5633b288cc615f4f6af79"
+checksum = "03b876ecf37e86b359573c16c8366bc3eba52b689884a0fc42ba3f67203d2a8b"
 dependencies = [
  "cc",
+ "cfg-if 1.0.0",
  "libc",
  "pkg-config",
- "winapi 0.3.9",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2434,9 +2342,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
 dependencies = [
  "bytes",
  "fnv",
@@ -2474,9 +2382,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "hyper"
-version = "0.14.28"
+version = "0.14.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+checksum = "8c08302e8fa335b151b788c775ff56e7a03ae64ff85c548ee820fecb70356e85"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2503,7 +2411,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca815a891b24fdfb243fa3239c86154392b0953ee584aa1a2a1f66d20cbe75cc"
 dependencies = [
  "bytes",
- "futures 0.3.30",
+ "futures 0.3.31",
  "headers",
  "http",
  "hyper",
@@ -2523,7 +2431,7 @@ dependencies = [
  "futures-util",
  "http",
  "hyper",
- "rustls",
+ "rustls 0.21.12",
  "tokio",
  "tokio-rustls",
 ]
@@ -2647,9 +2555,9 @@ dependencies = [
 
 [[package]]
 name = "index_list"
-version = "0.2.11"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70891286cb8e844fdfcf1178b47569699f9e20b5ecc4b45a6240a64771444638"
+checksum = "4e6ba961c14e98151cd6416dd3685efe786a94c38bc1a535c06ceff0a1600813"
 
 [[package]]
 name = "indexmap"
@@ -2659,32 +2567,39 @@ checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
- "serde",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.2.1"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "433de089bd45971eecf4668ee0ee8f4cec17db4f8bd8f7bc3197a6ce37aa7d9b"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.1",
+ "hashbrown 0.15.1",
  "rayon",
- "serde",
 ]
 
 [[package]]
 name = "indicatif"
-version = "0.17.7"
+version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb28741c9db9a713d93deb3bb9515c20788cef5815265bee4980e87bde7e0f25"
+checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
 dependencies = [
  "console",
  "instant",
  "number_prefix",
  "portable-atomic",
- "unicode-width",
+ "unicode-width 0.1.9",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -2711,26 +2626,55 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
 
+[[package]]
+name = "jni"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec"
+dependencies = [
+ "cesu8",
+ "combine 4.6.7",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
 [[package]]
 name = "jobserver"
-version = "0.1.24"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.67"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a1d36f1235bc969acba30b7f5990b864423a6068a10f7c90ae8f0112e3a59d1"
+checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -2753,7 +2697,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2b99d4207e2a04fb4581746903c2bb7eb376f88de9c699d0f3e10feeac0cd3a"
 dependencies = [
  "derive_more",
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-core",
  "jsonrpc-pubsub",
  "log",
@@ -2768,7 +2712,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "futures-executor",
  "futures-util",
  "log",
@@ -2783,7 +2727,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b51da17abecbdab3e3d4f26b01c5ec075e88d3abe3ab3b05dc9aa69392764ec0"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-client-transports",
 ]
 
@@ -2805,7 +2749,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1dea6e07251d9ce6a552abfb5d7ad6bc290a4596c8dcc3d795fae2bbdc1f3ff"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "hyper",
  "jsonrpc-core",
  "jsonrpc-server-utils",
@@ -2821,7 +2765,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240f87695e6c6f62fb37f05c02c04953cf68d6408b8c1c89de85c7a0125b1011"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-core",
  "lazy_static",
  "log",
@@ -2837,7 +2781,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4fdea130485b572c39a460d50888beb00afb3e35de23ccd7fad8ff19f0e0d4"
 dependencies = [
  "bytes",
- "futures 0.3.30",
+ "futures 0.3.31",
  "globset",
  "jsonrpc-core",
  "lazy_static",
@@ -2867,11 +2811,20 @@ dependencies = [
  "winapi-build",
 ]
 
+[[package]]
+name = "lazy-lru"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b031495510a5a17bfb14e9f1fc00f6efdebfaa9ab04a876a4e153b042a3fe06"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lazycell"
@@ -2881,9 +2834,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.152"
+version = "0.2.161"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
+checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
 
 [[package]]
 name = "libloading"
@@ -2897,15 +2850,15 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.8"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
 
 [[package]]
 name = "librocksdb-sys"
-version = "0.11.0+8.1.1"
+version = "0.16.0+8.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3386f101bcb4bd252d8e9d2fb41ec3b0862a15a62b478c355b2982efa469e3e"
+checksum = "ce3d60bc059831dc1c83903fb45c103f75db65c5a7bf22272764d9cc683e348c"
 dependencies = [
  "bindgen",
  "bzip2-sys",
@@ -2931,7 +2884,7 @@ dependencies = [
  "libsecp256k1-gen-genmult",
  "rand 0.7.3",
  "serde",
- "sha2 0.9.8",
+ "sha2 0.9.9",
  "typenum",
 ]
 
@@ -2964,18 +2917,6 @@ dependencies = [
  "libsecp256k1-core",
 ]
 
-[[package]]
-name = "libtest-mimic"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc0bda45ed5b3a2904262c1bb91e526127aa70e7ef3758aba2ef93cf896b9b58"
-dependencies = [
- "clap 4.4.8",
- "escape8259",
- "termcolor",
- "threadpool",
-]
-
 [[package]]
 name = "libz-sys"
 version = "1.1.5"
@@ -2995,8 +2936,8 @@ checksum = "3c9a85a9752c549ceb7578064b4ed891179d20acd85f27318573b64d2d7ee7ee"
 dependencies = [
  "ark-bn254",
  "ark-ff",
- "num-bigint 0.4.4",
- "thiserror",
+ "num-bigint 0.4.6",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -3010,9 +2951,9 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
 name = "lock_api"
@@ -3026,9 +2967,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.20"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lru"
@@ -3041,19 +2982,18 @@ dependencies = [
 
 [[package]]
 name = "lz4"
-version = "1.24.0"
+version = "1.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9e2dd86df36ce760a60f6ff6ad526f7ba1f14ba0356f8254fb6905e6494df1"
+checksum = "4d1febb2b4a79ddd1980eede06a8f7902197960aa0383ffcfdd62fe723036725"
 dependencies = [
- "libc",
  "lz4-sys",
 ]
 
 [[package]]
 name = "lz4-sys"
-version = "1.9.4"
+version = "1.11.1+lz4-1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57d27b317e207b10f69f5e75494119e391a96f48861ae870d1da6edac98ca900"
+checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6"
 dependencies = [
  "cc",
  "libc",
@@ -3110,15 +3050,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "memoffset"
 version = "0.9.0"
@@ -3146,6 +3077,16 @@ version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
 
+[[package]]
+name = "mime_guess"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "min-max-heap"
 version = "1.3.0"
@@ -3167,15 +3108,25 @@ dependencies = [
  "adler",
 ]
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+dependencies = [
+ "adler2",
+]
+
 [[package]]
 name = "mio"
-version = "0.8.11"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+checksum = "4569e456d394deccd22ce1c1913e6ea0e54519f577285001215d33557431afe4"
 dependencies = [
+ "hermit-abi 0.3.9",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3189,7 +3140,7 @@ dependencies = [
  "fragile",
  "lazy_static",
  "mockall_derive",
- "predicates 2.1.5",
+ "predicates",
  "predicates-tree",
 ]
 
@@ -3263,17 +3214,23 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.26.4"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
+ "cfg_aliases",
  "libc",
- "memoffset 0.7.1",
- "pin-utils",
+ "memoffset 0.9.0",
 ]
 
+[[package]]
+name = "no-std-compat"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
+
 [[package]]
 name = "nom"
 version = "7.1.1"
@@ -3284,6 +3241,12 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nonzero_ext"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bf9645c8b145698bb0b18a4637dcacbc421ea49bef2317e4fd8065a387cf21"
+
 [[package]]
 name = "normalize-line-endings"
 version = "0.3.0"
@@ -3317,11 +3280,10 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.4"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
- "autocfg",
  "num-integer",
  "num-traits",
 ]
@@ -3337,15 +3299,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "num-derive"
-version = "0.3.3"
+name = "num-conv"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
 [[package]]
 name = "num-derive"
@@ -3355,16 +3312,15 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "num-integer"
-version = "0.1.44"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
@@ -3407,50 +3363,29 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.3.3",
+ "hermit-abi 0.3.9",
  "libc",
 ]
 
 [[package]]
 name = "num_enum"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1"
-dependencies = [
- "num_enum_derive 0.6.1",
-]
-
-[[package]]
-name = "num_enum"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
-dependencies = [
- "num_enum_derive 0.7.2",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.6.1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
+checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
 dependencies = [
- "proc-macro-crate 1.1.0",
- "proc-macro2",
- "quote",
- "syn 2.0.46",
+ "num_enum_derive",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
+checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
 dependencies = [
  "proc-macro-crate 3.1.0",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -3497,11 +3432,11 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
 [[package]]
 name = "openssl"
-version = "0.10.60"
+version = "0.10.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79a4c6c3a2b158f7f8f2a2fc5a969fa3a068df6fc9dbb4a43845436e3af7c800"
+checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
  "foreign-types",
  "libc",
@@ -3529,18 +3464,18 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-src"
-version = "300.1.6+3.1.4"
+version = "300.3.1+3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439fac53e092cd7442a3660c85dde4643ab3b5bd39040912388dcdabf6b88085"
+checksum = "7259953d42a81bf137fbbd73bd30a8e1914d6dce43c2b90ed575783a22608b91"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.96"
+version = "0.9.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3812c071ba60da8b5677cc12bcb1d42989a65553772897a7e0355545a819838f"
+checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
 dependencies = [
  "cc",
  "libc",
@@ -3565,7 +3500,7 @@ dependencies = [
  "percent-encoding 2.3.1",
  "pin-project",
  "rand 0.8.5",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -3575,27 +3510,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
 
 [[package]]
-name = "ouroboros"
-version = "0.15.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1358bd1558bd2a083fed428ffeda486fbfb323e698cdda7794259d592ca72db"
-dependencies = [
- "aliasable",
- "ouroboros_macro",
-]
-
-[[package]]
-name = "ouroboros_macro"
-version = "0.15.6"
+name = "parking"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f7d21ccd03305a674437ee1248f3ab5d4b1db095cf1caf49f1713ddf61956b7"
-dependencies = [
- "Inflector",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"
@@ -3669,12 +3587,6 @@ dependencies = [
  "digest 0.10.7",
 ]
 
-[[package]]
-name = "peeking_take_while"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
-
 [[package]]
 name = "pem"
 version = "1.1.1"
@@ -3775,7 +3687,7 @@ checksum = "39407670928234ebc5e6e580247dd567ad73a3578460c5990f9503df207e8f07"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -3790,34 +3702,17 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
-[[package]]
-name = "pkcs8"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cabda3fb821068a9a4fab19a683eac3af12edf0f34b94a8be53c4972b8149d0"
-dependencies = [
- "der",
- "spki",
- "zeroize",
-]
-
 [[package]]
 name = "pkg-config"
 version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
 
-[[package]]
-name = "plain"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
-
 [[package]]
 name = "polyval"
-version = "0.5.3"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8419d2b623c7c0896ff2d5d96e2cb4ede590fed28fcc34934f4c33c036e620a1"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
@@ -3827,9 +3722,15 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.3.3"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "767eb9f07d4a5ebcb39bbf2d452058a93c011373abf6832e24194a1c3f004794"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
@@ -3845,24 +3746,12 @@ checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
 dependencies = [
  "difflib",
  "float-cmp",
- "itertools",
+ "itertools 0.10.5",
  "normalize-line-endings",
  "predicates-core",
  "regex",
 ]
 
-[[package]]
-name = "predicates"
-version = "3.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9"
-dependencies = [
- "anstyle",
- "difflib",
- "itertools",
- "predicates-core",
-]
-
 [[package]]
 name = "predicates-core"
 version = "1.0.6"
@@ -3895,38 +3784,21 @@ dependencies = [
  "syn 1.0.107",
 ]
 
-[[package]]
-name = "prettyplease"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ceca8aaf45b5c46ec7ed39fff75f57290368c1846d33d24a122ca81416ab058"
-dependencies = [
- "proc-macro2",
- "syn 2.0.46",
-]
-
 [[package]]
 name = "prio-graph"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6492a75ca57066a4479af45efa302bed448680182b0563f96300645d5f896097"
-
-[[package]]
-name = "proc-macro-crate"
-version = "0.1.5"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785"
+checksum = "2f28921629370a46cf564f6ba1828bd8d1c97f7fad4ee9d1c6438f92feed6b8d"
 dependencies = [
- "toml",
+ "ahash 0.8.11",
 ]
 
 [[package]]
 name = "proc-macro-crate"
-version = "1.1.0"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebace6889caf889b4d3f76becee12e90353f2b8c7d875534a71e5742f8f6f83"
+checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785"
 dependencies = [
- "thiserror",
  "toml",
 ]
 
@@ -3965,22 +3837,22 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.78"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "proptest"
-version = "1.4.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
+checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.4.2",
+ "bitflags 2.6.0",
  "lazy_static",
  "num-traits",
  "rand 0.8.5",
@@ -4010,12 +3882,12 @@ checksum = "119533552c9a7ffacc21e099c24a0ac8bb19c2a2a3f363de84cd9b844feab270"
 dependencies = [
  "bytes",
  "heck 0.4.1",
- "itertools",
+ "itertools 0.10.5",
  "lazy_static",
  "log",
  "multimap",
  "petgraph",
- "prettyplease 0.1.9",
+ "prettyplease",
  "prost",
  "prost-types",
  "regex",
@@ -4031,7 +3903,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
 dependencies = [
  "anyhow",
- "itertools",
+ "itertools 0.10.5",
  "proc-macro2",
  "quote",
  "syn 1.0.107",
@@ -4072,7 +3944,22 @@ checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "quanta"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5167a477619228a0b284fac2674e3c388cba90631d7b7de620e6f1fcd08da5"
+dependencies = [
+ "crossbeam-utils",
+ "libc",
+ "once_cell",
+ "raw-cpuid",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "web-sys",
+ "winapi 0.3.9",
 ]
 
 [[package]]
@@ -4083,50 +3970,52 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quinn"
-version = "0.10.2"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cc2c5017e4b43d5995dcea317bc46c1e09404c0a9664d2908f7f02dfe943d75"
+checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
 dependencies = [
  "bytes",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash",
- "rustls",
- "thiserror",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.18",
+ "socket2",
+ "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "quinn-proto"
-version = "0.10.6"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "141bf7dfde2fbc246bfd3fe12f2455aa24b0fbd9af535d8c86c7bd1381ff2b1a"
+checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
 dependencies = [
  "bytes",
  "rand 0.8.5",
- "ring 0.16.20",
- "rustc-hash",
- "rustls",
- "rustls-native-certs",
+ "ring 0.17.3",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.18",
+ "rustls-platform-verifier",
  "slab",
- "thiserror",
+ "thiserror 1.0.69",
  "tinyvec",
  "tracing",
 ]
 
 [[package]]
 name = "quinn-udp"
-version = "0.4.1"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
+checksum = "e346e016eacfff12233c243718197ca12f148c84e1e84268a896699b41c71780"
 dependencies = [
- "bytes",
+ "cfg_aliases",
  "libc",
+ "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4237,11 +4126,20 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "raw-cpuid"
+version = "11.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ab240315c661615f2ee9f0f2cd32d5a7343a84d5ebcccb99d46e6637565e7b0"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
 [[package]]
 name = "rayon"
-version = "1.8.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
  "either",
  "rayon-core",
@@ -4257,18 +4155,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "rcgen"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b"
-dependencies = [
- "pem",
- "ring 0.16.20",
- "time",
- "yasna",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.2.10"
@@ -4314,27 +4200,21 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick 1.0.2",
  "memchr",
- "regex-automata 0.4.5",
+ "regex-automata",
  "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa250384981ea14565685dea16a9ccc4d1c541a13f82b9c168572264d1df8c56"
-
-[[package]]
-name = "regex-automata"
-version = "0.4.5"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
  "aho-corasick 1.0.2",
  "memchr",
@@ -4343,15 +4223,15 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "reqwest"
-version = "0.11.23"
+version = "0.11.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b1ae8d9ac08420c66222fb9096fc5de435c3c48542bc5336c51892cffafb41"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
 dependencies = [
  "async-compression",
  "base64 0.21.7",
@@ -4369,22 +4249,24 @@ dependencies = [
  "js-sys",
  "log",
  "mime",
+ "mime_guess",
  "native-tls",
  "once_cell",
  "percent-encoding 2.3.1",
  "pin-project-lite",
- "rustls",
+ "rustls 0.21.12",
  "rustls-pemfile 1.0.1",
  "serde",
  "serde_json",
  "serde_urlencoded",
+ "sync_wrapper",
  "system-configuration",
  "tokio",
  "tokio-native-tls",
  "tokio-rustls",
  "tokio-util 0.7.1",
  "tower-service",
- "url 2.5.0",
+ "url 2.5.2",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
@@ -4392,6 +4274,21 @@ dependencies = [
  "winreg",
 ]
 
+[[package]]
+name = "reqwest-middleware"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a735987236a8e238bf0296c7e351b999c188ccc11477f311b82b55c93984216"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "http",
+ "reqwest",
+ "serde",
+ "task-local-extensions",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "ring"
 version = "0.16.20"
@@ -4423,9 +4320,9 @@ dependencies = [
 
 [[package]]
 name = "rocksdb"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb6f170a4041d50a0ce04b0d2e14916d6ca863ea2e422689a5b694395d299ffe"
+checksum = "6bd13e55d6d7b8cd0ea569161127567cd587676c99f4472f779a0279aa60a7a7"
 dependencies = [
  "libc",
  "librocksdb-sys",
@@ -4479,6 +4376,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.0"
@@ -4499,11 +4402,11 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.31"
+version = "0.38.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+checksum = "375116bee2be9ed569afe2154ea6a99dfdffd257f533f187498c2a8f5feaf4ee"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -4512,46 +4415,94 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.21.11"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
  "ring 0.17.3",
- "rustls-webpki",
+ "rustls-webpki 0.101.7",
  "sct",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.23.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9cc1d47e243d655ace55ed38201c19ae02c148ae56412ab8750e8f0166ab7f"
+dependencies = [
+ "once_cell",
+ "ring 0.17.3",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
+]
+
 [[package]]
 name = "rustls-native-certs"
-version = "0.6.1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca9ebdfa27d3fc180e42879037b5338ab1c040c06affd00d8338598e7800943"
+checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5"
 dependencies = [
  "openssl-probe",
- "rustls-pemfile 0.2.1",
+ "rustls-pemfile 2.2.0",
+ "rustls-pki-types",
  "schannel",
  "security-framework",
 ]
 
 [[package]]
 name = "rustls-pemfile"
-version = "0.2.1"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eebeaeb360c87bfb72e84abdb3447159c0eaececf1bef2aecd65a8be949d1c9"
+checksum = "0864aeff53f8c05aa08d86e5ef839d3dfcf07aeba2db32f12db0ef716e87bd55"
 dependencies = [
  "base64 0.13.0",
 ]
 
 [[package]]
 name = "rustls-pemfile"
-version = "1.0.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0864aeff53f8c05aa08d86e5ef839d3dfcf07aeba2db32f12db0ef716e87bd55"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
 dependencies = [
- "base64 0.13.0",
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16f1201b3c9a7ee8039bcadc17b7e605e2945b27eee7631788c1bd2b0643674b"
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afbb878bdfdf63a336a5e63561b1835e7a8c91524f51621db870169eac84b490"
+dependencies = [
+ "core-foundation",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls 0.23.18",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki 0.102.8",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-roots 0.26.6",
+ "winapi 0.3.9",
 ]
 
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.101.7"
@@ -4562,11 +4513,22 @@ dependencies = [
  "untrusted 0.9.0",
 ]
 
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring 0.17.3",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
 [[package]]
 name = "rustversion"
-version = "1.0.14"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
 name = "rusty-fork"
@@ -4595,15 +4557,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "scc"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec96560eea317a9cc4e0bb1f6a2c93c09a19b8c4fc5cb3fcc0ec1c094cd783e2"
-dependencies = [
- "sdd",
-]
-
 [[package]]
 name = "schannel"
 version = "0.1.19"
@@ -4631,20 +4584,6 @@ name = "scroll"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04c565b551bafbef4157586fa379538366e4385d42082f255bfd96e4fe8519da"
-dependencies = [
- "scroll_derive",
-]
-
-[[package]]
-name = "scroll_derive"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbda6ac5cd1321e724fa9cee216f3a61885889b896f073b8f82322789c5250e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
 
 [[package]]
 name = "sct"
@@ -4656,30 +4595,25 @@ dependencies = [
  "untrusted 0.7.1",
 ]
 
-[[package]]
-name = "sdd"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b84345e4c9bd703274a082fb80caaa99b7612be48dfaa1dd9266577ec412309d"
-
 [[package]]
 name = "security-framework"
-version = "2.6.1"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dc14f172faf8a0194a3aded622712b0de276821addc574fa54fc0a1167e10dc"
+checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation",
  "core-foundation-sys",
  "libc",
+ "num-bigint 0.4.6",
  "security-framework-sys",
 ]
 
 [[package]]
 name = "security-framework-sys"
-version = "2.6.1"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556"
+checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -4687,9 +4621,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 
 [[package]]
 name = "seqlock"
@@ -4702,40 +4636,41 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_bytes"
-version = "0.11.14"
+version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734"
+checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.135"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "2b0d7ba2887406110130a978386c4e1befb98c674b4fba677954e4db976630d9"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
@@ -4754,54 +4689,25 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "2.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07ff71d2c147a7b57362cead5e22f772cd52f6ab31cfcd9edcd7f6aeb2a0afbe"
-dependencies = [
- "serde",
- "serde_with_macros 2.3.3",
-]
-
-[[package]]
-name = "serde_with"
-version = "3.8.1"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20"
+checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa"
 dependencies = [
- "base64 0.22.1",
- "chrono",
- "hex",
- "indexmap 1.9.3",
- "indexmap 2.2.1",
  "serde",
  "serde_derive",
- "serde_json",
- "serde_with_macros 3.8.1",
- "time",
-]
-
-[[package]]
-name = "serde_with_macros"
-version = "2.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "881b6f881b17d13214e5d494c939ebab463d01264ce1811e9d4ac3a882e7695f"
-dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn 2.0.46",
+ "serde_with_macros",
 ]
 
 [[package]]
 name = "serde_with_macros"
-version = "3.8.1"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
+checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e"
 dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -4810,38 +4716,13 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "itoa",
  "ryu",
  "serde",
  "unsafe-libyaml",
 ]
 
-[[package]]
-name = "serial_test"
-version = "3.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b4b487fe2acf240a021cf57c6b2b4903b1e78ca0ecd862a71b71d2a51fed77d"
-dependencies = [
- "futures 0.3.30",
- "log",
- "once_cell",
- "parking_lot 0.12.0",
- "scc",
- "serial_test_derive",
-]
-
-[[package]]
-name = "serial_test_derive"
-version = "3.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82fe9db325bcef1fbcde82e078a5cc4efdf787e96b3b9cf45b50b529f2083d67"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.46",
-]
-
 [[package]]
 name = "sha-1"
 version = "0.8.2"
@@ -4891,9 +4772,9 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
+checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
 dependencies = [
  "block-buffer 0.9.0",
  "cfg-if 1.0.0",
@@ -4913,18 +4794,6 @@ dependencies = [
  "digest 0.10.7",
 ]
 
-[[package]]
-name = "sha3"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
-dependencies = [
- "block-buffer 0.9.0",
- "digest 0.9.0",
- "keccak",
- "opaque-debug 0.3.0",
-]
-
 [[package]]
 name = "sha3"
 version = "0.10.8"
@@ -5072,12 +4941,12 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.5"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -5088,21 +4957,35 @@ checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2"
 dependencies = [
  "base64 0.13.0",
  "bytes",
- "futures 0.3.30",
+ "futures 0.3.31",
  "httparse",
  "log",
  "rand 0.8.5",
  "sha-1 0.9.8",
 ]
 
+[[package]]
+name = "solana-account"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "730219420b206253977b8cc8fd7846ffe021ab2e2c718e70db420efbd2775547"
+dependencies = [
+ "bincode",
+ "serde",
+ "serde_bytes",
+ "serde_derive",
+ "solana-instruction",
+ "solana-program",
+]
+
 [[package]]
 name = "solana-account-decoder"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff098f24024f1046d9ba778c48b9a68c590c15cf5c42af67e2578a240fb141a4"
+checksum = "14e5b1c167335942b659d077552607f79b2eca3472e40eeed97a2c55838b84ef"
 dependencies = [
  "Inflector",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "bs58",
  "bv",
@@ -5110,242 +4993,330 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
+ "solana-account-decoder-client-types",
  "solana-config-program",
  "solana-sdk",
- "spl-token 4.0.0",
- "spl-token-2022 1.0.0",
- "spl-token-group-interface 0.1.0",
- "spl-token-metadata-interface 0.2.0",
- "thiserror",
+ "spl-token 6.0.0",
+ "spl-token-2022 4.0.0",
+ "spl-token-group-interface 0.3.0",
+ "spl-token-metadata-interface 0.4.0",
+ "thiserror 1.0.69",
+ "zstd",
+]
+
+[[package]]
+name = "solana-account-decoder-client-types"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee0750d2f106ecbee6d4508b6e2029e6946cb5f67288bf002b5a62f9f451c43"
+dependencies = [
+ "base64 0.22.1",
+ "bs58",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "solana-account",
+ "solana-pubkey",
  "zstd",
 ]
 
+[[package]]
+name = "solana-account-info"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6abe81cfc4a75f71a510c6856b03a7d8525e416af3c69d55daef62e6078b8d40"
+dependencies = [
+ "bincode",
+ "serde",
+ "solana-program-error",
+ "solana-program-memory",
+ "solana-pubkey",
+]
+
 [[package]]
 name = "solana-accounts-db"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8b18106c7a95d34a30030d00100ed2c212ece3ec166bc65ae9f4f6906ddf01e"
+checksum = "b9fecc332ad4edd98ed63e5a46d990ecaf6fe4abd2bf9795c15474a64534ced6"
 dependencies = [
- "arrayref",
+ "ahash 0.8.11",
  "bincode",
  "blake3",
  "bv",
  "bytemuck",
- "byteorder",
+ "bytemuck_derive",
  "bzip2",
  "crossbeam-channel",
  "dashmap",
- "flate2",
- "fnv",
- "im",
  "index_list",
- "itertools",
+ "indexmap 2.6.0",
+ "itertools 0.12.1",
  "lazy_static",
  "log",
  "lz4",
  "memmap2 0.5.10",
  "modular-bitfield",
- "num-derive 0.4.2",
- "num-traits",
  "num_cpus",
- "num_enum 0.7.2",
- "ouroboros",
- "percentage",
- "qualifier_attr",
+ "num_enum",
  "rand 0.8.5",
  "rayon",
- "regex",
- "rustc_version",
  "seqlock",
  "serde",
  "serde_derive",
  "smallvec",
  "solana-bucket-map",
- "solana-config-program",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-inline-spl",
+ "solana-lattice-hash",
  "solana-measure",
  "solana-metrics",
  "solana-nohash-hasher",
- "solana-program-runtime",
  "solana-rayon-threadlimit",
  "solana-sdk",
- "solana-stake-program",
- "solana-system-program",
- "solana-vote-program",
+ "solana-svm-transaction",
  "static_assertions",
- "strum 0.24.1",
- "strum_macros 0.24.3",
  "tar",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-address-lookup-table-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20d61283a078fbcac0690852434fb848e0cbf1a62e6c7b3472a8656459933134"
+checksum = "2cf79a76f2878982b9781dfd0831d58ee15eb905be65406ccf7370c3ecd69c52"
 dependencies = [
  "bincode",
  "bytemuck",
  "log",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "rustc_version",
- "serde",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-feature-set",
+ "solana-log-collector",
  "solana-program",
  "solana-program-runtime",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-atomic-u64"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "391b795afcdcad39ddc6c938d64b789d036cdfe00d9dc5ff83024cf2da9f066f"
+dependencies = [
+ "parking_lot 0.12.0",
 ]
 
 [[package]]
 name = "solana-banks-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1630817c0df2ca64afd07e850b2a439f55dab75850008c1f3d6378d55f43a43"
+checksum = "2f857fb6590467d433f40eee507666ca496ec67907e50b7d530b6c04f6541875"
 dependencies = [
- "borsh 1.5.1",
- "futures 0.3.30",
+ "borsh 1.5.3",
+ "futures 0.3.31",
  "solana-banks-interface",
  "solana-program",
  "solana-sdk",
  "tarpc",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-serde",
 ]
 
 [[package]]
 name = "solana-banks-interface"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c6eef1d6b792eb16b3a214916736f5e211ef7b2c3f6344ef753f5054d6b648d"
+checksum = "20052d231bb9ac3268dc61a713e3915d6c95fc942f9a5c15ca3a81a3fcd9cc12"
 dependencies = [
  "serde",
+ "serde_derive",
  "solana-sdk",
  "tarpc",
 ]
 
 [[package]]
 name = "solana-banks-server"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbc2173ccec80fa07f075d054461e678397fa7fd7c16d18fae16b2e9d3c57320"
+checksum = "10db60e4bf077b870a7e75f8596bf3790d079b3762e9b4edc032475077007d0b"
 dependencies = [
  "bincode",
  "crossbeam-channel",
- "futures 0.3.30",
- "solana-accounts-db",
+ "futures 0.3.31",
  "solana-banks-interface",
  "solana-client",
+ "solana-feature-set",
  "solana-runtime",
  "solana-sdk",
  "solana-send-transaction-service",
+ "solana-svm",
  "tarpc",
  "tokio",
  "tokio-serde",
 ]
 
+[[package]]
+name = "solana-bincode"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e85cb5961c356345a61378163fd9057011b35540f8bcdd8d8a09cb10117264f"
+dependencies = [
+ "bincode",
+ "serde",
+ "solana-instruction",
+]
+
 [[package]]
 name = "solana-bloom"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5860ef8eec7296e4a28c155214103499e8065fdce878f96849c4594ce2f31dba"
+checksum = "a6cdcc35537b23cd3376eb2ea7753d958f6ce64f69318b00dc137817c0b49411"
 dependencies = [
  "bv",
  "fnv",
  "log",
  "rand 0.8.5",
- "rayon",
- "rustc_version",
  "serde",
  "serde_derive",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-sanitize",
  "solana-sdk",
 ]
 
+[[package]]
+name = "solana-bn254"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39c4030db26ad618f7e18fb5284df19fd52a68e092a1ca58db857108c4cc777"
+dependencies = [
+ "ark-bn254",
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "bytemuck",
+ "solana-program",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-borsh"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d526f3525ab22a3ada3f9a1d642664dafac00dc9208326b701a2045514eb04"
+dependencies = [
+ "borsh 0.10.3",
+ "borsh 1.5.3",
+]
+
 [[package]]
 name = "solana-bpf-loader-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55a1f4be18656ddeeb9b722b3553eb4d47cf8fa356552c0002f6e7f63c457319"
+checksum = "142e0407f8428a1d2a33154d1d3d1c134ad257651ddff0811c17a6ee840def36"
 dependencies = [
  "bincode",
  "byteorder",
  "libsecp256k1",
  "log",
  "scopeguard",
+ "solana-bn254",
+ "solana-compute-budget",
+ "solana-curve25519",
+ "solana-feature-set",
+ "solana-log-collector",
  "solana-measure",
+ "solana-poseidon",
+ "solana-program-memory",
  "solana-program-runtime",
  "solana-sdk",
- "solana-zk-token-sdk",
+ "solana-timings",
+ "solana-type-overrides",
  "solana_rbpf",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-bucket-map"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "461c725c2a6db405355e35bdaa2077673059b95b9859ed3d2a1ebc4e05ffd746"
+checksum = "66eb348939fcfea6e40eed61bca06a1c631f8cb70f1801a5b14021bddefe93eb"
 dependencies = [
  "bv",
  "bytemuck",
+ "bytemuck_derive",
  "log",
  "memmap2 0.5.10",
  "modular-bitfield",
- "num_enum 0.7.2",
+ "num_enum",
  "rand 0.8.5",
  "solana-measure",
  "solana-sdk",
  "tempfile",
 ]
 
+[[package]]
+name = "solana-builtins-default-costs"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854270e266040355f5fd5b67c91855bc36cebf1d3f325eb54d8b1b0ca385f74b"
+dependencies = [
+ "ahash 0.8.11",
+ "lazy_static",
+ "log",
+ "solana-address-lookup-table-program",
+ "solana-bpf-loader-program",
+ "solana-compute-budget-program",
+ "solana-config-program",
+ "solana-loader-v4-program",
+ "solana-sdk",
+ "solana-stake-program",
+ "solana-system-program",
+ "solana-vote-program",
+]
+
 [[package]]
 name = "solana-clap-utils"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "751789b7c7a3d78afe7f1ddbf48942463253167e67e85034a9695e0a05fba63e"
+checksum = "1709e1b0aefc8062fca29a4fde8d35f39ee95586e77cc6360e9bfc50a094c44f"
 dependencies = [
  "chrono",
  "clap 2.34.0",
  "rpassword",
+ "solana-derivation-path",
  "solana-remote-wallet",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "tiny-bip39",
  "uriparse",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "solana-clap-v3-utils"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c562ed7985ebe389e0a145e3ed2d7b640196ad967313a0d0b497e8d005080bc5"
+checksum = "d9682fa05e9e8bcd49340567c000b20e4f094db530ef7912d74ea12706448814"
 dependencies = [
  "chrono",
  "clap 3.2.25",
  "rpassword",
+ "solana-derivation-path",
  "solana-remote-wallet",
  "solana-sdk",
  "solana-zk-token-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "tiny-bip39",
  "uriparse",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "solana-cli-config"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9247f845e3c9fb302087e71ca3626930699a03b575c2d21dbc07e19f4f0bb8e8"
+checksum = "384fda0ddf3099eab0f702b326663f499e84731e8584fd7d0c6d8bab03bead79"
 dependencies = [
  "dirs-next",
  "lazy_static",
@@ -5354,17 +5325,17 @@ dependencies = [
  "serde_yaml",
  "solana-clap-utils",
  "solana-sdk",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "solana-cli-output"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a86aef37f8ea82c6fad2efb23f5bcb366fd2303c34829d0f488f162f4ca03e77"
+checksum = "b82ae7fc5a012ad5bc4077a235ea5b26145fab50ca05b550e792a50bdd6d77a9"
 dependencies = [
  "Inflector",
- "base64 0.21.7",
+ "base64 0.22.1",
  "chrono",
  "clap 2.34.0",
  "console",
@@ -5381,28 +5352,27 @@ dependencies = [
  "solana-sdk",
  "solana-transaction-status",
  "solana-vote-program",
- "spl-memo 4.0.0",
+ "spl-memo 5.0.0",
 ]
 
 [[package]]
 name = "solana-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae5a780ff360acc9794d6e7fae8cd449c0b01bb5f0cec9c4bd8b0e6c6d111487"
+checksum = "1d9a40b8e9e11604e8c05e8b5fcdb89359235db47d1aae84dcba0fc98e95dd0c"
 dependencies = [
  "async-trait",
  "bincode",
  "dashmap",
- "futures 0.3.30",
+ "futures 0.3.31",
  "futures-util",
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "indicatif",
  "log",
  "quinn",
  "rayon",
  "solana-connection-cache",
  "solana-measure",
- "solana-metrics",
  "solana-pubsub-client",
  "solana-quic-client",
  "solana-rpc-client",
@@ -5413,15 +5383,35 @@ dependencies = [
  "solana-thin-client",
  "solana-tpu-client",
  "solana-udp-client",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
+[[package]]
+name = "solana-clock"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7848171e53fa528efd41dd4b3ab919f47b851f8bb4a827d63ff95678f08737fc"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "solana-sdk-macro",
+]
+
+[[package]]
+name = "solana-compute-budget"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebf2f023f471bd1195b7f420e13ffc2422592dd48e71104b4901300b49ac493e"
+dependencies = [
+ "solana-sdk",
+]
+
 [[package]]
 name = "solana-compute-budget-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b5d5f91e6e16026679364f001e2ce9231bdc83752888a84a911e3aa81fa160"
+checksum = "73eddf023f02a56daa838818e30894b874368a741782457468eeefdfce2f7f53"
 dependencies = [
  "solana-program-runtime",
  "solana-sdk",
@@ -5429,82 +5419,87 @@ dependencies = [
 
 [[package]]
 name = "solana-config-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fd4f18daab90c2f703da8dc094b1dc80721178977302d66d21df43e61b4a97b"
+checksum = "a035a01970ebbf40a244b3b79af533329ac8d48d80b0b98e166e23e35aa88171"
 dependencies = [
  "bincode",
  "chrono",
  "serde",
  "serde_derive",
+ "solana-log-collector",
  "solana-program-runtime",
  "solana-sdk",
+ "solana-short-vec",
 ]
 
 [[package]]
 name = "solana-connection-cache"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a7b949fb3d3abc092b0c1dfb437a63d3cb7968f92d74820ef46732093517083"
+checksum = "5f45dd2a6d5d55ed951781486231d0d2ee9ff7047fdafaed01ee021e236319d0"
 dependencies = [
  "async-trait",
  "bincode",
  "crossbeam-channel",
  "futures-util",
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "log",
  "rand 0.8.5",
  "rayon",
- "rcgen",
  "solana-measure",
  "solana-metrics",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
 [[package]]
 name = "solana-core"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be0c86a816e33dc0c26656da74273a23f7519a7ccaf4969c2c66ddb358dcdb22"
+checksum = "9d499325db220d9442530d625addc20defe35c41a2e349a9ffb8f3bf20e7a9b7"
 dependencies = [
- "base64 0.21.7",
+ "ahash 0.8.11",
+ "anyhow",
+ "arrayvec",
+ "base64 0.22.1",
  "bincode",
  "bs58",
  "bytes",
  "chrono",
  "crossbeam-channel",
  "dashmap",
- "eager",
  "etcd-client",
- "futures 0.3.30",
+ "futures 0.3.31",
  "histogram",
- "itertools",
+ "itertools 0.12.1",
  "lazy_static",
  "log",
  "lru",
  "min-max-heap",
- "num_enum 0.7.2",
+ "num_enum",
  "prio-graph",
+ "qualifier_attr",
  "quinn",
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rayon",
- "rcgen",
  "rolling-file",
- "rustc_version",
- "rustls",
+ "rustls 0.23.18",
  "serde",
  "serde_bytes",
  "serde_derive",
  "solana-accounts-db",
  "solana-bloom",
+ "solana-builtins-default-costs",
  "solana-client",
+ "solana-compute-budget",
+ "solana-connection-cache",
  "solana-cost-model",
  "solana-entry",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-feature-set",
+ "solana-fee",
  "solana-geyser-plugin-manager",
  "solana-gossip",
  "solana-ledger",
@@ -5513,15 +5508,20 @@ dependencies = [
  "solana-net-utils",
  "solana-perf",
  "solana-poh",
- "solana-program-runtime",
  "solana-quic-client",
  "solana-rayon-threadlimit",
  "solana-rpc",
  "solana-rpc-client-api",
  "solana-runtime",
+ "solana-runtime-transaction",
+ "solana-sanitize",
  "solana-sdk",
  "solana-send-transaction-service",
+ "solana-short-vec",
  "solana-streamer",
+ "solana-svm",
+ "solana-svm-transaction",
+ "solana-timings",
  "solana-tpu-client",
  "solana-transaction-status",
  "solana-turbine",
@@ -5530,45 +5530,93 @@ dependencies = [
  "solana-vote",
  "solana-vote-program",
  "solana-wen-restart",
- "strum 0.24.1",
- "strum_macros 0.24.3",
+ "strum",
+ "strum_macros",
  "sys-info",
  "sysctl",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "trees",
 ]
 
 [[package]]
 name = "solana-cost-model"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50ae48bd5f95036552951e76780021cead2cdea26aedab3c2e3617c2c3bacb32"
+checksum = "448128561bb950bce19cdbbdc1780955a52ef25f1984c9c13b35b4b9cdc548c4"
 dependencies = [
+ "ahash 0.8.11",
  "lazy_static",
  "log",
- "rustc_version",
- "solana-address-lookup-table-program",
- "solana-bpf-loader-program",
- "solana-compute-budget-program",
- "solana-config-program",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
- "solana-loader-v4-program",
+ "solana-builtins-default-costs",
+ "solana-compute-budget",
+ "solana-feature-set",
  "solana-metrics",
- "solana-program-runtime",
+ "solana-runtime-transaction",
  "solana-sdk",
- "solana-stake-program",
- "solana-system-program",
+ "solana-svm-transaction",
  "solana-vote-program",
 ]
 
+[[package]]
+name = "solana-cpi"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25c536ad0ce25d84a64f48dedcb773e764827e0ef781eda41fa1fa35f5d64b38"
+dependencies = [
+ "solana-account-info",
+ "solana-define-syscall",
+ "solana-instruction",
+ "solana-program-error",
+ "solana-pubkey",
+ "solana-stable-layout",
+]
+
+[[package]]
+name = "solana-curve25519"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f934d38b6f2a940fb1e1d8eaa17a14ffd3773b37be9fb29fa4bcec1bac5e4591"
+dependencies = [
+ "bytemuck",
+ "bytemuck_derive",
+ "curve25519-dalek 4.1.3",
+ "solana-program",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-decode-error"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5a431f532d030098e81d120877f2dddbd3dd90bea5b259198a6aae4ff6456c3"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "solana-define-syscall"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7062ae1de58e294d3bee5fd2c89efc155b7f7383ddce4cb88345dfafaaabc5bd"
+
+[[package]]
+name = "solana-derivation-path"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12080d9bf8eecd559c6f40b5aaf9e47f7f28f515218087f83f02e493b46d8388"
+dependencies = [
+ "derivation-path",
+ "qstring",
+ "uriparse",
+]
+
 [[package]]
 name = "solana-entry"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a40a0d0c05bca1218b875270fb92433ba732c19d5afa7da3c99c453ba4aed5cf"
+checksum = "151cbfd824285d3b6ab6391f85448f73364baca34a897184e26ad7c66165e3f0"
 dependencies = [
  "bincode",
  "crossbeam-channel",
@@ -5586,11 +5634,22 @@ dependencies = [
  "solana-sdk",
 ]
 
+[[package]]
+name = "solana-epoch-schedule"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c4cf7d7c266d353169cf4feeada5e4bba3a55f33715535fa1ef49080eac3e0"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "solana-sdk-macro",
+]
+
 [[package]]
 name = "solana-faucet"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f435797ec23f5aa8f1dd7c90ae34b5e44c80ad165c218fabfe2add6790696a"
+checksum = "281c481c0efa41a7ddada5dbffabee9099a6b01e9d748b7135366df589f7415e"
 dependencies = [
  "bincode",
  "byteorder",
@@ -5605,60 +5664,57 @@ dependencies = [
  "solana-metrics",
  "solana-sdk",
  "solana-version",
- "spl-memo 4.0.0",
- "thiserror",
+ "spl-memo 5.0.0",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
 [[package]]
-name = "solana-frozen-abi"
-version = "1.18.11"
+name = "solana-feature-set"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b8177685ab2bc8cc8b3bf63aa1eaa0580d5af850ecefac323ca1c2473085d77"
+checksum = "5cebf45992982065a0b01b4e109bf039b2ebf6394b21672382fd951516d4c9b0"
 dependencies = [
- "block-buffer 0.10.4",
- "bs58",
- "bv",
- "either",
- "generic-array 0.14.7",
- "im",
  "lazy_static",
- "log",
- "memmap2 0.5.10",
- "rustc_version",
- "serde",
- "serde_bytes",
- "serde_derive",
- "sha2 0.10.8",
- "solana-frozen-abi-macro",
- "subtle",
- "thiserror",
+ "solana-clock",
+ "solana-epoch-schedule",
+ "solana-hash",
+ "solana-pubkey",
+ "solana-sha256-hasher",
 ]
 
 [[package]]
-name = "solana-frozen-abi-macro"
-version = "1.18.11"
+name = "solana-fee"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a68241cad17b74c6034a68ba4890632d409a2c886e7bead9c1e1432befdb7c9"
+checksum = "833e9a34c8cb1271e360b240dce43065cc4419ad74fc7e807c4e30cf06ebca80"
 dependencies = [
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn 2.0.46",
+ "solana-sdk",
+ "solana-svm-transaction",
+]
+
+[[package]]
+name = "solana-fee-calculator"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2befe056ece2eb5807298c2b569a35ee52f79df859bdd16a1f97869f8224a28"
+dependencies = [
+ "log",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
 name = "solana-geyser-plugin-manager"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38a9972a34d9480e40a2d34bf8f6e638fdd680950e9d6136ce37449a1ce2a880"
+checksum = "4ac089db04deff5826ad8469e0c934e77451315396ee30fde4d512d6b60f2cca"
 dependencies = [
  "agave-geyser-plugin-interface",
  "bs58",
  "crossbeam-channel",
  "json5",
  "jsonrpc-core",
- "jsonrpc-server-utils",
  "libloading",
  "log",
  "serde_json",
@@ -5671,14 +5727,15 @@ dependencies = [
  "solana-runtime",
  "solana-sdk",
  "solana-transaction-status",
- "thiserror",
+ "thiserror 1.0.69",
+ "tokio",
 ]
 
 [[package]]
 name = "solana-gossip"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d58c7700a66ba13a20b935a706906257cb95193de315db854c58c1bbe450e46a"
+checksum = "c5849898b9a0a9b4dc9a200fa7b28d1c929bb89f8db4e8b5899d2d32277459ce"
 dependencies = [
  "assert_matches",
  "bincode",
@@ -5686,25 +5743,23 @@ dependencies = [
  "clap 2.34.0",
  "crossbeam-channel",
  "flate2",
- "indexmap 2.2.1",
- "itertools",
+ "indexmap 2.6.0",
+ "itertools 0.12.1",
  "log",
  "lru",
  "num-traits",
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rayon",
- "rustc_version",
- "rustversion",
  "serde",
  "serde_bytes",
  "serde_derive",
  "solana-bloom",
  "solana-clap-utils",
  "solana-client",
+ "solana-connection-cache",
  "solana-entry",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-feature-set",
  "solana-ledger",
  "solana-logger",
  "solana-measure",
@@ -5712,103 +5767,204 @@ dependencies = [
  "solana-net-utils",
  "solana-perf",
  "solana-rayon-threadlimit",
+ "solana-rpc-client",
  "solana-runtime",
+ "solana-sanitize",
  "solana-sdk",
+ "solana-serde-varint",
+ "solana-short-vec",
  "solana-streamer",
- "solana-thin-client",
  "solana-tpu-client",
  "solana-version",
  "solana-vote",
  "solana-vote-program",
  "static_assertions",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "solana-ledger"
-version = "1.18.11"
+name = "solana-hash"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3047298d664542d444837d8f75e7fb05b133a3ec93a27d377c6d7fa375ca6616"
+checksum = "1807bc4e9e1d25271514167d5a1e698ce5a330bce547a368242dd63b355b5faa"
 dependencies = [
- "assert_matches",
- "bincode",
- "bitflags 2.4.2",
- "byteorder",
- "chrono",
- "chrono-humanize",
- "crossbeam-channel",
- "dashmap",
- "fs_extra",
- "futures 0.3.30",
- "itertools",
- "lazy_static",
- "libc",
- "log",
- "lru",
- "mockall",
- "num_cpus",
- "num_enum 0.7.2",
- "prost",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
- "rayon",
- "reed-solomon-erasure",
- "rocksdb",
- "rustc_version",
- "scopeguard",
+ "borsh 1.5.3",
+ "bs58",
+ "bytemuck",
+ "bytemuck_derive",
+ "js-sys",
  "serde",
- "serde_bytes",
- "sha2 0.10.8",
- "solana-account-decoder",
- "solana-accounts-db",
- "solana-bpf-loader-program",
- "solana-cost-model",
- "solana-entry",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
- "solana-measure",
- "solana-metrics",
- "solana-perf",
- "solana-program-runtime",
- "solana-rayon-threadlimit",
- "solana-runtime",
- "solana-sdk",
- "solana-stake-program",
- "solana-storage-bigtable",
- "solana-storage-proto",
- "solana-transaction-status",
- "solana-vote",
- "solana-vote-program",
- "spl-token 4.0.0",
- "spl-token-2022 1.0.0",
- "static_assertions",
- "strum 0.24.1",
- "strum_macros 0.24.3",
- "tempfile",
- "thiserror",
- "tokio",
- "tokio-stream",
- "trees",
+ "serde_derive",
+ "solana-atomic-u64",
+ "solana-sanitize",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "solana-inflation"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a60b572cdf0ec8fcf5a53e5ba4e3e19814dd96c2b9c156d5828be68d0d2e7103"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "solana-inline-spl"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d24c9c6590e4eaf91efa887b2689b2941fe4b324bccd9a95f77853168f3d9a88"
+dependencies = [
+ "bytemuck",
+ "solana-pubkey",
+]
+
+[[package]]
+name = "solana-instruction"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfef689e06e5c7cb6206d4dc61ac77733de4f72d754e0d531393206abc27dbe4"
+dependencies = [
+ "bincode",
+ "borsh 1.5.3",
+ "getrandom 0.2.10",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "serde_derive",
+ "solana-define-syscall",
+ "solana-pubkey",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "solana-last-restart-slot"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3186feae497bdfd2e77bfa56caed38b1cb1b0f389506666e3331f0b9ae799cb"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "solana-sdk-macro",
+]
+
+[[package]]
+name = "solana-lattice-hash"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ec86f48a8694d55757922823823069a3652d2896f61f3ffc4b741646c166a62"
+dependencies = [
+ "base64 0.22.1",
+ "blake3",
+ "bs58",
+ "bytemuck",
+]
+
+[[package]]
+name = "solana-ledger"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d181954a7e0ef3847ed2336adda1214cda401ac2c5557ebb63d700e409864881"
+dependencies = [
+ "assert_matches",
+ "bincode",
+ "bitflags 2.6.0",
+ "byteorder",
+ "bzip2",
+ "chrono",
+ "chrono-humanize",
+ "crossbeam-channel",
+ "dashmap",
+ "eager",
+ "fs_extra",
+ "futures 0.3.31",
+ "itertools 0.12.1",
+ "lazy-lru",
+ "lazy_static",
+ "libc",
+ "log",
+ "lru",
+ "mockall",
+ "num_cpus",
+ "num_enum",
+ "prost",
+ "qualifier_attr",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "rayon",
+ "reed-solomon-erasure",
+ "rocksdb",
+ "scopeguard",
+ "serde",
+ "serde_bytes",
+ "sha2 0.10.8",
+ "solana-account-decoder",
+ "solana-accounts-db",
+ "solana-bpf-loader-program",
+ "solana-cost-model",
+ "solana-entry",
+ "solana-feature-set",
+ "solana-measure",
+ "solana-metrics",
+ "solana-perf",
+ "solana-program-runtime",
+ "solana-rayon-threadlimit",
+ "solana-runtime",
+ "solana-sdk",
+ "solana-stake-program",
+ "solana-storage-bigtable",
+ "solana-storage-proto",
+ "solana-svm",
+ "solana-svm-transaction",
+ "solana-timings",
+ "solana-transaction-status",
+ "solana-vote",
+ "solana-vote-program",
+ "spl-token 6.0.0",
+ "spl-token-2022 4.0.0",
+ "static_assertions",
+ "strum",
+ "strum_macros",
+ "tar",
+ "tempfile",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-stream",
+ "trees",
 ]
 
 [[package]]
 name = "solana-loader-v4-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd77e6da2cc1ba4742dcef6f3e4c7025dc9bf5e36ebba681c53531fef9148b5d"
+checksum = "94c6915a49e537925e934551dbce2db2357d555d257a311bbf5ba0810cb1017a"
 dependencies = [
  "log",
+ "solana-bpf-loader-program",
+ "solana-compute-budget",
+ "solana-log-collector",
  "solana-measure",
  "solana-program-runtime",
  "solana-sdk",
+ "solana-type-overrides",
  "solana_rbpf",
 ]
 
+[[package]]
+name = "solana-log-collector"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b529f5736a6c0794a885dac2e091138d3db6d924335906f117a62b58b0d3b5dc"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "solana-logger"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea560989ef67ba4a1a0fd62a248721f1aa5bac8fa5ede9ccf4fe9ee484ccadf"
+checksum = "367c5431bad14b10fbb62614b48720b746672558dba3244167ff7d251890c355"
 dependencies = [
  "env_logger",
  "lazy_static",
@@ -5817,29 +5973,26 @@ dependencies = [
 
 [[package]]
 name = "solana-measure"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2abdc65120ba03eac69a668c0085166e969ea6717aee1f5b0a2ffbdd07afe7a6"
-dependencies = [
- "log",
- "solana-sdk",
-]
+checksum = "33b2047a2f588082b71080b060918f107c3330ae1505f759c3b2d74bae9d9c88"
 
 [[package]]
 name = "solana-merkle-tree"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350d93058a08b7a7ac36283cbbbce951da5e6d3d65c42dddd40c5a58fb4ad20d"
+checksum = "e75fa782e9cf2a846f09f96594db01e3005aeefb36ce53aebc41b050381e9989"
 dependencies = [
  "fast-math",
- "solana-program",
+ "solana-hash",
+ "solana-sha256-hasher",
 ]
 
 [[package]]
 name = "solana-metrics"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4874fea432f89b6ef0902fdada2cbca715b094419897dcfc7ef82d88b0a308"
+checksum = "6319c74238e8ed4f7159fd37c693a574ab8316d03b053103f9cc83dce13f1d5c"
 dependencies = [
  "crossbeam-channel",
  "gethostname",
@@ -5847,17 +6000,31 @@ dependencies = [
  "log",
  "reqwest",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-msg"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f7551f85064bc7299d56dbd7126258b084a2d78d0325b1579324f818b405123"
+dependencies = [
+ "solana-define-syscall",
 ]
 
+[[package]]
+name = "solana-native-token"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0c4074f5fc67574dabd8f30fe6e51e290a812d88326b19b49c462058e23340"
+
 [[package]]
 name = "solana-net-utils"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05afd6080d20db4dc862603178535c7d648cba7462ca23241ff5670fb0026d38"
+checksum = "bbac19474a4c4f91cb264c2fccead8a1a4f65384ce650b24360d9df5650e65bc"
 dependencies = [
  "bincode",
- "clap 3.2.25",
  "crossbeam-channel",
  "log",
  "nix",
@@ -5865,11 +6032,9 @@ dependencies = [
  "serde",
  "serde_derive",
  "socket2",
- "solana-logger",
  "solana-sdk",
- "solana-version",
  "tokio",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
@@ -5878,17 +6043,31 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b8a731ed60e89177c8a7ab05fe0f1511cedd3e70e773f288f9de33a9cfdc21e"
 
+[[package]]
+name = "solana-packet"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dafc2d84e57dbfe32583fe915962bd2ca3af6be496628a871db3c3d697b38d7"
+dependencies = [
+ "bincode",
+ "bitflags 2.6.0",
+ "cfg_eval",
+ "serde",
+ "serde_derive",
+ "serde_with",
+]
+
 [[package]]
 name = "solana-perf"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cff0f2ea9735a5452a3fe837c61f30231c8f5b455a2b12665d3bb6e0c56e49c8"
+checksum = "e8299f1ba518f9888da8cafa861addc6ffdd639c689e3ce219ae08212c0dcd0e"
 dependencies = [
- "ahash 0.8.9",
+ "ahash 0.8.11",
  "bincode",
  "bv",
  "caps",
- "curve25519-dalek",
+ "curve25519-dalek 4.1.3",
  "dlopen2",
  "fnv",
  "lazy_static",
@@ -5897,21 +6076,19 @@ dependencies = [
  "nix",
  "rand 0.8.5",
  "rayon",
- "rustc_version",
  "serde",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
  "solana-metrics",
  "solana-rayon-threadlimit",
  "solana-sdk",
+ "solana-short-vec",
  "solana-vote-program",
 ]
 
 [[package]]
 name = "solana-poh"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6cbd0d4aa51a73d5907be007ed083b8da1c4ac45c627f3bdd795530a556e6e6"
+checksum = "c11f9be81af30870cfc5b782e46565f65685d75a6969052d5f8f063a3271c66c"
 dependencies = [
  "core_affinity",
  "crossbeam-channel",
@@ -5922,101 +6099,195 @@ dependencies = [
  "solana-metrics",
  "solana-runtime",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "solana-program"
-version = "1.18.11"
+name = "solana-poseidon"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bddf573103c890b4ab8f9a6641d4f969d4148bce9a451c263f4a62afa949fae"
+checksum = "f193a65f0db7fe5615c76c2814d6450a2e4cda61f786d5bf7a6b1ad0c179b947"
 dependencies = [
  "ark-bn254",
- "ark-ec",
- "ark-ff",
- "ark-serialize",
- "base64 0.21.7",
+ "light-poseidon",
+ "solana-define-syscall",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-precompile-error"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a30ab58b9e37cde4e5577282670f30df71b97b6b06dbdb420e9b84e57b831227"
+dependencies = [
+ "num-traits",
+ "solana-decode-error",
+]
+
+[[package]]
+name = "solana-program"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9040decf2f295d35da22557eeab3768ab8dfca8aed9afe668663c8fa0e97d60e"
+dependencies = [
+ "base64 0.22.1",
  "bincode",
- "bitflags 2.4.2",
+ "bitflags 2.6.0",
  "blake3",
  "borsh 0.10.3",
- "borsh 0.9.3",
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "bs58",
  "bv",
  "bytemuck",
- "cc",
+ "bytemuck_derive",
  "console_error_panic_hook",
  "console_log",
- "curve25519-dalek",
+ "curve25519-dalek 4.1.3",
+ "five8_const",
  "getrandom 0.2.10",
- "itertools",
  "js-sys",
  "lazy_static",
- "libc",
- "libsecp256k1",
- "light-poseidon",
  "log",
  "memoffset 0.9.0",
- "num-bigint 0.4.4",
- "num-derive 0.4.2",
+ "num-bigint 0.4.6",
+ "num-derive",
  "num-traits",
  "parking_lot 0.12.0",
  "rand 0.8.5",
- "rustc_version",
- "rustversion",
  "serde",
  "serde_bytes",
  "serde_derive",
- "serde_json",
  "sha2 0.10.8",
- "sha3 0.10.8",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "sha3",
+ "solana-account-info",
+ "solana-atomic-u64",
+ "solana-bincode",
+ "solana-borsh",
+ "solana-clock",
+ "solana-cpi",
+ "solana-decode-error",
+ "solana-define-syscall",
+ "solana-epoch-schedule",
+ "solana-fee-calculator",
+ "solana-hash",
+ "solana-instruction",
+ "solana-last-restart-slot",
+ "solana-msg",
+ "solana-native-token",
+ "solana-program-entrypoint",
+ "solana-program-error",
+ "solana-program-memory",
+ "solana-program-option",
+ "solana-program-pack",
+ "solana-pubkey",
+ "solana-rent",
+ "solana-sanitize",
  "solana-sdk-macro",
- "thiserror",
- "tiny-bip39",
+ "solana-secp256k1-recover",
+ "solana-serde-varint",
+ "solana-serialize-utils",
+ "solana-sha256-hasher",
+ "solana-short-vec",
+ "solana-slot-hashes",
+ "solana-slot-history",
+ "solana-stable-layout",
+ "solana-transaction-error",
+ "thiserror 1.0.69",
  "wasm-bindgen",
- "zeroize",
+]
+
+[[package]]
+name = "solana-program-entrypoint"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eb90f3fa3e979b912451a404508f1f90bb6e5c1d7767625f622b20016fb9fde"
+dependencies = [
+ "solana-account-info",
+ "solana-msg",
+ "solana-program-error",
+ "solana-pubkey",
+]
+
+[[package]]
+name = "solana-program-error"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd089caeef26dd07bd12b7b67d45e92faddc2fc67a960f316df7ae4776a2f3d5"
+dependencies = [
+ "borsh 1.5.3",
+ "num-traits",
+ "serde",
+ "serde_derive",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-pubkey",
+]
+
+[[package]]
+name = "solana-program-memory"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed4bc044dc2b49c323aeff04aec03c908a052e278c2edf2f7616f32fc0f1bcd9"
+dependencies = [
+ "num-traits",
+ "solana-define-syscall",
+]
+
+[[package]]
+name = "solana-program-option"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3babbdffd81994c043fc9a61458ce87496218825d6e9a303de643c0a53089b9a"
+
+[[package]]
+name = "solana-program-pack"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fb28439d23e1f505e59c7a14ed5012365ab7aa0f20dc7bda048e02ff231cf6"
+dependencies = [
+ "solana-program-error",
 ]
 
 [[package]]
 name = "solana-program-runtime"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22d035b370d65bff46c7d7582a1619c4edac8e8059e2dec0e151df09882c7b3"
+checksum = "ba1de51df173401d50c0f4cf750f5070d7a4c82125a03c1aec9622dc041b0b54"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
- "eager",
  "enum-iterator",
- "itertools",
+ "itertools 0.12.1",
  "libc",
  "log",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "percentage",
  "rand 0.8.5",
- "rustc_version",
  "serde",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-compute-budget",
+ "solana-feature-set",
+ "solana-log-collector",
  "solana-measure",
  "solana-metrics",
  "solana-sdk",
+ "solana-timings",
+ "solana-type-overrides",
+ "solana-vote",
  "solana_rbpf",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-program-test"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b6ea8515eb200c6ba4841f99e17bc3498ae7bc6e95ebb3aff8ffa73bac482c7"
+checksum = "974591eca853eafee8196a3445b81fd03ebd9b3e38a6dd7b6f22dc3414c32be6"
 dependencies = [
  "assert_matches",
  "async-trait",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "chrono-humanize",
  "crossbeam-channel",
@@ -6027,22 +6298,55 @@ dependencies = [
  "solana-banks-interface",
  "solana-banks-server",
  "solana-bpf-loader-program",
+ "solana-compute-budget",
+ "solana-feature-set",
+ "solana-inline-spl",
+ "solana-instruction",
+ "solana-log-collector",
  "solana-logger",
  "solana-program-runtime",
  "solana-runtime",
  "solana-sdk",
+ "solana-svm",
+ "solana-timings",
  "solana-vote-program",
  "solana_rbpf",
- "test-case",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
+[[package]]
+name = "solana-pubkey"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bea3215775fcedf200d47590c7e2ce9a3a46bc2b7d3f77d0eae9c6edf0a39aec"
+dependencies = [
+ "borsh 0.10.3",
+ "borsh 1.5.3",
+ "bs58",
+ "bytemuck",
+ "bytemuck_derive",
+ "curve25519-dalek 4.1.3",
+ "five8_const",
+ "getrandom 0.2.10",
+ "js-sys",
+ "num-traits",
+ "rand 0.8.5",
+ "serde",
+ "serde_derive",
+ "solana-atomic-u64",
+ "solana-decode-error",
+ "solana-define-syscall",
+ "solana-sanitize",
+ "solana-sha256-hasher",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "solana-pubsub-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b3aaa906f6b222be23423a0dd5deed254f092d27ad3bc05371acd9685d2db0"
+checksum = "9d28adf5ff89c19ef3cb24d0f484afa05852697881c2e4ef12aec190d61f76d8"
 dependencies = [
  "crossbeam-channel",
  "futures-util",
@@ -6055,30 +6359,29 @@ dependencies = [
  "solana-account-decoder",
  "solana-rpc-client-api",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
  "tokio-tungstenite",
  "tungstenite",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "solana-quic-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e75ba7e460865a7f556d7b7bc59e70c049eab4448bf2528bed1c5e5a1b672d"
+checksum = "259c6d420c0b7620557700f13fbbdb00afbb1b82274485c27ba30dd660ea921b"
 dependencies = [
- "async-mutex",
+ "async-lock",
  "async-trait",
- "futures 0.3.30",
- "itertools",
+ "futures 0.3.31",
+ "itertools 0.12.1",
  "lazy_static",
  "log",
  "quinn",
  "quinn-proto",
- "rcgen",
- "rustls",
+ "rustls 0.23.18",
  "solana-connection-cache",
  "solana-measure",
  "solana-metrics",
@@ -6086,15 +6389,15 @@ dependencies = [
  "solana-rpc-client-api",
  "solana-sdk",
  "solana-streamer",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
 [[package]]
 name = "solana-rayon-threadlimit"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a6ccb1910cc9efd4bae450d18a57c387e51ebebade1bd9bdf006ae539dd012f"
+checksum = "4c69806ad1a7b0986f750134e13e55d83919631d81a2328a588615740e14ed0a"
 dependencies = [
  "lazy_static",
  "num_cpus",
@@ -6102,36 +6405,48 @@ dependencies = [
 
 [[package]]
 name = "solana-remote-wallet"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24cda66f8ed8860870cd4bf26235fb7fd08d8e5a75a4fce26b279c8d5c9db81f"
+checksum = "6f36cf8ad0090276b5e9c73512df889b84092761ed733a26781b164c9e95f544"
 dependencies = [
  "console",
  "dialoguer",
  "hidapi",
  "log",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "parking_lot 0.12.0",
  "qstring",
  "semver",
+ "solana-derivation-path",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "uriparse",
 ]
 
+[[package]]
+name = "solana-rent"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aab3f4a270196c38d62c3bb3c7a2f07732af2c772b50da49c9b1e2c9d2ace286"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "solana-sdk-macro",
+]
+
 [[package]]
 name = "solana-rpc"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c567b10f1c0dfd8861670eb93b68df9ae5ffb015cb8f53737bb04e54c7cb2bfb"
+checksum = "b6e2cf5309990480e4d52e59850bbd8181e1e2c8d4321a44b1c6b89e05df2c44"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "bs58",
  "crossbeam-channel",
  "dashmap",
- "itertools",
+ "itertools 0.12.1",
  "jsonrpc-core",
  "jsonrpc-core-client",
  "jsonrpc-derive",
@@ -6150,7 +6465,9 @@ dependencies = [
  "solana-client",
  "solana-entry",
  "solana-faucet",
+ "solana-feature-set",
  "solana-gossip",
+ "solana-inline-spl",
  "solana-ledger",
  "solana-measure",
  "solana-metrics",
@@ -6164,40 +6481,42 @@ dependencies = [
  "solana-stake-program",
  "solana-storage-bigtable",
  "solana-streamer",
+ "solana-svm",
  "solana-tpu-client",
  "solana-transaction-status",
  "solana-version",
  "solana-vote",
  "solana-vote-program",
- "spl-token 4.0.0",
- "spl-token-2022 1.0.0",
+ "spl-token 6.0.0",
+ "spl-token-2022 4.0.0",
  "stream-cancel",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
- "tokio-util 0.6.9",
+ "tokio-util 0.7.1",
 ]
 
 [[package]]
 name = "solana-rpc-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efae5c8740d8eb49e504e728de10aed0a5ddc53af3004b32ecdea2f7ca12c97b"
+checksum = "3b05822aceeb484074a72d82a1b289da9fc3383f9ba3f55ce4bfd003bf9d62e6"
 dependencies = [
  "async-trait",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "bs58",
  "indicatif",
  "log",
  "reqwest",
+ "reqwest-middleware",
  "semver",
  "serde",
  "serde_derive",
  "serde_json",
- "solana-account-decoder",
+ "solana-account-decoder-client-types",
  "solana-rpc-client-api",
  "solana-sdk",
- "solana-transaction-status",
+ "solana-transaction-status-client-types",
  "solana-version",
  "solana-vote-program",
  "tokio",
@@ -6205,48 +6524,49 @@ dependencies = [
 
 [[package]]
 name = "solana-rpc-client-api"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdd1597ebe177b6fd68a9b33b682a5f0c9445c02be3783e7f51e570cbbbb3aa4"
+checksum = "cb9c6e64f01cfafef9b2d43d6adb02979bb22f579ec8ee88b77796259acce92e"
 dependencies = [
- "base64 0.21.7",
+ "anyhow",
+ "base64 0.22.1",
  "bs58",
  "jsonrpc-core",
  "reqwest",
+ "reqwest-middleware",
  "semver",
  "serde",
  "serde_derive",
  "serde_json",
- "solana-account-decoder",
+ "solana-account-decoder-client-types",
+ "solana-inline-spl",
  "solana-sdk",
- "solana-transaction-status",
+ "solana-transaction-status-client-types",
  "solana-version",
- "spl-token-2022 1.0.0",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-rpc-client-nonce-utils"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ae385b37c59a8507b9871d5162ea7709206360a55cf2859adb4274be4a870e1"
+checksum = "7f0ab2d1ca3769c5058c689b438d35eb1cb7d2a32fc4b2b7c16fe72fa187927c"
 dependencies = [
- "clap 2.34.0",
- "solana-clap-utils",
  "solana-rpc-client",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-runtime"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ebeeadbb2c6bab05e248493bb170e9e1429f180559df7f0027c71a9d486df84"
+checksum = "60f579df1ed24b2e7be5c99c2b97cb2a331823008129103b5b7753057ddf3cf7"
 dependencies = [
+ "ahash 0.8.11",
  "aquamarine",
  "arrayref",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "blake3",
  "bv",
@@ -6260,171 +6580,313 @@ dependencies = [
  "fnv",
  "im",
  "index_list",
- "itertools",
+ "itertools 0.12.1",
  "lazy_static",
+ "libc",
  "log",
- "lru",
  "lz4",
  "memmap2 0.5.10",
  "mockall",
  "modular-bitfield",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "num_cpus",
- "num_enum 0.7.2",
- "ouroboros",
+ "num_enum",
  "percentage",
  "qualifier_attr",
  "rand 0.8.5",
  "rayon",
  "regex",
- "rustc_version",
  "serde",
  "serde_derive",
  "serde_json",
+ "serde_with",
  "solana-accounts-db",
  "solana-address-lookup-table-program",
  "solana-bpf-loader-program",
  "solana-bucket-map",
+ "solana-compute-budget",
  "solana-compute-budget-program",
  "solana-config-program",
  "solana-cost-model",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-feature-set",
+ "solana-fee",
+ "solana-inline-spl",
+ "solana-lattice-hash",
  "solana-loader-v4-program",
  "solana-measure",
  "solana-metrics",
  "solana-perf",
+ "solana-program",
  "solana-program-runtime",
  "solana-rayon-threadlimit",
+ "solana-runtime-transaction",
  "solana-sdk",
  "solana-stake-program",
+ "solana-svm",
+ "solana-svm-rent-collector",
+ "solana-svm-transaction",
  "solana-system-program",
+ "solana-timings",
+ "solana-transaction-status",
  "solana-version",
  "solana-vote",
  "solana-vote-program",
+ "solana-zk-elgamal-proof-program",
+ "solana-zk-sdk",
  "solana-zk-token-proof-program",
  "solana-zk-token-sdk",
  "static_assertions",
- "strum 0.24.1",
- "strum_macros 0.24.3",
+ "strum",
+ "strum_macros",
  "symlink",
  "tar",
  "tempfile",
- "thiserror",
+ "thiserror 1.0.69",
  "zstd",
 ]
 
+[[package]]
+name = "solana-runtime-transaction"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e1757d4473c7a2f462d2ce5f3cb5689145cfbde3a6b12161a49e497633ab85"
+dependencies = [
+ "agave-transaction-view",
+ "log",
+ "solana-builtins-default-costs",
+ "solana-compute-budget",
+ "solana-pubkey",
+ "solana-sdk",
+ "solana-svm-transaction",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-sanitize"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "203b90994371db8cade8e885f74ec9f68ee02a32b25d514594158b2551a4e5ed"
+
 [[package]]
 name = "solana-sdk"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08b24b06fa176209ddb2a2f8172a00b07e8a3b18229fbfc49f1eb3ce6ad11ff1"
+checksum = "524604d94185c189616296e5b7da1014cc96d1e446bd2b26f247f00708b9225a"
 dependencies = [
- "assert_matches",
- "base64 0.21.7",
  "bincode",
- "bitflags 2.4.2",
- "borsh 1.5.1",
+ "bitflags 2.6.0",
+ "borsh 1.5.3",
  "bs58",
  "bytemuck",
+ "bytemuck_derive",
  "byteorder",
  "chrono",
- "derivation-path",
  "digest 0.10.7",
  "ed25519-dalek",
  "ed25519-dalek-bip32",
- "generic-array 0.14.7",
+ "getrandom 0.1.16",
  "hmac 0.12.1",
- "itertools",
+ "itertools 0.12.1",
  "js-sys",
  "lazy_static",
  "libsecp256k1",
  "log",
  "memmap2 0.5.10",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "num_enum 0.7.2",
+ "num_enum",
  "pbkdf2 0.11.0",
- "qstring",
- "qualifier_attr",
  "rand 0.7.3",
  "rand 0.8.5",
- "rustc_version",
- "rustversion",
  "serde",
  "serde_bytes",
  "serde_derive",
  "serde_json",
- "serde_with 2.3.3",
+ "serde_with",
  "sha2 0.10.8",
- "sha3 0.10.8",
+ "sha3",
  "siphasher",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
- "solana-logger",
+ "solana-account",
+ "solana-bn254",
+ "solana-decode-error",
+ "solana-derivation-path",
+ "solana-feature-set",
+ "solana-inflation",
+ "solana-instruction",
+ "solana-native-token",
+ "solana-packet",
+ "solana-precompile-error",
  "solana-program",
+ "solana-program-memory",
+ "solana-pubkey",
+ "solana-sanitize",
  "solana-sdk-macro",
- "thiserror",
- "uriparse",
+ "solana-secp256k1-recover",
+ "solana-serde-varint",
+ "solana-short-vec",
+ "solana-signature",
+ "solana-transaction-error",
+ "thiserror 1.0.69",
  "wasm-bindgen",
 ]
 
 [[package]]
-name = "solana-sdk-macro"
-version = "1.18.11"
+name = "solana-sdk-macro"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd2265b93dce9d3dcf9f395abf1a85b5e06e4da4aa60ca147620003ac3abc67"
+dependencies = [
+ "bs58",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "solana-secp256k1-recover"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2eef5a00a75648273c3fb6e3d85b0c8c02fcc1e36c4271664dcc39b6b128d41"
+dependencies = [
+ "borsh 1.5.3",
+ "libsecp256k1",
+ "solana-define-syscall",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-security-txt"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183"
+
+[[package]]
+name = "solana-send-transaction-service"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8dc6adaa31bdaab1e5f8932575e75160f4806553ab5e15e552c258dfe1d5594b"
+dependencies = [
+ "crossbeam-channel",
+ "log",
+ "solana-client",
+ "solana-connection-cache",
+ "solana-measure",
+ "solana-metrics",
+ "solana-runtime",
+ "solana-sdk",
+ "solana-tpu-client",
+]
+
+[[package]]
+name = "solana-serde-varint"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aeb51d3c20e2a61db0ef72617f3b8c9207a342a867af454a95f17add9f6c262"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "solana-serialize-utils"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cfb0b57c6a431fb15ff33053caadb6c36aed4e1ce74bea9adfc459a710b3626"
+dependencies = [
+ "solana-instruction",
+ "solana-pubkey",
+ "solana-sanitize",
+]
+
+[[package]]
+name = "solana-sha256-hasher"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd115f3a1136314b0183235080d29023530c3a0a5df60505fdb7ea620eff9fd6"
+dependencies = [
+ "sha2 0.10.8",
+ "solana-define-syscall",
+ "solana-hash",
+]
+
+[[package]]
+name = "solana-short-vec"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08e55330b694db1139dcdf2a1ea7781abe8bd994dec2ab29e36abfd06e4e9274"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "solana-signature"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ad9784d110f195a3a4fe423479d18f05b01a1c380a1430644a3b3038fdbe2f0"
+dependencies = [
+ "bs58",
+ "ed25519-dalek",
+ "generic-array 0.14.7",
+ "rand 0.8.5",
+ "serde",
+ "serde_derive",
+ "solana-sanitize",
+]
+
+[[package]]
+name = "solana-slot-hashes"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "869483c05f18d37d4d95a08d9e05e00a4f76a8c8349aeedeee9ba2d013cbacde"
+checksum = "17d216c0ebf00e95acaf2b1e227e6cc900a5ce50fb81fa0743272851e88a788d"
 dependencies = [
- "bs58",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.46",
+ "serde",
+ "serde_derive",
+ "solana-hash",
 ]
 
 [[package]]
-name = "solana-security-txt"
-version = "1.1.1"
+name = "solana-slot-history"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183"
+checksum = "88cbcdf767891c6a40116a5ef8f7241000f074ece4ba80c8f00b4f62705fc8a4"
+dependencies = [
+ "bv",
+ "serde",
+ "serde_derive",
+]
 
 [[package]]
-name = "solana-send-transaction-service"
-version = "1.18.11"
+name = "solana-stable-layout"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e86bad64f4584997089757bf463d7c21099789a4fc8e9e412988b192f7d501a6"
+checksum = "8a5305ca88fb5deb219cd88f04e24f3a131769417d7fcb11a8da1126a8f98d23"
 dependencies = [
- "crossbeam-channel",
- "log",
- "solana-client",
- "solana-measure",
- "solana-metrics",
- "solana-runtime",
- "solana-sdk",
- "solana-tpu-client",
+ "solana-instruction",
+ "solana-pubkey",
 ]
 
 [[package]]
 name = "solana-stake-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce34cbcfddcddf8316af363e7457b2420ee0507bc8ff3a16980d38c71af0e04e"
+checksum = "c8bb1a59fdd929becddfaed9ec33a1ca4db853f45ae85e14e4f4054a875fc41d"
 dependencies = [
  "bincode",
  "log",
- "rustc_version",
  "solana-config-program",
+ "solana-feature-set",
+ "solana-log-collector",
  "solana-program-runtime",
  "solana-sdk",
+ "solana-type-overrides",
  "solana-vote-program",
 ]
 
 [[package]]
 name = "solana-storage-bigtable"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74e38acc6570c6f211ef18adfedc6fcaa7097c505e4c315e7553f1130e7ef6e0"
+checksum = "bd27a62abd1e8abab640ed77565fcbf10745e732fc016013f521f3a46193d07a"
 dependencies = [
  "backoff",
  "bincode",
@@ -6432,7 +6894,7 @@ dependencies = [
  "bzip2",
  "enum-iterator",
  "flate2",
- "futures 0.3.30",
+ "futures 0.3.31",
  "goauth",
  "http",
  "hyper",
@@ -6448,7 +6910,7 @@ dependencies = [
  "solana-sdk",
  "solana-storage-proto",
  "solana-transaction-status",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tonic",
  "zstd",
@@ -6456,9 +6918,9 @@ dependencies = [
 
 [[package]]
 name = "solana-storage-proto"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "651c9d7457c394f0d002ef95acfd8bb8e9e6bb501d65cbfceb3f3eff3aa75b90"
+checksum = "12335d3d506aa9a49ac0674c00a5ea3de2d617e77ced0611080a3c1cdd61ada5"
 dependencies = [
  "bincode",
  "bs58",
@@ -6473,58 +6935,113 @@ dependencies = [
 
 [[package]]
 name = "solana-streamer"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b76711141dd5b052e29e4825b33cf09ca9cf3987b8ac0c703d36e3d80ad5dc91"
+checksum = "ff771524872781eca074e0ba221d72b07fa0800cc1a7ffa400a9eb3e125fb922"
 dependencies = [
  "async-channel",
  "bytes",
  "crossbeam-channel",
+ "dashmap",
+ "futures 0.3.31",
  "futures-util",
+ "governor",
  "histogram",
- "indexmap 2.2.1",
- "itertools",
+ "indexmap 2.6.0",
+ "itertools 0.12.1",
  "libc",
  "log",
  "nix",
  "pem",
  "percentage",
- "pkcs8",
  "quinn",
  "quinn-proto",
  "rand 0.8.5",
- "rcgen",
- "rustls",
+ "rustls 0.23.18",
  "smallvec",
+ "socket2",
+ "solana-measure",
  "solana-metrics",
  "solana-perf",
  "solana-sdk",
- "thiserror",
+ "solana-transaction-metrics-tracker",
+ "thiserror 1.0.69",
  "tokio",
+ "tokio-util 0.7.1",
  "x509-parser",
 ]
 
+[[package]]
+name = "solana-svm"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43f3b139a001effc93295b693437013f365785fab04dcf2fa679164af4206ec8"
+dependencies = [
+ "itertools 0.12.1",
+ "log",
+ "percentage",
+ "serde",
+ "serde_derive",
+ "solana-bpf-loader-program",
+ "solana-compute-budget",
+ "solana-feature-set",
+ "solana-fee",
+ "solana-loader-v4-program",
+ "solana-log-collector",
+ "solana-measure",
+ "solana-program-runtime",
+ "solana-runtime-transaction",
+ "solana-sdk",
+ "solana-svm-rent-collector",
+ "solana-svm-transaction",
+ "solana-system-program",
+ "solana-timings",
+ "solana-type-overrides",
+ "solana-vote",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-svm-rent-collector"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e7068d6cc69c730190c96b87b106afd42cde203cf56164106792778cd0aaeb"
+dependencies = [
+ "solana-sdk",
+]
+
+[[package]]
+name = "solana-svm-transaction"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38a8533576cb7beca4a44b976ac27df9865bbf8c4cbca2ee8f4f3469cdd8175f"
+dependencies = [
+ "solana-sdk",
+]
+
 [[package]]
 name = "solana-system-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d55e3fb09b181f6b4040fc6e5038d35aa9a0c95eb182b7702b8318bf2ff0cb"
+checksum = "242634cdc1eacaa83738cc100fdd583eb88f99cc2edcc900c8ebe57d77af51b1"
 dependencies = [
  "bincode",
  "log",
  "serde",
  "serde_derive",
+ "solana-log-collector",
  "solana-program-runtime",
  "solana-sdk",
+ "solana-type-overrides",
 ]
 
 [[package]]
 name = "solana-test-validator"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14f8bda185f131c559e5b7161cc6045792fb35893d058089f5ae499bddcf1ca3"
+checksum = "f1ff3137ff403e0d6c7f04b0800448341e8b4c889eefb2a1cd52e31e71596e72"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "crossbeam-channel",
  "log",
@@ -6532,17 +7049,18 @@ dependencies = [
  "serde_json",
  "solana-accounts-db",
  "solana-cli-output",
- "solana-client",
+ "solana-compute-budget",
  "solana-core",
+ "solana-feature-set",
  "solana-geyser-plugin-manager",
  "solana-gossip",
  "solana-ledger",
  "solana-logger",
  "solana-net-utils",
- "solana-program-runtime",
  "solana-program-test",
  "solana-rpc",
  "solana-rpc-client",
+ "solana-rpc-client-api",
  "solana-runtime",
  "solana-sdk",
  "solana-streamer",
@@ -6552,9 +7070,9 @@ dependencies = [
 
 [[package]]
 name = "solana-thin-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b6b476b4572453f93a9827fa9312537b8a8ed253006919ab17d921b271b125"
+checksum = "10314ae3e0889cf38140902862d2c2ea481895c82c19f51dc4457b7dfa3aa6d0"
 dependencies = [
  "bincode",
  "log",
@@ -6565,40 +7083,78 @@ dependencies = [
  "solana-sdk",
 ]
 
+[[package]]
+name = "solana-timings"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8a8e2f926d488c1e2a65cbc05544dcb68cfa88deb4d50f89db5bfbda7ff2419"
+dependencies = [
+ "eager",
+ "enum-iterator",
+ "solana-sdk",
+]
+
 [[package]]
 name = "solana-tpu-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cfa13af3f54db31bde6f2d5462588f03be95f7cf66610d5942e7b52e556d1d9"
+checksum = "516cbed8800cd36fb3ecc9a65df1e76bf8251929aa32e9b10497e8d6612de605"
 dependencies = [
  "async-trait",
  "bincode",
  "futures-util",
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "indicatif",
  "log",
  "rayon",
  "solana-connection-cache",
  "solana-measure",
- "solana-metrics",
  "solana-pubsub-client",
  "solana-rpc-client",
  "solana-rpc-client-api",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
+[[package]]
+name = "solana-transaction-error"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37a4bea6d80b34fe6e785d19bf928fe103928d1f6c9935ec23bb6a9d4d7a33d2"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "solana-instruction",
+ "solana-sanitize",
+]
+
+[[package]]
+name = "solana-transaction-metrics-tracker"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0b668c986a83e6b2eb8f130039045b54abc37ee821853250755386d26c1c668"
+dependencies = [
+ "base64 0.22.1",
+ "bincode",
+ "lazy_static",
+ "log",
+ "rand 0.8.5",
+ "solana-perf",
+ "solana-sdk",
+ "solana-short-vec",
+]
+
 [[package]]
 name = "solana-transaction-status"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b5614e42e4d5a8b15e4553b68008788fae3a0dbc1a3672b62e9574252579536"
+checksum = "e3e8ed5bf2511c45b923de25482407c9a2eb56af73dba52c19db76df4dd35cba"
 dependencies = [
  "Inflector",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
- "borsh 0.10.3",
+ "borsh 1.5.3",
  "bs58",
  "lazy_static",
  "log",
@@ -6607,33 +7163,56 @@ dependencies = [
  "serde_json",
  "solana-account-decoder",
  "solana-sdk",
- "spl-associated-token-account 2.3.0",
- "spl-memo 4.0.0",
- "spl-token 4.0.0",
- "spl-token-2022 1.0.0",
- "thiserror",
+ "solana-transaction-status-client-types",
+ "spl-associated-token-account 4.0.0",
+ "spl-memo 5.0.0",
+ "spl-token 6.0.0",
+ "spl-token-2022 4.0.0",
+ "spl-token-group-interface 0.3.0",
+ "spl-token-metadata-interface 0.4.0",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "solana-transaction-status-client-types"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fb35fb678fec581e9bdf6350d2c7f5829951a6280038fc06949b1589a9605e1"
+dependencies = [
+ "base64 0.22.1",
+ "bincode",
+ "bs58",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "solana-account-decoder-client-types",
+ "solana-sdk",
+ "solana-signature",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-turbine"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ea00874e1b70347d54e54b9788cdbba5509de2119f702603776067db759628"
+checksum = "bf66a4e4cf0deed11e1d351fdce52e2a48058bd4b7ece4f5e1e1b435911460e0"
 dependencies = [
  "bincode",
  "bytes",
  "crossbeam-channel",
- "futures 0.3.30",
- "itertools",
+ "futures 0.3.31",
+ "itertools 0.12.1",
+ "lazy-lru",
  "log",
  "lru",
  "quinn",
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rayon",
- "rcgen",
- "rustls",
+ "rustls 0.23.18",
  "solana-entry",
+ "solana-feature-set",
+ "solana-geyser-plugin-manager",
  "solana-gossip",
  "solana-ledger",
  "solana-measure",
@@ -6647,132 +7226,198 @@ dependencies = [
  "solana-runtime",
  "solana-sdk",
  "solana-streamer",
- "thiserror",
+ "static_assertions",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
+[[package]]
+name = "solana-type-overrides"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2066f25d460d63801f91436c2640aaba4f2dc95aa18fe1e76f7f2c063e981d4e"
+dependencies = [
+ "lazy_static",
+ "rand 0.8.5",
+]
+
 [[package]]
 name = "solana-udp-client"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22a37626fc851db74838725fc1034a71f2b2445149d93e45884ae366c6d85d61"
+checksum = "95ec0cbc2d5e3379fafb2c1493f2358f07c09e76e2081c44e3a8c36da12fbd40"
 dependencies = [
  "async-trait",
  "solana-connection-cache",
  "solana-net-utils",
  "solana-sdk",
  "solana-streamer",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
 ]
 
 [[package]]
 name = "solana-unified-scheduler-logic"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd361d0e29b165135b2947e5f0738996c42c54073ddda3009802e4cfe2c8510"
+checksum = "dd7b34042dc9a9731d47fc0ae1f5e0b4a393b0ad51b27b633df3d21771e4f12b"
+dependencies = [
+ "assert_matches",
+ "solana-sdk",
+ "static_assertions",
+]
 
 [[package]]
 name = "solana-unified-scheduler-pool"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1158e7ad20e98044d416b7111736481c590f7b49d66cae917c5c092ff373d979"
+checksum = "672e74caac59ba67407a9895bd34906edd9b4de1884ece54afb49607919ab957"
 dependencies = [
+ "assert_matches",
+ "crossbeam-channel",
+ "dashmap",
+ "derivative",
+ "log",
+ "qualifier_attr",
+ "scopeguard",
  "solana-ledger",
- "solana-program-runtime",
  "solana-runtime",
  "solana-sdk",
+ "solana-timings",
  "solana-unified-scheduler-logic",
- "solana-vote",
+ "static_assertions",
+ "vec_extract_if_polyfill",
 ]
 
 [[package]]
 name = "solana-version"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c23651369dd7278308c988078adeb593a37560abd0f728f70e768e12fa4b507"
+checksum = "7310708b642fb83c04f44934509f4f149ffd69d0cd4cf76d9645c991177d7ea0"
 dependencies = [
- "log",
- "rustc_version",
  "semver",
  "serde",
  "serde_derive",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
- "solana-sdk",
+ "solana-feature-set",
+ "solana-sanitize",
+ "solana-serde-varint",
 ]
 
 [[package]]
 name = "solana-vote"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cc7a6e32de8a455bf85090a2a7bf4c298fc4ca02279f2829896ee0a28a94272"
+checksum = "5ab46788981765ee706094ca53ad8421aae0286a6b948e892fa7db88992a5373"
 dependencies = [
- "crossbeam-channel",
- "itertools",
+ "itertools 0.12.1",
  "log",
- "rustc_version",
  "serde",
  "serde_derive",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
  "solana-sdk",
- "solana-vote-program",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-vote-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0bab220b03482b90aa1781f7c4d4f073c7c9e7eafe6759d07a1b3efee6e315"
+checksum = "637cadc921725d1804a451ea7d2dff83310a12b75e0b6c83a8bb67ebc02d10f1"
 dependencies = [
  "bincode",
  "log",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "rustc_version",
  "serde",
  "serde_derive",
- "solana-frozen-abi",
- "solana-frozen-abi-macro",
+ "solana-feature-set",
  "solana-metrics",
  "solana-program",
  "solana-program-runtime",
  "solana-sdk",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "solana-wen-restart"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5cde23559cd4a574023d9f39e5edea86ae927829c31dee058b7b49441ce7e71"
+checksum = "fb5c015db11fa341ee48fd17d573f27960d32e027606c7cd0586c07332923062"
 dependencies = [
+ "anyhow",
  "log",
  "prost",
  "prost-build",
  "prost-types",
  "protobuf-src",
- "rustc_version",
+ "rayon",
+ "solana-entry",
  "solana-gossip",
  "solana-ledger",
- "solana-logger",
  "solana-program",
  "solana-runtime",
  "solana-sdk",
+ "solana-timings",
  "solana-vote-program",
 ]
 
+[[package]]
+name = "solana-zk-elgamal-proof-program"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47f5ac026a972c9cbc6bd0f72f692f85ff9ceec961fc4bcb1f2550e6387e962c"
+dependencies = [
+ "bytemuck",
+ "num-derive",
+ "num-traits",
+ "solana-log-collector",
+ "solana-program-runtime",
+ "solana-sdk",
+ "solana-zk-sdk",
+]
+
+[[package]]
+name = "solana-zk-sdk"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18c2d96f65cb033f4dc16d3a1b085f8af0ea38012c514a8f65b9b6d75bc9339f"
+dependencies = [
+ "aes-gcm-siv",
+ "base64 0.22.1",
+ "bincode",
+ "bytemuck",
+ "bytemuck_derive",
+ "curve25519-dalek 4.1.3",
+ "itertools 0.12.1",
+ "js-sys",
+ "lazy_static",
+ "merlin",
+ "num-derive",
+ "num-traits",
+ "rand 0.8.5",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha3",
+ "solana-derivation-path",
+ "solana-program",
+ "solana-sdk",
+ "subtle",
+ "thiserror 1.0.69",
+ "wasm-bindgen",
+ "zeroize",
+]
+
 [[package]]
 name = "solana-zk-token-proof-program"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f77771c8c8d2f8f645a0626e57f72f6c6a83beb5bebb6fd4d7662f7bcc98deea"
+checksum = "83029f0fac09633fc4463dd5a7d13959d1825dccf77889c6e617e2b1265fb2f1"
 dependencies = [
  "bytemuck",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
+ "solana-feature-set",
+ "solana-log-collector",
  "solana-program-runtime",
  "solana-sdk",
  "solana-zk-token-sdk",
@@ -6780,49 +7425,51 @@ dependencies = [
 
 [[package]]
 name = "solana-zk-token-sdk"
-version = "1.18.11"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459c27f7b954798677d8243aa53b8080cfb314ecfecbf8889a5a65c91ad11fee"
+checksum = "ed293089d8eebd6b5c1b53ee4ad6817889fea254274ddb34cb01ad35a2f817cb"
 dependencies = [
  "aes-gcm-siv",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bincode",
  "bytemuck",
+ "bytemuck_derive",
  "byteorder",
- "curve25519-dalek",
- "getrandom 0.1.16",
- "itertools",
+ "curve25519-dalek 4.1.3",
+ "itertools 0.12.1",
  "lazy_static",
  "merlin",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "rand 0.7.3",
+ "rand 0.8.5",
  "serde",
+ "serde_derive",
  "serde_json",
- "sha3 0.9.1",
+ "sha3",
+ "solana-curve25519",
+ "solana-derivation-path",
  "solana-program",
  "solana-sdk",
  "subtle",
- "thiserror",
+ "thiserror 1.0.69",
  "zeroize",
 ]
 
 [[package]]
 name = "solana_rbpf"
-version = "0.8.0"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d457cc2ba742c120492a64b7fa60e22c575e891f6b55039f4d736568fb112a3"
+checksum = "1c1941b5ef0c3ce8f2ac5dd984d0fb1a97423c4ff2a02eec81e3913f02e2ac2b"
 dependencies = [
  "byteorder",
- "combine",
- "goblin",
+ "combine 3.8.1",
  "hash32",
  "libc",
  "log",
  "rand 0.8.5",
  "rustc-demangle",
  "scroll",
- "thiserror",
+ "thiserror 1.0.69",
  "winapi 0.3.9",
 ]
 
@@ -6839,148 +7486,142 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "511254be0c5bcf062b019a6c89c01a664aa359ded62f78aa72c6fc137c0590e5"
 
 [[package]]
-name = "spki"
-version = "0.5.4"
+name = "spinning_top"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d01ac02a6ccf3e07db148d2be087da624fea0221a16152ed01f0496a6b0a27"
+checksum = "d96d2d1d716fb500937168cc09353ffdc7a012be8475ac7308e1bdf0e3923300"
 dependencies = [
- "base64ct",
- "der",
+ "lock_api",
 ]
 
 [[package]]
 name = "spl-associated-token-account"
-version = "2.3.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "992d9c64c2564cc8f63a4b508bf3ebcdf2254b0429b13cd1d31adb6162432a5f"
+checksum = "68034596cf4804880d265f834af1ff2f821ad5293e41fa0f8f59086c181fc38e"
 dependencies = [
  "assert_matches",
- "borsh 0.10.3",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "solana-program",
- "spl-token 4.0.0",
- "spl-token-2022 1.0.0",
- "thiserror",
+ "spl-token 6.0.0",
+ "spl-token-2022 4.0.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-associated-token-account"
-version = "3.0.2"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76fee7d65013667032d499adc3c895e286197a35a0d3a4643c80e7fd3e9969e3"
 dependencies = [
- "assert_matches",
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "solana-program",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
- "thiserror",
+ "spl-associated-token-account-client",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "spl-associated-token-account-test"
-version = "0.0.1"
+name = "spl-associated-token-account-client"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f8349dbcbe575f354f9a533a21f272f3eb3808a49e2fdc1c34393b88ba76cb"
 dependencies = [
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
+ "solana-instruction",
+ "solana-pubkey",
 ]
 
 [[package]]
 name = "spl-binary-oracle-pair"
 version = "0.1.0"
 dependencies = [
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
  "uint",
 ]
 
 [[package]]
 name = "spl-concurrent-merkle-tree"
-version = "0.2.0"
+version = "0.4.0"
 dependencies = [
  "bytemuck",
  "rand 0.8.5",
  "rand_distr",
  "solana-program",
  "spl-merkle-tree-reference",
- "thiserror",
+ "thiserror 2.0.9",
  "tokio",
 ]
 
 [[package]]
 name = "spl-discriminator"
-version = "0.1.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cce5d563b58ef1bb2cdbbfe0dfb9ffdc24903b10ae6a4df2d8f425ece375033f"
+checksum = "a38ea8b6dedb7065887f12d62ed62c1743aa70749e8558f963609793f6fb12bc"
 dependencies = [
  "bytemuck",
  "solana-program",
- "spl-discriminator-derive 0.1.1",
+ "spl-discriminator-derive",
 ]
 
 [[package]]
 name = "spl-discriminator"
-version = "0.2.2"
-dependencies = [
- "borsh 1.5.1",
- "bytemuck",
- "solana-program",
- "spl-discriminator-derive 0.2.0",
-]
-
-[[package]]
-name = "spl-discriminator-derive"
-version = "0.1.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fadbefec4f3c678215ca72bd71862697bb06b41fd77c0088902dd3203354387b"
+checksum = "a7398da23554a31660f17718164e31d31900956054f54f52d5ec1be51cb4f4b3"
 dependencies = [
- "quote",
- "spl-discriminator-syn 0.1.1",
- "syn 2.0.46",
+ "bytemuck",
+ "solana-program-error",
+ "solana-sha256-hasher",
+ "spl-discriminator-derive",
 ]
 
 [[package]]
 name = "spl-discriminator-derive"
 version = "0.2.0"
-dependencies = [
- "quote",
- "spl-discriminator-syn 0.2.0",
- "syn 2.0.46",
-]
-
-[[package]]
-name = "spl-discriminator-syn"
-version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e5f2044ca42c8938d54d1255ce599c79a1ffd86b677dfab695caa20f9ffc3f2"
+checksum = "d9e8418ea6269dcfb01c712f0444d2c75542c04448b480e87de59d2865edc750"
 dependencies = [
- "proc-macro2",
  "quote",
- "sha2 0.10.8",
- "syn 2.0.46",
- "thiserror",
+ "spl-discriminator-syn",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "spl-discriminator-syn"
 version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c1f05593b7ca9eac7caca309720f2eafb96355e037e6d373b909a80fe7b69b9"
 dependencies = [
  "proc-macro2",
  "quote",
  "sha2 0.10.8",
- "syn 2.0.46",
- "thiserror",
+ "syn 2.0.87",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spl-elgamal-registry"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a157622a63a4d12fbd8b347fd75ee442cb913137fa98647824c992fb049a15b"
+dependencies = [
+ "bytemuck",
+ "solana-program",
+ "solana-zk-sdk",
+ "spl-pod 0.5.0",
+ "spl-token-confidential-transfer-proof-extraction",
 ]
 
 [[package]]
@@ -7035,32 +7676,7 @@ dependencies = [
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-token 4.0.1",
-]
-
-[[package]]
-name = "spl-feature-proposal"
-version = "1.0.0"
-dependencies = [
- "borsh 1.5.1",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-token 4.0.1",
-]
-
-[[package]]
-name = "spl-feature-proposal-cli"
-version = "1.2.0"
-dependencies = [
- "chrono",
- "clap 2.34.0",
- "solana-clap-utils",
- "solana-cli-config",
- "solana-client",
- "solana-logger",
- "solana-sdk",
- "spl-feature-proposal",
+ "spl-token 7.0.0",
 ]
 
 [[package]]
@@ -7071,8 +7687,8 @@ dependencies = [
  "assert_matches",
  "base64 0.22.1",
  "bincode",
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "proptest",
  "serde",
@@ -7084,15 +7700,15 @@ dependencies = [
  "spl-governance-addin-mock",
  "spl-governance-test-sdk",
  "spl-governance-tools",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-governance-addin-api"
 version = "0.1.4"
 dependencies = [
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "solana-program",
  "spl-governance-tools",
 ]
@@ -7104,8 +7720,8 @@ dependencies = [
  "arrayref",
  "assert_matches",
  "bincode",
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "proptest",
  "serde",
@@ -7116,8 +7732,8 @@ dependencies = [
  "spl-governance-addin-api",
  "spl-governance-test-sdk",
  "spl-governance-tools",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -7127,8 +7743,8 @@ dependencies = [
  "arrayref",
  "assert_matches",
  "bincode",
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "proptest",
  "serde",
@@ -7141,8 +7757,8 @@ dependencies = [
  "spl-governance-addin-mock",
  "spl-governance-test-sdk",
  "spl-governance-tools",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -7151,17 +7767,17 @@ version = "0.1.4"
 dependencies = [
  "arrayref",
  "bincode",
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "lazy_static",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "serde",
  "serde_derive",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -7170,72 +7786,76 @@ version = "0.1.4"
 dependencies = [
  "arrayref",
  "bincode",
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "serde",
  "serde_derive",
  "solana-program",
- "spl-token 4.0.1",
- "thiserror",
-]
-
-[[package]]
-name = "spl-instruction-padding"
-version = "0.1.1"
-dependencies = [
- "num_enum 0.7.2",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-managed-token"
 version = "0.1.0"
 dependencies = [
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "shank",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-associated-token-account 6.0.0",
+ "spl-associated-token-account-client",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-math"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
- "borsh 1.5.1",
  "libm",
- "num-derive 0.4.2",
  "num-traits",
  "proptest",
+ "uint",
+]
+
+[[package]]
+name = "spl-math-example"
+version = "0.1.0"
+dependencies = [
+ "borsh 1.5.3",
+ "num-derive",
+ "num-traits",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "thiserror",
- "uint",
+ "spl-math",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-memo"
-version = "4.0.0"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f180b03318c3dbab3ef4e1e4d46d5211ae3c780940dd0a28695aba4b59a75a"
+checksum = "a0dba2f2bb6419523405d21c301a32c9f9568354d4742552e7972af801f4bdb3"
 dependencies = [
  "solana-program",
 ]
 
 [[package]]
 name = "spl-memo"
-version = "4.0.1"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f09647c0974e33366efeb83b8e2daebb329f0420149e74d3a4bd2c08cf9f7cb"
 dependencies = [
- "solana-program",
- "solana-program-test",
- "solana-sdk",
+ "solana-account-info",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-entrypoint",
+ "solana-program-error",
+ "solana-pubkey",
 ]
 
 [[package]]
@@ -7243,110 +7863,113 @@ name = "spl-merkle-tree-reference"
 version = "0.1.0"
 dependencies = [
  "solana-program",
- "thiserror",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-name-service"
 version = "0.3.0"
 dependencies = [
- "borsh 1.5.1",
- "num-derive 0.4.2",
+ "borsh 1.5.3",
+ "num-derive",
  "num-traits",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "thiserror",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-pod"
-version = "0.1.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2881dddfca792737c0706fa0175345ab282b1b0879c7d877bad129645737c079"
+checksum = "e6166a591d93af33afd75bbd8573c5fd95fb1213f1bf254f0508c89fdb5ee156"
 dependencies = [
- "borsh 0.10.3",
+ "borsh 1.5.3",
  "bytemuck",
+ "bytemuck_derive",
  "solana-program",
  "solana-zk-token-sdk",
- "spl-program-error 0.3.0",
+ "spl-program-error 0.5.0",
 ]
 
 [[package]]
 name = "spl-pod"
-version = "0.2.2"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a7d5950993e1ff2680bd989df298eeb169367fb2f9deeef1f132de6e4e8016"
 dependencies = [
- "base64 0.22.1",
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "bytemuck",
- "serde",
- "serde_json",
- "solana-program",
- "solana-zk-token-sdk",
- "spl-program-error 0.4.1",
+ "bytemuck_derive",
+ "num-derive",
+ "num-traits",
+ "solana-decode-error",
+ "solana-msg",
+ "solana-program-error",
+ "solana-program-option",
+ "solana-pubkey",
+ "solana-zk-sdk",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-program-error"
-version = "0.3.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "249e0318493b6bcf27ae9902600566c689b7dfba9f1bdff5893e92253374e78c"
+checksum = "d7b28bed65356558133751cc32b48a7a5ddfc59ac4e941314630bbed1ac10532"
 dependencies = [
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "solana-program",
- "spl-program-error-derive 0.3.1",
- "thiserror",
+ "spl-program-error-derive",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-program-error"
-version = "0.4.1"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d39b5186f42b2b50168029d81e58e800b690877ef0b30580d107659250da1d1"
 dependencies = [
- "lazy_static",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "serial_test",
  "solana-program",
- "solana-sdk",
- "spl-program-error-derive 0.4.1",
- "thiserror",
-]
-
-[[package]]
-name = "spl-program-error-derive"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5269c8e868da17b6552ef35a51355a017bd8e0eae269c201fef830d35fa52c"
-dependencies = [
- "proc-macro2",
- "quote",
- "sha2 0.10.8",
- "syn 2.0.46",
+ "spl-program-error-derive",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-program-error-derive"
 version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d375dd76c517836353e093c2dbb490938ff72821ab568b545fd30ab3256b3e"
 dependencies = [
  "proc-macro2",
  "quote",
  "sha2 0.10.8",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "spl-record"
-version = "0.2.0"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1288810a85bbe7e62ee3c6f7b8119e8c1016e90351411d12e4132e98c7ca7344"
 dependencies = [
  "bytemuck",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-pod 0.2.2",
- "thiserror",
+ "solana-account-info",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-entrypoint",
+ "solana-program-error",
+ "solana-program-pack",
+ "solana-pubkey",
+ "solana-rent",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -7359,306 +7982,134 @@ dependencies = [
  "solana-sdk",
 ]
 
-[[package]]
-name = "spl-single-pool"
-version = "1.0.1"
-dependencies = [
- "approx",
- "arrayref",
- "bincode",
- "borsh 1.5.1",
- "num-derive 0.4.2",
- "num-traits",
- "num_enum 0.7.2",
- "rand 0.8.5",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "solana-security-txt",
- "solana-vote-program",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "test-case",
- "thiserror",
-]
-
-[[package]]
-name = "spl-single-pool-cli"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "borsh 1.5.1",
- "clap 3.2.25",
- "console",
- "serde",
- "serde_derive",
- "serde_json",
- "serde_with 3.8.1",
- "serial_test",
- "solana-account-decoder",
- "solana-clap-v3-utils",
- "solana-cli-config",
- "solana-cli-output",
- "solana-client",
- "solana-logger",
- "solana-remote-wallet",
- "solana-sdk",
- "solana-test-validator",
- "solana-transaction-status",
- "solana-vote-program",
- "spl-associated-token-account 3.0.2",
- "spl-single-pool",
- "spl-token 4.0.1",
- "spl-token-client",
- "tempfile",
- "test-case",
- "tokio",
-]
-
-[[package]]
-name = "spl-stake-pool"
-version = "1.0.0"
-dependencies = [
- "arrayref",
- "assert_matches",
- "bincode",
- "borsh 1.5.1",
- "bytemuck",
- "num-derive 0.4.2",
- "num-traits",
- "num_enum 0.7.2",
- "proptest",
- "serde",
- "serde_derive",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "solana-security-txt",
- "solana-vote-program",
- "spl-math",
- "spl-pod 0.2.2",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
- "test-case",
- "thiserror",
-]
-
-[[package]]
-name = "spl-stake-pool-cli"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "borsh 1.5.1",
- "bs58",
- "clap 2.34.0",
- "serde",
- "serde_derive",
- "serde_json",
- "solana-account-decoder",
- "solana-clap-utils",
- "solana-cli-config",
- "solana-cli-output",
- "solana-client",
- "solana-logger",
- "solana-program",
- "solana-remote-wallet",
- "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-stake-pool",
- "spl-token 4.0.1",
-]
-
 [[package]]
 name = "spl-tlv-account-resolution"
-version = "0.5.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f335787add7fa711819f9e7c573f8145a5358a709446fe2d24bf2a88117c90"
+checksum = "37a75a5f0fcc58126693ed78a17042e9dc53f07e357d6be91789f7d62aff61a4"
 dependencies = [
  "bytemuck",
  "solana-program",
- "spl-discriminator 0.1.0",
- "spl-pod 0.1.0",
- "spl-program-error 0.3.0",
- "spl-type-length-value 0.3.0",
+ "spl-discriminator 0.3.0",
+ "spl-pod 0.3.0",
+ "spl-program-error 0.5.0",
+ "spl-type-length-value 0.5.0",
 ]
 
 [[package]]
 name = "spl-tlv-account-resolution"
-version = "0.6.3"
-dependencies = [
- "bytemuck",
- "futures 0.3.30",
- "futures-util",
- "serde",
- "solana-client",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-type-length-value 0.4.3",
-]
-
-[[package]]
-name = "spl-token"
-version = "4.0.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08459ba1b8f7c1020b4582c4edf0f5c7511a5e099a7a97570c9698d4f2337060"
+checksum = "cd99ff1e9ed2ab86e3fd582850d47a739fec1be9f4661cba1782d3a0f26805f3"
 dependencies = [
- "arrayref",
  "bytemuck",
- "num-derive 0.3.3",
+ "num-derive",
  "num-traits",
- "num_enum 0.6.1",
- "solana-program",
- "thiserror",
+ "solana-account-info",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-error",
+ "solana-pubkey",
+ "spl-discriminator 0.4.1",
+ "spl-pod 0.5.0",
+ "spl-program-error 0.6.0",
+ "spl-type-length-value 0.7.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-token"
-version = "4.0.1"
-dependencies = [
- "arrayref",
- "bytemuck",
- "lazy_static",
- "num-derive 0.4.2",
- "num-traits",
- "num_enum 0.7.2",
- "proptest",
- "serial_test",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "thiserror",
-]
-
-[[package]]
-name = "spl-token-2022"
-version = "1.0.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d697fac19fd74ff472dfcc13f0b442dd71403178ce1de7b5d16f83a33561c059"
+checksum = "70a0f06ac7f23dc0984931b1fe309468f14ea58e32660439c1cef19456f5d0e3"
 dependencies = [
  "arrayref",
  "bytemuck",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "num_enum 0.7.2",
+ "num_enum",
  "solana-program",
- "solana-security-txt",
- "solana-zk-token-sdk",
- "spl-memo 4.0.0",
- "spl-pod 0.1.0",
- "spl-token 4.0.0",
- "spl-token-group-interface 0.1.0",
- "spl-token-metadata-interface 0.2.0",
- "spl-transfer-hook-interface 0.4.1",
- "spl-type-length-value 0.3.0",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "spl-token-2022"
-version = "3.0.2"
+name = "spl-token"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed320a6c934128d4f7e54fe00e16b8aeaecf215799d060ae14f93378da6dc834"
 dependencies = [
  "arrayref",
- "base64 0.22.1",
  "bytemuck",
- "lazy_static",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "num_enum 0.7.2",
- "proptest",
- "serde",
- "serde_json",
- "serde_with 3.8.1",
- "serial_test",
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "solana-security-txt",
- "solana-zk-token-sdk",
- "spl-memo 4.0.1",
- "spl-pod 0.2.2",
- "spl-tlv-account-resolution 0.6.3",
- "spl-token 4.0.1",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "spl-transfer-hook-interface 0.6.3",
- "spl-type-length-value 0.4.3",
- "thiserror",
-]
-
-[[package]]
-name = "spl-token-2022-test"
-version = "0.0.1"
-dependencies = [
- "async-trait",
- "borsh 1.5.1",
- "futures-util",
+ "num_enum",
  "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-instruction-padding",
- "spl-memo 4.0.1",
- "spl-pod 0.2.2",
- "spl-tlv-account-resolution 0.6.3",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "spl-transfer-hook-example",
- "spl-transfer-hook-interface 0.6.3",
- "test-case",
- "walkdir",
+ "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "spl-token-cli"
-version = "3.4.1"
-dependencies = [
- "assert_cmd",
- "base64 0.22.1",
- "clap 2.34.0",
- "console",
- "futures 0.3.30",
- "libtest-mimic",
- "serde",
- "serde_derive",
- "serde_json",
- "serial_test",
- "solana-account-decoder",
- "solana-clap-utils",
- "solana-cli-config",
- "solana-cli-output",
- "solana-client",
- "solana-logger",
- "solana-remote-wallet",
- "solana-sdk",
- "solana-test-validator",
- "solana-transaction-status",
- "spl-associated-token-account 3.0.2",
- "spl-memo 4.0.1",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "strum 0.26.2",
- "strum_macros 0.26.4",
- "tempfile",
- "tokio",
- "walkdir",
+[[package]]
+name = "spl-token-2022"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c10f3483e48679619c76598d4e4aebb955bc49b0a5cc63323afbf44135c9bf"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "num-derive",
+ "num-traits",
+ "num_enum",
+ "solana-program",
+ "solana-security-txt",
+ "solana-zk-token-sdk",
+ "spl-memo 5.0.0",
+ "spl-pod 0.3.0",
+ "spl-token 6.0.0",
+ "spl-token-group-interface 0.3.0",
+ "spl-token-metadata-interface 0.4.0",
+ "spl-transfer-hook-interface 0.7.0",
+ "spl-type-length-value 0.5.0",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spl-token-2022"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b27f7405010ef816587c944536b0eafbcc35206ab6ba0f2ca79f1d28e488f4f"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "num-derive",
+ "num-traits",
+ "num_enum",
+ "solana-program",
+ "solana-security-txt",
+ "solana-zk-sdk",
+ "spl-elgamal-registry",
+ "spl-memo 6.0.0",
+ "spl-pod 0.5.0",
+ "spl-token 7.0.0",
+ "spl-token-confidential-transfer-ciphertext-arithmetic",
+ "spl-token-confidential-transfer-proof-extraction",
+ "spl-token-confidential-transfer-proof-generation",
+ "spl-token-group-interface 0.5.0",
+ "spl-token-metadata-interface 0.6.0",
+ "spl-transfer-hook-interface 0.9.0",
+ "spl-type-length-value 0.7.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-token-client"
-version = "0.10.0"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9155237581388a928822ce91caf936cf54406d27bf21def44f18b25e304ba0e"
 dependencies = [
  "async-trait",
- "curve25519-dalek",
- "futures 0.3.30",
+ "bincode",
+ "bytemuck",
+ "futures 0.3.31",
  "futures-util",
  "solana-banks-interface",
  "solana-cli-output",
@@ -7666,73 +8117,87 @@ dependencies = [
  "solana-rpc-client",
  "solana-rpc-client-api",
  "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-memo 4.0.1",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "spl-transfer-hook-interface 0.6.3",
- "thiserror",
+ "spl-associated-token-account-client",
+ "spl-elgamal-registry",
+ "spl-memo 6.0.0",
+ "spl-record",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
+ "spl-token-confidential-transfer-proof-extraction",
+ "spl-token-confidential-transfer-proof-generation",
+ "spl-token-group-interface 0.5.0",
+ "spl-token-metadata-interface 0.6.0",
+ "spl-transfer-hook-interface 0.9.0",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spl-token-confidential-transfer-ciphertext-arithmetic"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1f1bf731fc65546330a7929a9735679add70f828dd076a4e69b59d3afb5423c"
+dependencies = [
+ "base64 0.22.1",
+ "bytemuck",
+ "solana-curve25519",
+ "solana-zk-sdk",
 ]
 
 [[package]]
-name = "spl-token-collection"
-version = "0.1.0"
+name = "spl-token-confidential-transfer-proof-extraction"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "383937e637ccbe546f736d5115344351ebd4d2a076907582335261da58236816"
 dependencies = [
+ "bytemuck",
+ "solana-curve25519",
  "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-token-group-example",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "spl-type-length-value 0.4.3",
+ "solana-zk-sdk",
+ "spl-pod 0.5.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "spl-token-group-example"
-version = "0.2.1"
+name = "spl-token-confidential-transfer-proof-generation"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8627184782eec1894de8ea26129c61303f1f0adeed65c20e0b10bc584f09356d"
 dependencies = [
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-token-group-interface 0.2.3",
- "spl-token-metadata-interface 0.3.3",
- "spl-type-length-value 0.4.3",
+ "curve25519-dalek 4.1.3",
+ "solana-zk-sdk",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-token-group-interface"
-version = "0.1.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b889509d49fa74a4a033ca5dae6c2307e9e918122d97e58562f5c4ffa795c75d"
+checksum = "df8752b85a5ecc1d9f3a43bce3dd9a6a053673aacf5deb513d1cbb88d3534ffd"
 dependencies = [
  "bytemuck",
  "solana-program",
- "spl-discriminator 0.1.0",
- "spl-pod 0.1.0",
- "spl-program-error 0.3.0",
+ "spl-discriminator 0.3.0",
+ "spl-pod 0.3.0",
+ "spl-program-error 0.5.0",
 ]
 
 [[package]]
 name = "spl-token-group-interface"
-version = "0.2.3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d595667ed72dbfed8c251708f406d7c2814a3fa6879893b323d56a10bedfc799"
 dependencies = [
  "bytemuck",
- "solana-program",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-type-length-value 0.4.3",
+ "num-derive",
+ "num-traits",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-error",
+ "solana-pubkey",
+ "spl-discriminator 0.4.1",
+ "spl-pod 0.5.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -7742,14 +8207,14 @@ dependencies = [
  "arrayref",
  "assert_matches",
  "bytemuck",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "proptest",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
  "uint",
 ]
 
@@ -7764,51 +8229,43 @@ dependencies = [
  "solana-logger",
  "solana-program",
  "solana-sdk",
- "spl-token 4.0.1",
+ "spl-token 7.0.0",
  "spl-token-lending",
 ]
 
-[[package]]
-name = "spl-token-metadata-example"
-version = "0.3.0"
-dependencies = [
- "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-pod 0.2.2",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-token-metadata-interface 0.3.3",
- "spl-type-length-value 0.4.3",
- "test-case",
-]
-
 [[package]]
 name = "spl-token-metadata-interface"
-version = "0.2.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c16ce3ba6979645fb7627aa1e435576172dd63088dc7848cb09aa331fa1fe4f"
+checksum = "c6c2318ddff97e006ed9b1291ebec0750a78547f870f62a69c56fe3b46a5d8fc"
 dependencies = [
- "borsh 0.10.3",
+ "borsh 1.5.3",
  "solana-program",
- "spl-discriminator 0.1.0",
- "spl-pod 0.1.0",
- "spl-program-error 0.3.0",
- "spl-type-length-value 0.3.0",
+ "spl-discriminator 0.3.0",
+ "spl-pod 0.3.0",
+ "spl-program-error 0.5.0",
+ "spl-type-length-value 0.5.0",
 ]
 
 [[package]]
 name = "spl-token-metadata-interface"
-version = "0.3.3"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfb9c89dbc877abd735f05547dcf9e6e12c00c11d6d74d8817506cab4c99fdbb"
 dependencies = [
- "borsh 1.5.1",
- "serde",
- "serde_json",
- "solana-program",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-type-length-value 0.4.3",
+ "borsh 1.5.3",
+ "num-derive",
+ "num-traits",
+ "solana-borsh",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-error",
+ "solana-pubkey",
+ "spl-discriminator 0.4.1",
+ "spl-pod 0.5.0",
+ "spl-type-length-value 0.7.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -7818,17 +8275,17 @@ dependencies = [
  "arbitrary",
  "arrayref",
  "enum_dispatch",
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
  "proptest",
  "roots",
  "solana-program",
  "solana-sdk",
  "spl-math",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
  "test-case",
- "thiserror",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -7839,7 +8296,7 @@ dependencies = [
  "honggfuzz",
  "solana-program",
  "spl-math",
- "spl-token 4.0.1",
+ "spl-token 7.0.0",
  "spl-token-swap",
 ]
 
@@ -7847,17 +8304,17 @@ dependencies = [
 name = "spl-token-upgrade"
 version = "0.1.1"
 dependencies = [
- "num-derive 0.4.2",
+ "num-derive",
  "num-traits",
- "num_enum 0.7.2",
+ "num_enum",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
  "spl-token-client",
  "test-case",
- "thiserror",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -7873,9 +8330,9 @@ dependencies = [
  "solana-remote-wallet",
  "solana-sdk",
  "solana-test-validator",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
+ "spl-associated-token-account-client",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
  "spl-token-client",
  "spl-token-upgrade",
  "tokio",
@@ -7887,140 +8344,97 @@ name = "spl-token-wrap"
 version = "0.1.0"
 dependencies = [
  "bytemuck",
- "num_enum 0.7.2",
- "solana-program",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "spl-token-2022 3.0.2",
- "thiserror",
-]
-
-[[package]]
-name = "spl-transfer-hook-cli"
-version = "0.2.0"
-dependencies = [
- "clap 3.2.25",
- "futures-util",
- "serde",
- "serde_json",
- "serde_yaml",
- "solana-clap-v3-utils",
- "solana-cli-config",
- "solana-client",
- "solana-logger",
- "solana-remote-wallet",
- "solana-sdk",
- "solana-test-validator",
- "spl-tlv-account-resolution 0.6.3",
- "spl-token-2022 3.0.2",
- "spl-token-client",
- "spl-transfer-hook-example",
- "spl-transfer-hook-interface 0.6.3",
- "strum 0.26.2",
- "strum_macros 0.26.4",
- "tokio",
-]
-
-[[package]]
-name = "spl-transfer-hook-example"
-version = "0.6.0"
-dependencies = [
- "arrayref",
+ "num_enum",
  "solana-program",
- "solana-program-test",
- "solana-sdk",
- "spl-tlv-account-resolution 0.6.3",
- "spl-token-2022 3.0.2",
- "spl-transfer-hook-interface 0.6.3",
- "spl-type-length-value 0.4.3",
+ "spl-associated-token-account 6.0.0",
+ "spl-token 7.0.0",
+ "spl-token-2022 6.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
 name = "spl-transfer-hook-interface"
-version = "0.4.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aabdb7c471566f6ddcee724beb8618449ea24b399e58d464d6b5bc7db550259"
+checksum = "a110f33d941275d9f868b96daaa993f1e73b6806cc8836e43075b4d3ad8338a7"
 dependencies = [
  "arrayref",
  "bytemuck",
  "solana-program",
- "spl-discriminator 0.1.0",
- "spl-pod 0.1.0",
- "spl-program-error 0.3.0",
- "spl-tlv-account-resolution 0.5.2",
- "spl-type-length-value 0.3.0",
+ "spl-discriminator 0.3.0",
+ "spl-pod 0.3.0",
+ "spl-program-error 0.5.0",
+ "spl-tlv-account-resolution 0.7.0",
+ "spl-type-length-value 0.5.0",
 ]
 
 [[package]]
 name = "spl-transfer-hook-interface"
-version = "0.6.3"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa7503d52107c33c88e845e1351565050362c2314036ddf19a36cd25137c043"
 dependencies = [
  "arrayref",
  "bytemuck",
- "solana-program",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-tlv-account-resolution 0.6.3",
- "spl-type-length-value 0.4.3",
- "tokio",
+ "num-derive",
+ "num-traits",
+ "solana-account-info",
+ "solana-cpi",
+ "solana-decode-error",
+ "solana-instruction",
+ "solana-msg",
+ "solana-program-error",
+ "solana-pubkey",
+ "spl-discriminator 0.4.1",
+ "spl-pod 0.5.0",
+ "spl-program-error 0.6.0",
+ "spl-tlv-account-resolution 0.9.0",
+ "spl-type-length-value 0.7.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "spl-type-length-value"
-version = "0.3.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a468e6f6371f9c69aae760186ea9f1a01c2908351b06a5e0026d21cfc4d7ecac"
+checksum = "bdcd73ec187bc409464c60759232e309f83b52a18a9c5610bf281c9c6432918c"
 dependencies = [
  "bytemuck",
  "solana-program",
- "spl-discriminator 0.1.0",
- "spl-pod 0.1.0",
- "spl-program-error 0.3.0",
+ "spl-discriminator 0.3.0",
+ "spl-pod 0.3.0",
+ "spl-program-error 0.5.0",
 ]
 
 [[package]]
 name = "spl-type-length-value"
-version = "0.4.3"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba70ef09b13af616a4c987797870122863cba03acc4284f226a4473b043923f9"
 dependencies = [
  "bytemuck",
- "solana-program",
- "spl-discriminator 0.2.2",
- "spl-pod 0.2.2",
- "spl-program-error 0.4.1",
- "spl-type-length-value-derive",
-]
-
-[[package]]
-name = "spl-type-length-value-derive"
-version = "0.1.0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.46",
-]
-
-[[package]]
-name = "spl-type-length-value-derive-test"
-version = "0.1.0"
-dependencies = [
- "borsh 1.5.1",
- "solana-program",
- "spl-discriminator 0.2.2",
- "spl-type-length-value 0.4.3",
+ "num-derive",
+ "num-traits",
+ "solana-account-info",
+ "solana-decode-error",
+ "solana-msg",
+ "solana-program-error",
+ "spl-discriminator 0.4.1",
+ "spl-pod 0.5.0",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
 name = "stateless-asks"
 version = "0.1.0"
 dependencies = [
- "borsh 1.5.1",
+ "borsh 1.5.3",
  "solana-program",
  "solana-program-test",
  "solana-sdk",
- "spl-associated-token-account 3.0.2",
- "spl-token 4.0.1",
- "thiserror",
+ "spl-associated-token-account-client",
+ "spl-token 7.0.0",
+ "thiserror 2.0.9",
 ]
 
 [[package]]
@@ -8058,15 +8472,9 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
 dependencies = [
- "strum_macros 0.24.3",
+ "strum_macros",
 ]
 
-[[package]]
-name = "strum"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
-
 [[package]]
 name = "strum_macros"
 version = "0.24.3"
@@ -8080,24 +8488,11 @@ dependencies = [
  "syn 1.0.107",
 ]
 
-[[package]]
-name = "strum_macros"
-version = "0.26.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
-dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.46",
-]
-
 [[package]]
 name = "subtle"
-version = "2.4.1"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "symlink"
@@ -8118,32 +8513,20 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.46"
+version = "2.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89456b690ff72fddcecf231caedbe615c59480c93358a93dfae7fc29e3ebbf0e"
+checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
-[[package]]
-name = "syn_derive"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 2.0.46",
-]
-
 [[package]]
 name = "sync_wrapper"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
 [[package]]
 name = "synstructure"
@@ -8176,7 +8559,7 @@ dependencies = [
  "bitflags 1.3.2",
  "byteorder",
  "libc",
- "thiserror",
+ "thiserror 1.0.69",
  "walkdir",
 ]
 
@@ -8203,9 +8586,9 @@ dependencies = [
 
 [[package]]
 name = "tar"
-version = "0.4.40"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+checksum = "4ff6c40d3aedb5e06b57c6f669ad17ab063dd1e63d977c6a88e7f4dfa4f04020"
 dependencies = [
  "filetime",
  "libc",
@@ -8220,7 +8603,7 @@ checksum = "1c38a012bed6fb9681d3bf71ffaa4f88f3b4b9ed3198cda6e4c8462d24d4bb80"
 dependencies = [
  "anyhow",
  "fnv",
- "futures 0.3.30",
+ "futures 0.3.31",
  "humantime",
  "opentelemetry",
  "pin-project",
@@ -8228,7 +8611,7 @@ dependencies = [
  "serde",
  "static_assertions",
  "tarpc-plugins",
- "thiserror",
+ "thiserror 1.0.69",
  "tokio",
  "tokio-serde",
  "tokio-util 0.6.9",
@@ -8247,16 +8630,26 @@ dependencies = [
  "syn 1.0.107",
 ]
 
+[[package]]
+name = "task-local-extensions"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba323866e5d033818e3240feeb9f7db2c4296674e4d9e16b97b7bf8f490434e8"
+dependencies = [
+ "pin-utils",
+]
+
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
 dependencies = [
  "cfg-if 1.0.0",
  "fastrand",
+ "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -8293,7 +8686,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -8305,7 +8698,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
  "test-case-core",
 ]
 
@@ -8314,8 +8707,8 @@ name = "test-client"
 version = "0.1.0"
 dependencies = [
  "solana-sdk",
- "spl-memo 4.0.1",
- "spl-token 4.0.1",
+ "spl-memo 6.0.0",
+ "spl-token 7.0.0",
  "spl-token-swap",
 ]
 
@@ -8325,7 +8718,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 dependencies = [
- "unicode-width",
+ "unicode-width 0.1.9",
 ]
 
 [[package]]
@@ -8336,49 +8729,63 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.9",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
-name = "thread_local"
-version = "1.1.4"
+name = "thiserror-impl"
+version = "2.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
 dependencies = [
- "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
 ]
 
 [[package]]
-name = "threadpool"
-version = "1.8.1"
+name = "thread_local"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
 dependencies = [
- "num_cpus",
+ "once_cell",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.22"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea9e1b3cf1243ae005d9e74085d4d542f3125458f3a81af210d901dcd7411efd"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
+ "deranged",
  "itoa",
+ "num-conv",
+ "powerfmt",
  "serde",
  "time-core",
  "time-macros",
@@ -8386,16 +8793,17 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.9"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "372950940a5f07bf38dbe211d7283c9e6d7327df53794992d293e534c733d09b"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
@@ -8410,9 +8818,9 @@ dependencies = [
  "once_cell",
  "pbkdf2 0.4.0",
  "rand 0.7.3",
- "rustc-hash",
- "sha2 0.9.8",
- "thiserror",
+ "rustc-hash 1.1.0",
+ "sha2 0.9.9",
+ "thiserror 1.0.69",
  "unicode-normalization",
  "wasm-bindgen",
  "zeroize",
@@ -8420,9 +8828,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.5.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -8435,21 +8843,20 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
 
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "5cec9b21b0450273377fc97bd4c33a8acffc8c996c987a7c5b319a0083707551"
 dependencies = [
  "backtrace",
  "bytes",
  "libc",
  "mio",
- "num_cpus",
  "parking_lot 0.12.0",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8464,13 +8871,13 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
+checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -8489,7 +8896,7 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls",
+ "rustls 0.21.12",
  "tokio",
 ]
 
@@ -8511,9 +8918,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.14"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
+checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -8528,7 +8935,7 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
 dependencies = [
  "futures-util",
  "log",
- "rustls",
+ "rustls 0.21.12",
  "tokio",
  "tokio-rustls",
  "tungstenite",
@@ -8543,7 +8950,6 @@ checksum = "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0"
 dependencies = [
  "bytes",
  "futures-core",
- "futures-io",
  "futures-sink",
  "log",
  "pin-project-lite",
@@ -8559,6 +8965,7 @@ checksum = "0edfdeb067411dba2044da6d1cb2df793dd35add7888d73c16e3381ded401764"
 dependencies = [
  "bytes",
  "futures-core",
+ "futures-io",
  "futures-sink",
  "pin-project-lite",
  "tokio",
@@ -8586,7 +8993,7 @@ version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "indexmap 2.2.1",
+ "indexmap 2.6.0",
  "toml_datetime",
  "winnow",
 ]
@@ -8628,7 +9035,7 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6fdaae4c2c638bb70fe42803a26fbd6fc6ac8c72f5c59f67ecc2a2dcabf4b07"
 dependencies = [
- "prettyplease 0.1.9",
+ "prettyplease",
  "proc-macro2",
  "prost-build",
  "quote",
@@ -8687,7 +9094,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -8749,10 +9156,10 @@ dependencies = [
  "httparse",
  "log",
  "rand 0.8.5",
- "rustls",
+ "rustls 0.21.12",
  "sha1",
- "thiserror",
- "url 2.5.0",
+ "thiserror 1.0.69",
+ "url 2.5.2",
  "utf-8",
  "webpki-roots 0.24.0",
 ]
@@ -8771,9 +9178,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 
 [[package]]
 name = "uint"
-version = "0.9.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
+checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e"
 dependencies = [
  "byteorder",
  "crunchy",
@@ -8829,6 +9236,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
 
+[[package]]
+name = "unicode-width"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.2"
@@ -8837,11 +9250,11 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
 
 [[package]]
 name = "universal-hash"
-version = "0.4.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
 dependencies = [
- "generic-array 0.14.7",
+ "crypto-common",
  "subtle",
 ]
 
@@ -8895,9 +9308,9 @@ dependencies = [
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
  "idna 0.5.0",
@@ -8910,12 +9323,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
-[[package]]
-name = "utf8parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
-
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -8928,6 +9335,12 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
+[[package]]
+name = "vec_extract_if_polyfill"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c9cb5fb67c2692310b6eb3fce7dd4b6e4c9a75be4f2f46b27f0b2b7799759c"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -8989,26 +9402,27 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.90"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1223296a201415c7fad14792dbefaace9bd52b62d33453ade1c5b5f07555406"
+checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e"
 dependencies = [
  "cfg-if 1.0.0",
+ "once_cell",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.90"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcdc935b63408d58a32f8cc9738a0bffd8f05cc7c002086c6ef20b7312ad9dcd"
+checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
  "wasm-bindgen-shared",
 ]
 
@@ -9026,9 +9440,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.90"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4c238561b2d428924c49815533a8b9121c664599558a5d9ec51f8a1740a999"
+checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -9036,22 +9450,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.90"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
+checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.90"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d91413b1c31d7539ba5ef2451af3f0b833a005eb27a631cec32bc0635a8602b"
+checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
 
 [[package]]
 name = "web-sys"
@@ -9069,7 +9483,7 @@ version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b291546d5d9d1eab74f069c77749f2cb8504a12caa20f0f2de93ddbf6f411888"
 dependencies = [
- "rustls-webpki",
+ "rustls-webpki 0.101.7",
 ]
 
 [[package]]
@@ -9078,6 +9492,15 @@ version = "0.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841c67bff177718f1d4dfefde8d8f0e78f9b6589319ba88312f567fc5841a958"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "which"
 version = "4.2.5"
@@ -9147,7 +9570,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -9167,17 +9599,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.0",
- "windows_aarch64_msvc 0.52.0",
- "windows_i686_gnu 0.52.0",
- "windows_i686_msvc 0.52.0",
- "windows_x86_64_gnu 0.52.0",
- "windows_x86_64_gnullvm 0.52.0",
- "windows_x86_64_msvc 0.52.0",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
@@ -9188,9 +9621,9 @@ checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -9200,9 +9633,9 @@ checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -9212,9 +9645,15 @@ checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.0"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -9224,9 +9663,9 @@ checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -9236,9 +9675,9 @@ checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -9248,9 +9687,9 @@ checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -9260,9 +9699,9 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
@@ -9297,26 +9736,19 @@ dependencies = [
  "nom",
  "oid-registry",
  "rusticata-macros",
- "thiserror",
+ "thiserror 1.0.69",
  "time",
 ]
 
 [[package]]
 name = "xattr"
-version = "1.0.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
 dependencies = [
  "libc",
-]
-
-[[package]]
-name = "yasna"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "346d34a236c9d3e5f3b9b74563f238f955bbd05fa0b8b4efa53c130c43982f4c"
-dependencies = [
- "time",
+ "linux-raw-sys",
+ "rustix",
 ]
 
 [[package]]
@@ -9336,55 +9768,53 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.46",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.3.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
 dependencies = [
  "zeroize_derive",
 ]
 
 [[package]]
 name = "zeroize_derive"
-version = "1.2.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65f1a51723ec88c66d5d1fe80c841f17f63587d6691901d66be9bec6c3b51f73"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
- "synstructure",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "zstd"
-version = "0.11.2+zstd.1.5.2"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
+checksum = "fcf2b778a664581e31e389454a7072dab1647606d44f7feea22cd5abb9c9f3f9"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
-version = "5.0.1+zstd.1.5.2"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c12659121420dd6365c5c3de4901f97145b79651fb1d25814020ed2ed0585ae"
+checksum = "54a3ab4db68cea366acc5c897c7b4d4d1b8994a9cd6e6f841f8964566a419059"
 dependencies = [
- "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.1+zstd.1.5.2"
+version = "2.0.13+zstd.1.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fd07cbbc53846d9145dbffdf6dd09a7a0aa52be46741825f5c97bdd4f73f12b"
+checksum = "38ff0f21cfee8f97d94cef41359e0c89aa6113028ab0291aa8ca0038995a95aa"
 dependencies = [
  "cc",
- "libc",
+ "pkg-config",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index f07979180d5..ef88ac61895 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,18 @@
 [profile.dev]
 split-debuginfo = "unpacked"
 
+# The curve25519-dalek crate uses the `simd` backend by default in v4 if
+# possible, which has very slow performance on some platforms with opt-level 0,
+# which is the default for `dev` and `test` builds. This slowdown causes
+# certain interactions in the solana-test-validator, such as verifying ZK
+# proofs in transactions, to take much more than 400ms, creating problems in
+# the test environment. To give better performance in the solana-test-validator
+# during tests and dev builds, override the opt-level to 3 for the crate.
+[profile.dev.package.curve25519-dalek]
+opt-level = 3
+
 [workspace]
 members = [
-  "associated-token-account/program",
-  "associated-token-account/program-test",
   "binary-option/program",
   "binary-oracle-pair/program",
   "examples/rust/cross-program-invocation",
@@ -13,60 +21,46 @@ members = [
   "examples/rust/sysvar",
   "examples/rust/transfer-lamports",
   "examples/rust/transfer-tokens",
-  "feature-proposal/program",
-  "feature-proposal/cli",
   "governance/addin-mock/program",
   "governance/addin-api",
   "governance/program",
   "governance/test-sdk",
   "governance/tools",
   "governance/chat/program",
-  "instruction-padding/program",
-  "libraries/discriminator",
   "libraries/concurrent-merkle-tree",
   "libraries/math",
+  "libraries/math-example",
   "libraries/merkle-tree-reference",
-  "libraries/pod",
-  "libraries/program-error",
-  "libraries/tlv-account-resolution",
-  "libraries/type-length-value",
-  "libraries/type-length-value-derive-test",
-  "memo/program",
   "name-service/program",
   "managed-token/program",
-  "record/program",
   "shared-memory/program",
-  "single-pool/cli",
-  "single-pool/program",
-  "stake-pool/cli",
-  "stake-pool/program",
   "stateless-asks/program",
-  "token-collection/program",
-  "token-group/example",
-  "token-group/interface",
+  #"token-collection/program",
   "token-lending/cli",
+  "token-lending/flash_loan_receiver",
   "token-lending/program",
-  "token-metadata/example",
-  "token-metadata/interface",
   "token-swap/program",
   "token-swap/program/fuzz",
   "token-upgrade/cli",
   "token-upgrade/program",
   "token-wrap/program",
-  "token/cli",
-  "token/program",
-  "token/program-2022",
-  "token/program-2022-test",
-  "token/transfer-hook/cli",
-  "token/transfer-hook/example",
-  "token/transfer-hook/interface",
-  "token/client",
   "utils/cgen",
   "utils/test-client",
-  "token-lending/flash_loan_receiver",
 ]
 
 exclude = [
 ]
 
 resolver = "2"
+
+[workspace.lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+    'cfg(feature, values("frozen-abi", "no-entrypoint"))',
+]
+
+[workspace.metadata.release]
+pre-release-commit-message = "Publish {{crate_name}} v{{version}}"
+tag-message = "Publish {{crate_name}} v{{version}}"
+consolidate-commits = false
diff --git a/README.md b/README.md
index d98f488f3d6..1a3d09fb19a 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,34 @@
+# PLEASE READ: This repo no longer contains the SPL program implementations
+
+This repo still exists in archived form, feel free to fork any reference
+implementations it still contains.
+
+## Migrated Packages
+
+The Solana Program Library repository has been broken up into separate repos for
+each program and set of clients, under the
+[solana-program organization](https://github.com/solana-program).
+
+The following programs have been moved:
+
+* [Associated-Token-Account](https://github.com/solana-program/associated-token-account)
+* [Feature Proposal](https://github.com/solana-program/feature-proposal)
+* [Instruction Padding](https://github.com/solana-program/instruction-padding)
+* [Libraries](https://github.com/solana-program/libraries)
+* [Memo](https://github.com/solana-program/memo)
+* [Record](https://github.com/solana-program/record)
+* [Single Pool](https://github.com/solana-program/single-pool)
+* [Slashing](https://github.com/solana-program/slashing)
+* [Stake Pool](https://github.com/solana-program/stake-pool)
+* [Token](https://github.com/solana-program/token)
+* [Token-2022](https://github.com/solana-program/token-2022)
+* [Token-Group](https://github.com/solana-program/token-group)
+* [Token-Metadata](https://github.com/solana-program/token-metadata)
+* [Token-2022 Transfer Hook](https://github.com/solana-program/transfer-hook)
+
+The governance programs have been moved to https://github.com/Mythic-Project/solana-program-library/tree/master/governance
+
+
 # Solana Program Library
 
 The Solana Program Library (SPL) is a collection of on-chain programs targeting
@@ -17,22 +48,17 @@ the Solana Mainnet Beta. Currently, this includes:
 
 | Program | Version |
 | --- | --- |
-| [token](https://github.com/solana-labs/solana-program-library/tree/master/token/program) | [3.4.0](https://github.com/solana-labs/solana-program-library/releases/tag/token-v3.4.0) |
-| [associated-token-account](https://github.com/solana-labs/solana-program-library/tree/master/associated-token-account/program) | [1.1.0](https://github.com/solana-labs/solana-program-library/releases/tag/associated-token-account-v1.1.0) |
-| [token-2022](https://github.com/solana-labs/solana-program-library/tree/master/token/program-2022) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/token-2022-v1.0.0) |
+| [token](https://github.com/solana-program/token/tree/main/program) | [3.4.0](https://github.com/solana-labs/solana-program-library/releases/tag/token-v3.4.0) |
+| [associated-token-account](https://github.com/solana-program/associated-token-account/tree/main/program) | [1.1.0](https://github.com/solana-labs/solana-program-library/releases/tag/associated-token-account-v1.1.0) |
+| [token-2022](https://github.com/solana-program/token-2022/tree/main/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/token-2022-v1.0.0) |
 | [governance](https://github.com/solana-labs/solana-program-library/tree/master/governance/program) | [3.1.0](https://github.com/solana-labs/solana-program-library/releases/tag/governance-v3.1.0) |
-| [stake-pool](https://github.com/solana-labs/solana-program-library/tree/master/stake-pool/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/stake-pool-v1.0.0) |
+| [stake-pool](https://github.com/solana-program/stake-pool/tree/main/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/stake-pool-v1.0.0) |
 | [account-compression](https://github.com/solana-labs/solana-program-library/tree/master/account-compression/programs/account-compression) | [0.1.3](https://github.com/solana-labs/solana-program-library/releases/tag/account-compression-v0.1.3) |
 | [shared-memory](https://github.com/solana-labs/solana-program-library/tree/master/shared-memory/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/commit/b40e0dd3fd6c0e509dc1e8dd3da0a6d609035bbd) |
-| [feature-proposal](https://github.com/solana-labs/solana-program-library/tree/master/feature-proposal/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/feature-proposal-v1.0.0) |
+| [feature-proposal](https://github.com/solana-program/feature-proposal/tree/main/program) | [1.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/feature-proposal-v1.0.0) |
 | [name-service](https://github.com/solana-labs/solana-program-library/tree/master/name-service/program) | [0.3.0](https://github.com/solana-labs/solana-program-library/releases/tag/name-service-v0.3.0) |
-| [memo](https://github.com/solana-labs/solana-program-library/tree/master/memo/program) | [3.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/memo-v3.0.0) |
-
-In addition, one program is planned for deployment to Solana Mainnet Beta:
-
-| Program | Version |
-| --- | --- |
-| [single-pool](https://github.com/solana-labs/solana-program-library/tree/master/single-pool/program) | [1.0.1](https://github.com/solana-labs/solana-program-library/releases/tag/single-pool-v1.0.1) |
+| [memo](https://github.com/solana-program/memo/tree/main/program) | [3.0.0](https://github.com/solana-labs/solana-program-library/releases/tag/memo-v3.0.0) |
+| [single-pool](https://github.com/solana-program/single-pool/tree/main/program) | [1.0.1](https://github.com/solana-labs/solana-program-library/releases/tag/single-pool-v1.0.1) |
 
 ## Audits
 
@@ -40,13 +66,13 @@ Only a subset of programs within the Solana Program Library repo are audited. Cu
 
 | Program | Last Audit Date | Version |
 | --- | --- | --- |
-| [token](https://github.com/solana-labs/solana-program-library/tree/master/token/program) | 2022-08-04 (Peer review) | [4fadd55](https://github.com/solana-labs/solana-program-library/commit/4fadd553e1c549afd1d62aeb5ffa7ef31d1999d1) |
-| [associated-token-account](https://github.com/solana-labs/solana-program-library/tree/master/associated-token-account/program) | 2022-08-04 (Peer review) | [c00194d](https://github.com/solana-labs/solana-program-library/commit/c00194d2257302f028f44a403c6dee95c0f9c3bc) |
-| [token-2022](https://github.com/solana-labs/solana-program-library/tree/master/token/program-2022) | [2023-11-03](https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecToken2022Audit-2023-11-03.pdf) | [e924132](https://github.com/solana-labs/solana-program-library/tree/e924132d65ba0896249fb4983f6f97caff15721a) |
-| [stake-pool](https://github.com/solana-labs/solana-program-library/tree/master/stake-pool/program) | [2023-12-31](https://github.com/solana-labs/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-12-31.pdf) | [a17fffe](https://github.com/solana-labs/solana-program-library/commit/a17fffe70d6cc13742abfbc4a4a375b087580bc1) |
+| [token](https://github.com/solana-program/token) | 2022-08-04 (Peer review) | [4fadd55](https://github.com/solana-labs/solana-program-library/commit/4fadd553e1c549afd1d62aeb5ffa7ef31d1999d1) |
+| [associated-token-account](https://github.com/solana-program/associated-token-account) | 2022-08-04 (Peer review) | [c00194d](https://github.com/solana-labs/solana-program-library/commit/c00194d2257302f028f44a403c6dee95c0f9c3bc) |
+| [token-2022](https://github.com/solana-program/token-2022) | [2023-11-03](https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecToken2022Audit-2023-11-03.pdf) | [e924132](https://github.com/solana-labs/solana-program-library/tree/e924132d65ba0896249fb4983f6f97caff15721a) |
+| [stake-pool](https://github.com/solana-program/stake-pool) | [2023-12-31](https://github.com/solana-labs/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-12-31.pdf) | [a17fffe](https://github.com/solana-labs/solana-program-library/commit/a17fffe70d6cc13742abfbc4a4a375b087580bc1) |
 | [account-compression](https://github.com/solana-labs/solana-program-library/tree/master/account-compression/programs/account-compression) | [2022-12-05](https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecAccountCompressionAudit-2022-12-03.pdf) | [6e81794](https://github.com/solana-labs/solana-program-library/commit/6e81794) |
 | [shared-memory](https://github.com/solana-labs/solana-program-library/tree/master/shared-memory/program) | [2021-02-25](https://github.com/solana-labs/security-audits/blob/master/spl/KudelskiTokenSwapSharedMemAudit-2021-02-25.pdf) | [b40e0dd](https://github.com/solana-labs/solana-program-library/commit/b40e0dd3fd6c0e509dc1e8dd3da0a6d609035bbd) |
-| [single-pool](https://github.com/solana-labs/solana-program-library/tree/master/single-pool/program) | [2024-01-02](https://github.com/solana-labs/security-audits/blob/master/spl/ZellicSinglePoolAudit-2024-01-02.pdf) | [ef44df9](https://github.com/solana-labs/solana-program-library/commit/ef44df985e76a697ee9a8aabb3a223610e4cf1dc) |
+| [single-pool](https://github.com/solana-program/single-pool) | [2024-01-02](https://github.com/solana-labs/security-audits/blob/master/spl/ZellicSinglePoolAudit-2024-01-02.pdf) | [ef44df9](https://github.com/solana-labs/solana-program-library/commit/ef44df985e76a697ee9a8aabb3a223610e4cf1dc) |
 
 All other programs may be updated from time to time. These programs are not
 audited, so fork and deploy them at your own risk. Here is the full list of
@@ -54,12 +80,11 @@ unaudited programs:
 
 * [binary-option](https://github.com/solana-labs/solana-program-library/tree/master/binary-option/program)
 * [binary-oracle-pair](https://github.com/solana-labs/solana-program-library/tree/master/binary-oracle-pair/program)
-* [feature-proposal](https://github.com/solana-labs/solana-program-library/tree/master/feature-proposal/program)
-* [instruction-padding](https://github.com/solana-labs/solana-program-library/tree/master/instruction-padding/program)
+* [feature-proposal](https://github.com/solana-program/feature-proposal)
+* [instruction-padding](https://github.com/solana-program/instruction-padding)
 * [managed-token](https://github.com/solana-labs/solana-program-library/tree/master/managed-token/program)
-* [memo](https://github.com/solana-labs/solana-program-library/tree/master/memo/program)
 * [name-service](https://github.com/solana-labs/solana-program-library/tree/master/name-service/program)
-* [record](https://github.com/solana-labs/solana-program-library/tree/master/record/program)
+* [record](https://github.com/solana-program/record)
 * [stateless-asks](https://github.com/solana-labs/solana-program-library/tree/master/stateless-asks/program)
 * [token-lending](https://github.com/solana-labs/solana-program-library/tree/master/token-lending/program)
 * [token-swap](https://github.com/solana-labs/solana-program-library/tree/master/token-swap/program)
@@ -82,7 +107,6 @@ all past and present program audits.
 | `spl-account-compression` | Program for managing compressed accounts stored in an off-chain merkle tree | [![Crates.io](https://img.shields.io/crates/v/spl-account-compression)](https://crates.io/crates/spl-account-compression) | [![Docs.rs](https://docs.rs/spl-account-compression/badge.svg)](https://docs.rs/spl-account-compression) |
 | `spl-feature-proposal` | Program using tokens to vote on enabling Solana network features | [![Crates.io](https://img.shields.io/crates/v/spl-feature-proposal)](https://crates.io/crates/spl-feature-proposal) | [![Docs.rs](https://docs.rs/spl-feature-proposal/badge.svg)](https://docs.rs/spl-feature-proposal) |
 | `spl-noop` | Program that does nothing, used for logging instruction data | [![Crates.io](https://img.shields.io/crates/v/spl-noop)](https://crates.io/crates/spl-noop) | [![Docs.rs](https://docs.rs/spl-noop/badge.svg)](https://docs.rs/spl-noop) |
-| `spl-memo` | Program for logging signed memos on-chain | [![Crates.io](https://img.shields.io/crates/v/spl-memo)](https://crates.io/crates/spl-memo) | [![Docs.rs](https://docs.rs/spl-memo/badge.svg)](https://docs.rs/spl-memo) |
 | `spl-name-service` | Program for managing ownership of data on-chain | [![Crates.io](https://img.shields.io/crates/v/spl-name-service)](https://crates.io/crates/spl-name-service) | [![Docs.rs](https://docs.rs/spl-name-service/badge.svg)](https://docs.rs/spl-name-service) |
 | `spl-shared-memory` | Program for sharing data between programs | [![Crates.io](https://img.shields.io/crates/v/spl-shared-memory)](https://crates.io/crates/spl-shared-memory) | [![Docs.rs](https://docs.rs/spl-shared-memory/badge.svg)](https://docs.rs/spl-shared-memory) |
 | `spl-stake-pool` | Program for pooling stake accounts, managed by another entity | [![Crates.io](https://img.shields.io/crates/v/spl-stake-pool)](https://crates.io/crates/spl-stake-pool) | [![Docs.rs](https://docs.rs/spl-stake-pool/badge.svg)](https://docs.rs/spl-stake-pool) |
@@ -110,7 +134,6 @@ all past and present program audits.
 | `@solana/spl-token` | Bindings for the token, token-2022, and associated-token-account programs | [![npm](https://img.shields.io/npm/v/@solana/spl-token.svg)](https://www.npmjs.com/package/@solana/spl-token) | [![Docs](https://img.shields.io/badge/docs-typedoc-blue)](https://solana-labs.github.io/solana-program-library/token/js) |
 | `@solana/spl-governance` | Bindings for the governance program | [![npm](https://img.shields.io/npm/v/@solana/spl-governance.svg)](https://www.npmjs.com/package/@solana/spl-governance) | N/A |
 | `@solana/spl-account-compression` | Bindings for the account-compression program | [![npm](https://img.shields.io/npm/v/@solana/spl-account-compression.svg)](https://www.npmjs.com/package/@solana/spl-account-compression) | [![Docs](https://img.shields.io/badge/docs-typedoc-blue)](https://solana-labs.github.io/solana-program-library/account-compression/sdk/docs) |
-| `@solana/spl-memo` | Bindings for the memo program | [![npm](https://img.shields.io/npm/v/@solana/spl-memo.svg)](https://www.npmjs.com/package/@solana/spl-memo) | N/A |
 | `@solana/spl-name-service` | Bindings for the name-service program | [![npm](https://img.shields.io/npm/v/@solana/spl-name-service.svg)](https://www.npmjs.com/package/@solana/spl-name-service) | N/A |
 | `@solana/spl-stake-pool` | Bindings for the stake-pool program | [![npm](https://img.shields.io/npm/v/@solana/spl-stake-pool.svg)](https://www.npmjs.com/package/@solana/spl-stake-pool) | N/A |
 | `@solana/spl-token-lending` | Bindings for the token-lending program | [![npm](https://img.shields.io/npm/v/@solana/spl-token-lending.svg)](https://www.npmjs.com/package/@solana/spl-token-lending) | N/A |
diff --git a/SECURITY.md b/SECURITY.md
index d08589f9d82..57d453670fd 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,73 +1,13 @@
-# Security Policy
-
-1. [Reporting security problems](#reporting)
-1. [Security Bug Bounties](#bounty)
-1. [Scope](#scope)
-1. [Incident Response Process](#process)
-
-<a name="reporting"></a>
-## Reporting security problems in the Solana Program Library
-
-**DO NOT CREATE A GITHUB ISSUE** to report a security problem.
-
-Instead please use this [Report a Vulnerability](https://github.com/solana-labs/solana-program-library/security/advisories/new) link.
-Provide a helpful title and detailed description of the problem.
-
-If you haven't done so already, please **enable two-factor auth** in your GitHub account.
-
-Expect a response as fast as possible in the advisory, typically within 72 hours.
-
---
-
-If you do not receive a response in the advisory, send an email to
-security@solana.com with the full URL of the advisory you have created.  DO NOT
-include attachments or provide detail sufficient for exploitation regarding the
-security issue in this email. **Only provide such details in the advisory**.
-
-If you do not receive a response from security@solana.com please followup with
-the team directly. You can do this in the `#core-technology` channel of the
-[Solana Tech discord server](https://solana.com/discord), by pinging the admins
-in the channel and referencing the fact that you submitted a security problem.
-
-
-
-<a name="bounty"></a>
-## Security Bug Bounties
-The Solana Foundation offer bounties for critical Solana security issues. Please
-see the [Solana Security Bug
-Bounties](https://github.com/solana-labs/solana/security/policy#security-bug-bounties)
-for details on classes of bugs and payment amounts.
-
-<a name="scope"></a>
-## Scope
-
-Only a subset of programs within the Solana Program Library repo are deployed to
-the Solana Mainnet Beta. Currently, this includes:
-
-* [associated-token-account](https://github.com/solana-labs/solana-program-library/tree/master/associated-token-account/program)
-* [feature-proposal](https://github.com/solana-labs/solana-program-library/tree/master/feature-proposal/program)
-* [governance](https://github.com/solana-labs/solana-program-library/tree/master/governance/program)
-* [memo](https://github.com/solana-labs/solana-program-library/tree/master/memo/program)
-* [name-service](https://github.com/solana-labs/solana-program-library/tree/master/name-service/program)
-* [stake-pool](https://github.com/solana-labs/solana-program-library/tree/master/stake-pool/program)
-* [token](https://github.com/solana-labs/solana-program-library/tree/master/token/program)
-* [token-2022](https://github.com/solana-labs/solana-program-library/tree/master/token/program-2022)
-
-If you discover a critical security issue in an out-of-scope program, your finding
-may still be valuable.
-
-Many programs, including
-[token-swap](https://github.com/solana-labs/solana-program-library/tree/master/token-swap/program)
-and [token-lending](https://github.com/solana-labs/solana-program-library/tree/master/token-lending/program),
-have been forked and deployed by prominent ecosystem projects, many of which
-have their own bug bounty programs.
-
-While we cannot guarantee a bounty from another entity, we can help determine who
-may be affected and put you in touch with the corresponding teams.
-
-<a name="process"></a>
-## Incident Response Process
-
-In case an incident is discovered or reported, the
-[Solana Security Incident Response Process](https://github.com/solana-labs/solana/security/policy#incident-response-process)
-will be followed to contain, respond and remediate.
+## This repo will be archived soon
+Active development in this repo is ending 2024-03-02. Anza is continuing development
+in program-specific repos under the
+[solana-program organization](https://github.com/solana-program). Please refer to 
+the security policy in individual repos:
+
+* [associated-token-account](https://github.com/solana-program/associated-token-account/security)
+* [feature-proposal](https://github.com/solana-program/feature-proposal/security)
+* [memo](https://github.com/solana-program/memo/security)
+* [single-pool](https://github.com/solana-program/single-pool/security)
+* [stake-pool](https://github.com/solana-program/stake-pool/security)
+* [token](https://github.com/solana-program/token/security)
+* [token-2022](https://github.com/solana-program/token-2022/security)
diff --git a/account-compression/Cargo.lock b/account-compression/Cargo.lock
index 592543ceb10..7e147646d36 100644
--- a/account-compression/Cargo.lock
+++ b/account-compression/Cargo.lock
@@ -145,6 +145,7 @@ dependencies = [
  "anchor-derive-accounts",
  "anchor-derive-serde",
  "anchor-derive-space",
+ "anchor-syn",
  "arrayref",
  "base64 0.13.0",
  "bincode",
@@ -463,7 +464,7 @@ dependencies = [
  "proc-macro-crate 3.1.0",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
  "syn_derive",
 ]
 
@@ -544,9 +545,9 @@ dependencies = [
 
 [[package]]
 name = "bytemuck"
-version = "1.14.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6"
+checksum = "8334215b81e418a0a7bdb8ef0849474f40bb10c8b71f1c4ed315cff49f32494d"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -1067,7 +1068,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1198,9 +1199,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.78"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
  "unicode-ident",
 ]
@@ -1392,7 +1393,7 @@ checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1458,9 +1459,9 @@ checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
 
 [[package]]
 name = "solana-frozen-abi"
-version = "1.18.2"
+version = "1.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f97bbed79e7fd14e1c48411ce217f305972e7151f14b3124f3956fc13aac76b"
+checksum = "4867f66e9527fa44451c861c1dc6d9b2a7c7a668d7c6a297cdefbe39f4395b33"
 dependencies = [
  "block-buffer 0.10.4",
  "bs58 0.4.0",
@@ -1483,21 +1484,21 @@ dependencies = [
 
 [[package]]
 name = "solana-frozen-abi-macro"
-version = "1.18.2"
+version = "1.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22b989fb872d2ba530ecb6e504284e3e1244eeb7541056c40fe2d87c7d0bb9d1"
+checksum = "168f24d97347b85f05192df58d6be3e3047a4aadc4001bc1b9e711a5ec878eea"
 dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "solana-program"
-version = "1.18.2"
+version = "1.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b5d8a2694dc792ee9ae4af09cf8995e21cc9366846001e8ee1e6f060a837518"
+checksum = "2bc5a636dc75e5c25651e34f7a36afc9ae60d38166687c5b0375abb580ac81a2"
 dependencies = [
  "ark-bn254",
  "ark-ec",
@@ -1550,20 +1551,20 @@ dependencies = [
 
 [[package]]
 name = "solana-sdk-macro"
-version = "1.18.2"
+version = "1.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2395961f455e2b2ec9b64d945e3e9db760ccce10716f40a3e947a1e399c7511e"
+checksum = "86c76414183a325038ff020b22c07d1e9d2da0703ddc0244acfed37ee2921d96"
 dependencies = [
  "bs58 0.4.0",
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "spl-account-compression"
-version = "0.3.0"
+version = "0.4.2"
 dependencies = [
  "anchor-lang",
  "bytemuck",
@@ -1574,7 +1575,7 @@ dependencies = [
 
 [[package]]
 name = "spl-concurrent-merkle-tree"
-version = "0.2.0"
+version = "0.4.0"
 dependencies = [
  "bytemuck",
  "solana-program",
@@ -1607,9 +1608,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.48"
+version = "2.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1625,27 +1626,27 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.57"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
+checksum = "3b3c6efbfc763e64eb85c11c25320f0737cb7364c4b6336db90aa9ebe27a0bbd"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.57"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
+checksum = "b607164372e89797d78b8e23a6d67d5d1038c1c65efd52e1389ef8b77caba2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1774,7 +1775,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
  "wasm-bindgen-shared",
 ]
 
@@ -1796,7 +1797,7 @@ checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -1886,7 +1887,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1906,5 +1907,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.48",
+ "syn 2.0.87",
 ]
diff --git a/account-compression/programs/account-compression/Cargo.toml b/account-compression/programs/account-compression/Cargo.toml
index 7639068adc1..75895cb151c 100644
--- a/account-compression/programs/account-compression/Cargo.toml
+++ b/account-compression/programs/account-compression/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "spl-account-compression"
-version = "0.3.0"
+version = "0.4.2"
 description = "Solana Program Library Account Compression Program"
 authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
 repository = "https://github.com/solana-labs/solana-program-library"
@@ -16,14 +16,13 @@ no-idl = []
 no-log-ix-name = []
 cpi = ["no-entrypoint"]
 default = []
+idl-build = ["anchor-lang/idl-build"]
 
 [dependencies]
-anchor-lang = "0.29.0"
+anchor-lang = { version = "0.29.0" }
 bytemuck = "1.13"
 solana-program = ">=1.18.11,<=2"
-spl-concurrent-merkle-tree = { version = "0.2.0", path = "../../../libraries/concurrent-merkle-tree", features = [
-  "sol-log",
-] }
+spl-concurrent-merkle-tree = { version = "0.4.0", path = "../../../libraries/concurrent-merkle-tree" }
 spl-noop = { version = "0.2.0", path = "../noop", features = ["no-entrypoint"] }
 
 [profile.release]
diff --git a/account-compression/programs/account-compression/README.md b/account-compression/programs/account-compression/README.md
index e57de7a10c6..e720cc57b9d 100644
--- a/account-compression/programs/account-compression/README.md
+++ b/account-compression/programs/account-compression/README.md
@@ -4,10 +4,8 @@
   </a>
 </p>
 
-# SPL Account Compression Rust SDK (Beta)
+# SPL Account Compression Rust SDK
 
 More information about account compression can be found in [the solana-program-library repo](https://github.com/solana-labs/solana-program-library/tree/master/account-compression).
 
-The [Solana Program Examples repo](https://github.com/solana-developers/program-examples) will eventually include examples of how to use this program.
-
-`spl-account-compression` and this crate's implementation are targeted towards supporting [Metaplex Compressed NFTs](https://github.com/metaplex-foundation/metaplex-program-library/tree/master/bubblegum) and may be subject to change.
\ No newline at end of file
+`spl-account-compression` and this crate's implementation are targeted towards supporting [Metaplex Compressed NFTs](https://github.com/metaplex-foundation/mpl-bubblegum) and may be subject to change.
\ No newline at end of file
diff --git a/account-compression/programs/account-compression/src/canopy.rs b/account-compression/programs/account-compression/src/canopy.rs
index bdf85d7d5d0..284b2fbbe73 100644
--- a/account-compression/programs/account-compression/src/canopy.rs
+++ b/account-compression/programs/account-compression/src/canopy.rs
@@ -20,9 +20,13 @@ use crate::error::AccountCompressionError;
 use crate::events::ChangeLogEvent;
 use anchor_lang::prelude::*;
 use bytemuck::{cast_slice, cast_slice_mut};
-use spl_concurrent_merkle_tree::node::{empty_node_cached, Node, EMPTY};
+use solana_program::keccak::hashv;
+use spl_concurrent_merkle_tree::node::{empty_node_cached, empty_node_cached_mut, Node, EMPTY};
 use std::mem::size_of;
 
+/// Maximum depth of the tree, supported by the SPL Compression
+const MAX_SUPPORTED_DEPTH: usize = 30;
+
 #[inline(always)]
 pub fn check_canopy_bytes(canopy_bytes: &[u8]) -> Result<()> {
     if canopy_bytes.len() % size_of::<Node>() != 0 {
@@ -94,8 +98,7 @@ pub fn fill_in_proof_from_canopy(
     index: u32,
     proof: &mut Vec<Node>,
 ) -> Result<()> {
-    // 30 is hard coded as it is the current max depth that SPL Compression supports
-    let mut empty_node_cache = Box::new([EMPTY; 30]);
+    let mut empty_node_cache = Box::new([EMPTY; MAX_SUPPORTED_DEPTH]);
     check_canopy_bytes(canopy_bytes)?;
     let canopy = cast_slice::<u8, Node>(canopy_bytes);
     let path_len = get_cached_path_length(canopy, max_depth)?;
@@ -114,7 +117,7 @@ pub fn fill_in_proof_from_canopy(
         };
         if canopy[cached_idx] == EMPTY {
             let level = max_depth - (31 - node_idx.leading_zeros());
-            let empty_node = empty_node_cached::<30>(level, &mut empty_node_cache);
+            let empty_node = empty_node_cached::<MAX_SUPPORTED_DEPTH>(level, &mut empty_node_cache);
             inferred_nodes.push(empty_node);
         } else {
             inferred_nodes.push(canopy[cached_idx]);
@@ -128,3 +131,431 @@ pub fn fill_in_proof_from_canopy(
     proof.extend(inferred_nodes.iter().skip(overlap));
     Ok(())
 }
+
+/// Sets the leaf nodes of the canopy. The leaf nodes are the lowest level of the canopy,
+/// representing the leaves of the canopy-tree. The method will update the parent nodes of all the
+/// modified subtrees up to the uppermost level of the canopy. The leaf nodes indexing for the
+/// start_index is 0-based without regards to the full tree indexes or the node indexes. The
+/// start_index is the index of the first leaf node to be updated.
+pub fn set_canopy_leaf_nodes(
+    canopy_bytes: &mut [u8],
+    max_depth: u32,
+    start_index: u32,
+    nodes: &[Node],
+) -> Result<()> {
+    check_canopy_bytes(canopy_bytes)?;
+    let canopy = cast_slice_mut::<u8, Node>(canopy_bytes);
+    let path_len = get_cached_path_length(canopy, max_depth)?;
+    if path_len == 0 {
+        return err!(AccountCompressionError::CanopyNotAllocated);
+    }
+    let start_canopy_node = leaf_node_index_to_canopy_index(path_len, start_index)?;
+    let start_canopy_idx = start_canopy_node - 2;
+    // set the "leaf" nodes of the canopy first - that's the lowest level of the canopy
+    for (i, node) in nodes.iter().enumerate() {
+        canopy[start_canopy_idx + i] = *node;
+    }
+    let mut start_canopy_node = start_canopy_node;
+    let mut end_canopy_node = start_canopy_node + nodes.len() - 1;
+    let mut empty_node_cache = Box::new([EMPTY; MAX_SUPPORTED_DEPTH]);
+    let leaf_node_level = max_depth - path_len;
+    // traverse up the tree and update the parent nodes in the modified subtree
+    for level in leaf_node_level + 1..max_depth {
+        start_canopy_node >>= 1;
+        end_canopy_node >>= 1;
+        for node in start_canopy_node..end_canopy_node + 1 {
+            let left_child = get_value_for_node::<MAX_SUPPORTED_DEPTH>(
+                node << 1,
+                level - 1,
+                canopy,
+                &mut empty_node_cache,
+            );
+            let right_child = get_value_for_node::<MAX_SUPPORTED_DEPTH>(
+                (node << 1) + 1,
+                level - 1,
+                canopy,
+                &mut empty_node_cache,
+            );
+            canopy[node - 2].copy_from_slice(hashv(&[&left_child, &right_child]).as_ref());
+        }
+    }
+    Ok(())
+}
+
+/// Checks the root of the canopy against the expected root.
+pub fn check_canopy_root(canopy_bytes: &[u8], expected_root: &Node, max_depth: u32) -> Result<()> {
+    check_canopy_bytes(canopy_bytes)?;
+    let canopy = cast_slice::<u8, Node>(canopy_bytes);
+    if canopy.is_empty() {
+        return Ok(()); // Canopy is empty
+    }
+    let mut empty_node_cache = Box::new([EMPTY; MAX_SUPPORTED_DEPTH]);
+    // first two nodes are the children of the root, they have index 2 and 3 respectively
+    let left_root_child =
+        get_value_for_node::<MAX_SUPPORTED_DEPTH>(2, max_depth - 1, canopy, &mut empty_node_cache);
+    let right_root_child =
+        get_value_for_node::<MAX_SUPPORTED_DEPTH>(3, max_depth - 1, canopy, &mut empty_node_cache);
+    let actual_root = hashv(&[&left_root_child, &right_root_child]).to_bytes();
+    if actual_root != *expected_root {
+        msg!(
+            "Canopy root mismatch. Expected: {:?}, Actual: {:?}",
+            expected_root,
+            actual_root
+        );
+        err!(AccountCompressionError::CanopyRootMismatch)
+    } else {
+        Ok(())
+    }
+}
+
+/// Checks the canopy doesn't have any nodes to the right of the provided index in the full tree.
+/// This is done by iterating through the canopy nodes to the right of the provided index and
+/// finding the top-most node that has the node as its left child. The node should be empty. The
+/// iteration contains following the previous checked node on the same level until the last node on
+/// the level is reached.
+pub fn check_canopy_no_nodes_to_right_of_index(
+    canopy_bytes: &[u8],
+    max_depth: u32,
+    index: u32,
+) -> Result<()> {
+    check_canopy_bytes(canopy_bytes)?;
+    check_index(index, max_depth)?;
+    let canopy = cast_slice::<u8, Node>(canopy_bytes);
+    let path_len = get_cached_path_length(canopy, max_depth)?;
+
+    let mut node_idx = ((1 << max_depth) + index) >> (max_depth - path_len);
+    // no need to check the node_idx as it's the leaf continaing the index underneath it
+    while node_idx & (node_idx + 1) != 0 {
+        // check the next node to the right
+        node_idx += 1;
+        // find the top-most node that has the node as its left-most child
+        node_idx >>= node_idx.trailing_zeros();
+
+        let shifted_index = node_idx as usize - 2;
+        if canopy[shifted_index] != EMPTY {
+            msg!("Canopy node at index {} is not empty", shifted_index);
+            return err!(AccountCompressionError::CanopyRightmostLeafMismatch);
+        }
+    }
+    Ok(())
+}
+
+#[inline(always)]
+fn check_index(index: u32, at_depth: u32) -> Result<()> {
+    if at_depth > MAX_SUPPORTED_DEPTH as u32 {
+        return err!(AccountCompressionError::ConcurrentMerkleTreeConstantsError);
+    }
+    if at_depth == 0 {
+        return err!(AccountCompressionError::ConcurrentMerkleTreeConstantsError);
+    }
+    if index >= (1 << at_depth) {
+        return err!(AccountCompressionError::LeafIndexOutOfBounds);
+    }
+    Ok(())
+}
+
+#[inline(always)]
+fn get_value_for_node<const N: usize>(
+    node_idx: usize,
+    level: u32,
+    canopy: &[Node],
+    empty_node_cache: &mut [Node; N],
+) -> Node {
+    if canopy[node_idx - 2] != EMPTY {
+        return canopy[node_idx - 2];
+    }
+    empty_node_cached_mut::<N>(level, empty_node_cache)
+}
+
+#[inline(always)]
+fn leaf_node_index_to_canopy_index(path_len: u32, index: u32) -> Result<usize> {
+    check_index(index, path_len)?;
+    Ok((1 << path_len) + index as usize)
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, spl_concurrent_merkle_tree::node::empty_node};
+
+    fn success_leaf_node_index_to_canopy_index(path_len: u32, index: u32, expected: usize) {
+        assert_eq!(
+            leaf_node_index_to_canopy_index(path_len, index).unwrap(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_zero_length_tree() {
+        assert_eq!(
+            leaf_node_index_to_canopy_index(0, 0).unwrap_err(),
+            AccountCompressionError::ConcurrentMerkleTreeConstantsError.into()
+        );
+    }
+
+    #[test]
+    fn test_1_level_0_index() {
+        success_leaf_node_index_to_canopy_index(1, 0, 2);
+    }
+
+    #[test]
+    fn test_1_level_1_index() {
+        success_leaf_node_index_to_canopy_index(1, 1, 3);
+    }
+
+    #[test]
+    fn test_2_level_0_index() {
+        success_leaf_node_index_to_canopy_index(2, 0, 4);
+    }
+    #[test]
+    fn test_2_level_3_index() {
+        success_leaf_node_index_to_canopy_index(2, 3, 7);
+    }
+
+    #[test]
+    fn test_10_level_0_index() {
+        success_leaf_node_index_to_canopy_index(10, 0, 1024);
+    }
+
+    #[test]
+    fn test_10_level_1023_index() {
+        success_leaf_node_index_to_canopy_index(10, 1023, 2047);
+    }
+
+    #[test]
+    fn test_simple_single_level_canopy_set_canopy_leaf_nodes_with_empty_nodes() {
+        let mut canopy_bytes = vec![0_u8; 2 * size_of::<Node>()];
+        let nodes = vec![EMPTY; 2];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 1, 0, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        assert_eq!(canopy[0], EMPTY);
+        assert_eq!(canopy[1], EMPTY);
+    }
+
+    #[test]
+    fn test_simple_single_level_canopy_set_canopy_leaf_nodes_non_empty_nodes() {
+        let mut canopy_bytes = vec![0_u8; 2 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 1, 0, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        assert_eq!(canopy[0], [1_u8; 32]);
+        assert_eq!(canopy[1], [2_u8; 32]);
+    }
+
+    #[test]
+    fn test_2levels_canopy_set_canopy_leaf_nodes_first_2_elements_provided() {
+        let mut canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 2, 0, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        assert_eq!(canopy[0], hashv(&[&[1_u8; 32], &[2_u8; 32]]).to_bytes());
+        assert_eq!(canopy[1], EMPTY); // is not updated
+        assert_eq!(canopy[2], [1_u8; 32]);
+        assert_eq!(canopy[3], [2_u8; 32]);
+        assert_eq!(canopy[4], EMPTY);
+        assert_eq!(canopy[5], EMPTY);
+    }
+
+    #[test]
+    fn test_2levels_canopy_set_canopy_leaf_nodes_last_2_elements_provided() {
+        let mut canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 2, 2, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        assert_eq!(canopy[0], EMPTY); // is not updated
+        assert_eq!(canopy[1], hashv(&[&[1_u8; 32], &[2_u8; 32]]).to_bytes());
+        assert_eq!(canopy[2], EMPTY);
+        assert_eq!(canopy[3], EMPTY);
+        assert_eq!(canopy[4], [1_u8; 32]);
+        assert_eq!(canopy[5], [2_u8; 32]);
+    }
+
+    #[test]
+    fn test_2levels_canopy_set_canopy_leaf_nodes_middle_2_elements_provided() {
+        let mut canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 2, 1, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        assert_eq!(canopy[2], EMPTY);
+        assert_eq!(canopy[3], [1_u8; 32]);
+        assert_eq!(canopy[4], [2_u8; 32]);
+        assert_eq!(canopy[5], EMPTY);
+        assert_eq!(canopy[0], hashv(&[&EMPTY, &[1_u8; 32]]).to_bytes());
+        assert_eq!(canopy[1], hashv(&[&[2_u8; 32], &EMPTY]).to_bytes());
+    }
+
+    #[test]
+    fn test_3level_canopy_in_10_level_tree_set_canopy_leaf_nodes_first_2_elements_provided() {
+        let mut canopy_bytes = vec![0_u8; 14 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 10, 0, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        let expected_hash12 = hashv(&[&[1_u8; 32], &[2_u8; 32]]).to_bytes();
+        assert_eq!(
+            canopy[0],
+            hashv(&[&expected_hash12, &empty_node(8)]).to_bytes()
+        );
+        assert_eq!(canopy[1], EMPTY); // is not updated
+        assert_eq!(canopy[2], expected_hash12);
+        assert_eq!(canopy[3], EMPTY); // is not updated
+        assert_eq!(canopy[4], EMPTY); // is not updated
+        assert_eq!(canopy[5], EMPTY); // is not updated
+        assert_eq!(canopy[6], [1_u8; 32]);
+        assert_eq!(canopy[7], [2_u8; 32]);
+    }
+
+    #[test]
+    fn test_3level_canopy_in_10_level_tree_set_canopy_leaf_nodes_middle_2_elements_provided() {
+        let mut canopy_bytes = vec![0_u8; 14 * size_of::<Node>()];
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 10, 3, &nodes).unwrap();
+        let canopy = cast_slice::<u8, Node>(&canopy_bytes);
+
+        let expected_hash_empty_1 = hashv(&[&empty_node(7), &[1_u8; 32]]).to_bytes();
+        let expected_hash_2_empty = hashv(&[&[2_u8; 32], &empty_node(7)]).to_bytes();
+
+        assert_eq!(
+            canopy[0],
+            hashv(&[&empty_node(8), &expected_hash_empty_1]).to_bytes()
+        );
+        assert_eq!(
+            canopy[1],
+            hashv(&[&expected_hash_2_empty, &empty_node(8)]).to_bytes()
+        );
+        assert_eq!(canopy[2], EMPTY); // is not updated
+        assert_eq!(canopy[3], expected_hash_empty_1);
+        assert_eq!(canopy[4], expected_hash_2_empty);
+        assert_eq!(canopy[5], EMPTY); // is not updated
+        assert_eq!(canopy[9], [1_u8; 32]);
+        assert_eq!(canopy[10], [2_u8; 32]);
+    }
+
+    #[test]
+    fn test_3level_canopy_empty_set_canopy_leaf_nodes_no_impact() {
+        let mut canopy_bytes = vec![0_u8; 14 * size_of::<Node>()];
+        let nodes = vec![];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 10, 0, &nodes).unwrap();
+        assert_eq!(canopy_bytes, vec![0_u8; 14 * size_of::<Node>()]);
+    }
+
+    #[test]
+    fn test_success_check_canopy_root() {
+        let mut canopy_bytes = vec![0_u8; 2 * size_of::<Node>()];
+        let expected_root = hashv(&[&[1_u8; 32], &[2_u8; 32]]).to_bytes();
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 1, 0, &nodes).unwrap();
+        check_canopy_root(&canopy_bytes, &expected_root, 30).unwrap();
+    }
+
+    #[test]
+    fn test_success_check_canopy_root_with_empty_right_branch() {
+        let mut canopy_bytes = vec![0_u8; 2 * size_of::<Node>()];
+        let mut empty_node_cache = Box::new([EMPTY; MAX_SUPPORTED_DEPTH]);
+        let top_level = (MAX_SUPPORTED_DEPTH - 1) as u32;
+        let right_branch =
+            empty_node_cached_mut::<MAX_SUPPORTED_DEPTH>(top_level, &mut empty_node_cache);
+        let expected_root = hashv(&[&[1_u8; 32], &right_branch]).to_bytes();
+        let nodes = vec![[1_u8; 32], EMPTY];
+        set_canopy_leaf_nodes(&mut canopy_bytes, MAX_SUPPORTED_DEPTH as u32, 0, &nodes).unwrap();
+        check_canopy_root(&canopy_bytes, &expected_root, 30).unwrap();
+    }
+
+    #[test]
+    fn test_failure_check_canopy_root() {
+        let mut canopy_bytes = vec![0_u8; 2 * size_of::<Node>()];
+        let expected_root = hashv(&[&[1_u8; 32], &[2_u8; 32]]).to_bytes();
+        let nodes = vec![[1_u8; 32], [2_u8; 32]];
+        set_canopy_leaf_nodes(&mut canopy_bytes, 1, 0, &nodes).unwrap();
+        let mut expected_root = expected_root;
+        expected_root[0] = 0;
+        assert_eq!(
+            check_canopy_root(&canopy_bytes, &expected_root, 30).unwrap_err(),
+            AccountCompressionError::CanopyRootMismatch.into()
+        );
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_empty_tree_first_index() {
+        let canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, 0).unwrap();
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_empty_tree_last_index() {
+        let canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, (1 << 20) - 1).unwrap();
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_empty_canopy_only_tree_first_index() {
+        let canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 2, 0).unwrap();
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_empty_canopy_only_tree_last_index() {
+        let canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 2, (1 << 2) - 1).unwrap();
+    }
+
+    #[test]
+    fn test_failure_check_canopy_no_nodes_to_right_of_index_empty_tree_index_out_of_range() {
+        let canopy_bytes = vec![0_u8; 6 * size_of::<Node>()];
+        assert_eq!(
+            check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 2, 1 << 20).unwrap_err(),
+            AccountCompressionError::LeafIndexOutOfBounds.into()
+        );
+    }
+
+    #[test]
+    fn test_failure_check_canopy_no_nodes_to_right_of_index_full_tree_index_out_of_range() {
+        let canopy_bytes = vec![1_u8; 6 * size_of::<Node>()];
+        assert_eq!(
+            check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 2, 1 << 21).unwrap_err(),
+            AccountCompressionError::LeafIndexOutOfBounds.into()
+        );
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_full_tree_last_index() {
+        let canopy_bytes = vec![1_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, (1 << 20) - 1).unwrap();
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_full_tree_first_child_of_last_canopy_node_leaf(
+    ) {
+        let canopy_bytes = vec![1_u8; 6 * size_of::<Node>()];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, 3 << (20 - 2)).unwrap();
+    }
+
+    #[test]
+    fn test_failure_check_canopy_no_nodes_to_right_of_index_full_tree_last_child_of_second_to_last_canopy_node_leaf(
+    ) {
+        let canopy_bytes = vec![1_u8; 6 * size_of::<Node>()];
+        assert_eq!(
+            check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, (3 << (20 - 2)) - 1)
+                .unwrap_err(),
+            AccountCompressionError::CanopyRightmostLeafMismatch.into()
+        );
+    }
+
+    #[test]
+    fn test_success_check_canopy_no_nodes_to_right_of_index_last_child_of_second_to_last_canopy_node_leaf(
+    ) {
+        let mut canopy_bytes = vec![1_u8; 6 * size_of::<Node>()];
+        canopy_bytes[5 * size_of::<Node>()..].fill(0);
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, (3 << (20 - 2)) - 1).unwrap();
+    }
+
+    #[test]
+    fn test_succes_check_canopy_no_nodes_to_right_of_index_no_canopy() {
+        let canopy_bytes = vec![];
+        check_canopy_no_nodes_to_right_of_index(&canopy_bytes, 20, 0).unwrap();
+    }
+}
diff --git a/account-compression/programs/account-compression/src/concurrent_tree_wrapper.rs b/account-compression/programs/account-compression/src/concurrent_tree_wrapper.rs
new file mode 100644
index 00000000000..e954fea5c57
--- /dev/null
+++ b/account-compression/programs/account-compression/src/concurrent_tree_wrapper.rs
@@ -0,0 +1,115 @@
+//! This module provides a wrapper around the `ConcurrentMerkleTree` struct from
+//! the `spl_concurrent_merkle_tree` crate. It provides a set of functions that
+//! can be called from the Anchor program to interact with the tree.
+//! The functions are used to initialize the tree, set a leaf, fill empty or
+//! append a leaf, and prove a leaf. As the tree is generic over the depth and
+//! buffer size, the functions are implemented using macros that infer the depth
+//! and buffer size from the header information stored on-chain. Usage of the
+//! macros directly is discouraged, as they have huge match statements with
+//! every case taking it's own stack frame. Instead, use the exported functions
+//! from this module and refenrece or Box the arguments to the functions to
+//! avoid the stack frame explosion.
+
+pub use crate::error::AccountCompressionError;
+/// Exported for Anchor / Solita
+pub use spl_concurrent_merkle_tree::{
+    concurrent_merkle_tree::{
+        ConcurrentMerkleTree, FillEmptyOrAppendArgs, InitializeWithRootArgs, ProveLeafArgs,
+        SetLeafArgs,
+    },
+    error::ConcurrentMerkleTreeError,
+    node::Node,
+    node::EMPTY,
+};
+use {
+    crate::{
+        events::ChangeLogEvent, macros::*, state::ConcurrentMerkleTreeHeader, zero_copy::ZeroCopy,
+    },
+    anchor_lang::prelude::*,
+};
+
+#[inline(never)]
+pub fn merkle_tree_initialize_empty(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, initialize,)
+}
+
+#[inline(never)]
+pub fn merkle_tree_initialize_with_root(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+    args: &InitializeWithRootArgs,
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, initialize_with_root, args)
+}
+
+#[inline(never)]
+pub fn merkle_tree_set_leaf(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+    args: &SetLeafArgs,
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, set_leaf, args)
+}
+
+#[inline(never)]
+pub fn merkle_tree_fill_empty_or_append(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+    args: &FillEmptyOrAppendArgs,
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, fill_empty_or_append, args)
+}
+
+#[inline(never)]
+pub fn merkle_tree_prove_leaf(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &[u8],
+    args: &ProveLeafArgs,
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn!(header, tree_id, tree_bytes, prove_leaf, args)
+}
+
+#[inline(never)]
+pub fn merkle_tree_append_leaf(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+    args: &[u8; 32],
+) -> Result<Box<ChangeLogEvent>> {
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, append, *args)
+}
+
+/// Checks whether the tree in not initialized yet without doing the deserialization. A rought
+/// equivalent to deserializing the tree and calling is_initialized() on it without the heavy
+/// lifting with macros. An empty account is a zero'd account. The tree is considered empty if the
+/// tree_bytes are all 0. A regular non-batch initialized tree is initialized early on when the
+/// init_empty_merkle_tree is called. A batch initialized tree stays uninitialized until the
+/// init_prepared_tree_with_root is called.
+pub fn tree_bytes_uninitialized(tree_bytes: &[u8]) -> bool {
+    tree_bytes.iter().all(|&x| x == 0)
+}
+
+#[inline(never)]
+pub fn assert_tree_is_empty(
+    header: &ConcurrentMerkleTreeHeader,
+    tree_id: Pubkey,
+    tree_bytes: &mut [u8],
+) -> Result<()> {
+    // If the tree is batch initialized and not finalized yet, we can treat it as empty.
+    // Before the tree is finalized, the tree_bytes will be all 0 as only the header will be
+    // initialized at that point, so we may skip the deserialization.
+    if header.get_is_batch_initialized() && tree_bytes_uninitialized(tree_bytes) {
+        return Ok(());
+    }
+    // check the tree is empty
+    merkle_tree_apply_fn_mut!(header, tree_id, tree_bytes, prove_tree_is_empty,)?;
+    Ok(())
+}
diff --git a/account-compression/programs/account-compression/src/error.rs b/account-compression/programs/account-compression/src/error.rs
index fc7efdb215a..ef682300ebc 100644
--- a/account-compression/programs/account-compression/src/error.rs
+++ b/account-compression/programs/account-compression/src/error.rs
@@ -47,6 +47,26 @@ pub enum AccountCompressionError {
     /// is out of bounds of tree's maximum leaf capacity
     #[msg("Leaf index of concurrent merkle tree is out of bounds")]
     LeafIndexOutOfBounds,
+
+    /// When initializing a canopy of the tree, the underlying tree was allocated without space for the canopy
+    #[msg("Tree was initialized without allocating space for the canopy")]
+    CanopyNotAllocated,
+
+    /// The tree was already initialized
+    #[msg("Tree was already initialized")]
+    TreeAlreadyInitialized,
+
+    /// The tree header was not initialized for batch processing
+    #[msg("Tree header was not initialized for batch processing")]
+    BatchNotInitialized,
+
+    /// The canopy root doesn't match the root of the tree
+    #[msg("Canopy root does not match the root of the tree")]
+    CanopyRootMismatch,
+
+    /// The canopy contains nodes to the right of the rightmost leaf of the tree
+    #[msg("Canopy contains nodes to the right of the rightmost leaf of the tree")]
+    CanopyRightmostLeafMismatch,
 }
 
 impl From<&ConcurrentMerkleTreeError> for AccountCompressionError {
diff --git a/account-compression/programs/account-compression/src/lib.rs b/account-compression/programs/account-compression/src/lib.rs
index d3308d5f313..93d8411b3c4 100644
--- a/account-compression/programs/account-compression/src/lib.rs
+++ b/account-compression/programs/account-compression/src/lib.rs
@@ -29,6 +29,7 @@ use anchor_lang::{
 use borsh::{BorshDeserialize, BorshSerialize};
 
 pub mod canopy;
+pub mod concurrent_tree_wrapper;
 pub mod error;
 pub mod events;
 #[macro_use]
@@ -39,18 +40,24 @@ pub mod zero_copy;
 
 pub use crate::noop::{wrap_application_data_v1, Noop};
 
-use crate::canopy::{fill_in_proof_from_canopy, update_canopy};
+use crate::canopy::{
+    check_canopy_bytes, check_canopy_no_nodes_to_right_of_index, check_canopy_root,
+    fill_in_proof_from_canopy, set_canopy_leaf_nodes, update_canopy,
+};
+use crate::concurrent_tree_wrapper::*;
 pub use crate::error::AccountCompressionError;
 pub use crate::events::{AccountCompressionEvent, ChangeLogEvent};
 use crate::noop::wrap_event;
 use crate::state::{
     merkle_tree_get_size, ConcurrentMerkleTreeHeader, CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1,
 };
-use crate::zero_copy::ZeroCopy;
 
 /// Exported for Anchor / Solita
 pub use spl_concurrent_merkle_tree::{
-    concurrent_merkle_tree::ConcurrentMerkleTree, error::ConcurrentMerkleTreeError, node::Node,
+    concurrent_merkle_tree::{ConcurrentMerkleTree, FillEmptyOrAppendArgs},
+    error::ConcurrentMerkleTreeError,
+    node::Node,
+    node::EMPTY,
 };
 
 declare_id!("cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK");
@@ -70,7 +77,8 @@ pub struct Initialize<'info> {
     pub noop: Program<'info, Noop>,
 }
 
-/// Context for inserting, appending, or replacing a leaf in the tree
+/// Context for modifying a tree: inserting, appending, or replacing a leaf in
+/// the existing tree and setting the canopy or finalizing a prepared tree.
 ///
 /// Modification instructions also require the proof to the leaf to be provided
 /// as 32-byte nodes via "remaining accounts".
@@ -162,10 +170,13 @@ pub mod spl_account_compression {
             Clock::get()?.slot,
         );
         header.serialize(&mut header_bytes)?;
+
         let merkle_tree_size = merkle_tree_get_size(&header)?;
         let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
         let id = ctx.accounts.merkle_tree.key();
-        let change_log_event = merkle_tree_apply_fn_mut!(header, id, tree_bytes, initialize,)?;
+
+        let change_log_event = merkle_tree_initialize_empty(&header, id, tree_bytes)?;
+
         wrap_event(
             &AccountCompressionEvent::ChangeLog(*change_log_event),
             &ctx.accounts.noop,
@@ -173,69 +184,166 @@ pub mod spl_account_compression {
         update_canopy(canopy_bytes, header.get_max_depth(), None)
     }
 
-    /// Note:
-    /// Supporting this instruction open a security vulnerability for indexers.
-    /// This instruction has been deemed unusable for publicly indexed compressed NFTs.
-    /// Indexing batched data in this way requires indexers to read in the `uri`s onto physical storage
-    /// and then into their database. This opens up a DOS attack vector, whereby this instruction is
-    /// repeatedly invoked, causing indexers to fail.
-    ///
-    /// Because this instruction was deemed insecure, this instruction has been removed
-    /// until secure usage is available on-chain.
-    // pub fn init_merkle_tree_with_root(
-    //     ctx: Context<Initialize>,
-    //     max_depth: u32,
-    //     max_buffer_size: u32,
-    //     root: [u8; 32],
-    //     leaf: [u8; 32],
-    //     index: u32,
-    //     _changelog_db_uri: String,
-    //     _metadata_db_uri: String,
-    // ) -> Result<()> {
-    //     require_eq!(
-    //         *ctx.accounts.merkle_tree.owner,
-    //         crate::id(),
-    //         AccountCompressionError::IncorrectAccountOwner
-    //     );
-    //     let mut merkle_tree_bytes = ctx.accounts.merkle_tree.try_borrow_mut_data()?;
-
-    //     let (mut header_bytes, rest) =
-    //         merkle_tree_bytes.split_at_mut(CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1);
-
-    //     let mut header = ConcurrentMerkleTreeHeader::try_from_slice(&header_bytes)?;
-    //     header.initialize(
-    //         max_depth,
-    //         max_buffer_size,
-    //         &ctx.accounts.authority.key(),
-    //         Clock::get()?.slot,
-    //     );
-    //     header.serialize(&mut header_bytes)?;
-    //     let merkle_tree_size = merkle_tree_get_size(&header)?;
-    //     let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
-
-    //     // Get rightmost proof from accounts
-    //     let mut proof = vec![];
-    //     for node in ctx.remaining_accounts.iter() {
-    //         proof.push(node.key().to_bytes());
-    //     }
-    //     fill_in_proof_from_canopy(canopy_bytes, header.max_depth, index, &mut proof)?;
-    //     assert_eq!(proof.len(), max_depth as usize);
-
-    //     let id = ctx.accounts.merkle_tree.key();
-    //     // A call is made to ConcurrentMerkleTree::initialize_with_root(root, leaf, proof, index)
-    //     let change_log = merkle_tree_apply_fn!(
-    //         header,
-    //         id,
-    //         tree_bytes,
-    //         initialize_with_root,
-    //         root,
-    //         leaf,
-    //         &proof,
-    //         index
-    //     )?;
-    //     wrap_event(change_log.try_to_vec()?, &ctx.accounts.log_wrapper)?;
-    //     update_canopy(canopy_bytes, header.max_depth, Some(change_log))
-    // }
+    /// (Devnet only) In order to initialize a tree with a root, we need to create the tree on-chain first with
+    /// the proper authority. The tree might contain a canopy, which is a cache of the uppermost
+    /// nodes. The canopy is used to decrease the size of the proof required to update the tree.
+    /// If the tree is expected to have a canopy, it needs to be prefilled with the necessary nodes.
+    /// There are 2 ways to initialize a merkle tree:
+    /// 1. Initialize an empty tree
+    /// 2. Initialize a tree with a root and leaf
+    /// For the former case, the canopy will be empty which is expected for an empty tree. The
+    /// expected flow is `init_empty_merkle_tree`. For the latter case, the canopy should be
+    /// filled with the necessary nodes to render the tree usable. Thus we need to prefill the
+    /// canopy with the necessary nodes. The expected flow for a tree without canopy is
+    /// `prepare_batch_merkle_tree` -> `init_prepared_tree_with_root`. The expected flow for a tree
+    /// with canopy is `prepare_batch_merkle_tree` -> `append_canopy_nodes` (multiple times
+    /// until all of the canopy is filled) -> `init_prepared_tree_with_root`. This instruction
+    /// initializes the tree header while leaving the tree itself uninitialized. This allows
+    /// distinguishing between an empty tree and a tree prepare to be initialized with a root.
+    pub fn prepare_batch_merkle_tree(
+        ctx: Context<Initialize>,
+        max_depth: u32,
+        max_buffer_size: u32,
+    ) -> Result<()> {
+        require_eq!(
+            *ctx.accounts.merkle_tree.owner,
+            crate::id(),
+            AccountCompressionError::IncorrectAccountOwner
+        );
+        let mut merkle_tree_bytes = ctx.accounts.merkle_tree.try_borrow_mut_data()?;
+
+        let (mut header_bytes, rest) =
+            merkle_tree_bytes.split_at_mut(CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1);
+
+        let mut header = ConcurrentMerkleTreeHeader::try_from_slice(header_bytes)?;
+        header.initialize_batched(
+            max_depth,
+            max_buffer_size,
+            &ctx.accounts.authority.key(),
+            Clock::get()?.slot,
+        );
+        header.serialize(&mut header_bytes)?;
+        let merkle_tree_size = merkle_tree_get_size(&header)?;
+        let (_tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
+        check_canopy_bytes(canopy_bytes)
+    }
+
+    /// (Devnet only) This instruction pre-initializes the canopy with the specified leaf nodes of the canopy.
+    /// This is intended to be used after `prepare_batch_merkle_tree` and in conjunction with the
+    /// `init_prepared_tree_with_root` instruction that'll finalize the tree initialization.
+    /// The canopy is used to cache the uppermost nodes of the tree, which allows for a smaller
+    /// proof size when updating the tree. The canopy should be filled with the necessary nodes
+    /// before calling `init_prepared_tree_with_root`. You may call this instruction multiple
+    /// times to fill the canopy with the necessary nodes. The canopy may be filled with the
+    /// nodes in any order. The already filled nodes may be replaced with new nodes before calling
+    /// `init_prepared_tree_with_root` if the step was done in error.
+    /// The canopy should be filled with all the nodes that are to the left of the rightmost
+    /// leaf of the tree before calling `init_prepared_tree_with_root`. The canopy should not
+    /// contain any nodes to the right of the rightmost leaf of the tree.
+    /// This instruction calculates and filles in all the canopy nodes "above" the provided ones.
+    /// The validation of the canopy is done in the `init_prepared_tree_with_root` instruction.
+    pub fn append_canopy_nodes(
+        ctx: Context<Modify>,
+        start_index: u32,
+        canopy_nodes: Vec<[u8; 32]>,
+    ) -> Result<()> {
+        require_eq!(
+            *ctx.accounts.merkle_tree.owner,
+            crate::id(),
+            AccountCompressionError::IncorrectAccountOwner
+        );
+        let mut merkle_tree_bytes = ctx.accounts.merkle_tree.try_borrow_mut_data()?;
+
+        let (header_bytes, rest) =
+            merkle_tree_bytes.split_at_mut(CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1);
+
+        let header = ConcurrentMerkleTreeHeader::try_from_slice(header_bytes)?;
+        header.assert_valid_authority(&ctx.accounts.authority.key())?;
+        header.assert_is_batch_initialized()?;
+        // assert the tree is not initialized yet, we don't want to overwrite the canopy of an
+        // initialized tree
+        let merkle_tree_size = merkle_tree_get_size(&header)?;
+        let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
+        // ensure the tree is not initialized, the hacky way
+        require!(
+            tree_bytes_uninitialized(tree_bytes),
+            AccountCompressionError::TreeAlreadyInitialized
+        );
+        set_canopy_leaf_nodes(
+            canopy_bytes,
+            header.get_max_depth(),
+            start_index,
+            &canopy_nodes,
+        )
+    }
+
+    /// (Devnet only) Initializes a prepared tree with a root and a rightmost leaf. The rightmost leaf is used to
+    /// verify the canopy if the tree has it. Before calling this instruction, the tree should be
+    /// prepared with `prepare_batch_merkle_tree` and the canopy should be filled with the necessary
+    /// nodes with `append_canopy_nodes` (if the canopy is used). This method should be used for
+    /// batch creation of trees. The indexing of such batches should be done off-chain. The
+    /// programs calling this instruction should take care of ensuring the indexing is possible.
+    /// For example, staking may be required to ensure the tree creator has some responsibility
+    /// for what is being indexed. If indexing is not possible, there should be a mechanism to
+    /// penalize the tree creator.
+    pub fn init_prepared_tree_with_root(
+        ctx: Context<Modify>,
+        root: [u8; 32],
+        rightmost_leaf: [u8; 32],
+        rightmost_index: u32,
+    ) -> Result<()> {
+        require_eq!(
+            *ctx.accounts.merkle_tree.owner,
+            crate::id(),
+            AccountCompressionError::IncorrectAccountOwner
+        );
+        let mut merkle_tree_bytes = ctx.accounts.merkle_tree.try_borrow_mut_data()?;
+
+        let (header_bytes, rest) =
+            merkle_tree_bytes.split_at_mut(CONCURRENT_MERKLE_TREE_HEADER_SIZE_V1);
+        // the header should already be initialized with prepare_batch_merkle_tree
+        let header = ConcurrentMerkleTreeHeader::try_from_slice(header_bytes)?;
+        header.assert_valid_authority(&ctx.accounts.authority.key())?;
+        header.assert_is_batch_initialized()?;
+        let merkle_tree_size = merkle_tree_get_size(&header)?;
+        let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
+        // check the canopy root matches the tree root
+        check_canopy_root(canopy_bytes, &root, header.get_max_depth())?;
+        // verify the canopy does not conain any nodes to the right of the rightmost leaf
+        check_canopy_no_nodes_to_right_of_index(
+            canopy_bytes,
+            header.get_max_depth(),
+            rightmost_index,
+        )?;
+
+        // Get rightmost proof from accounts
+        let mut proof = vec![];
+        for node in ctx.remaining_accounts.iter() {
+            proof.push(node.key().to_bytes());
+        }
+        fill_in_proof_from_canopy(
+            canopy_bytes,
+            header.get_max_depth(),
+            rightmost_index,
+            &mut proof,
+        )?;
+        assert_eq!(proof.len(), header.get_max_depth() as usize);
+
+        let id = ctx.accounts.merkle_tree.key();
+        // A call is made to ConcurrentMerkleTree::initialize_with_root
+        let args = &InitializeWithRootArgs {
+            root,
+            rightmost_leaf,
+            proof_vec: proof,
+            index: rightmost_index,
+        };
+        let change_log = merkle_tree_initialize_with_root(&header, id, tree_bytes, args)?;
+        update_canopy(canopy_bytes, header.get_max_depth(), Some(&change_log))?;
+        wrap_event(
+            &AccountCompressionEvent::ChangeLog(*change_log),
+            &ctx.accounts.noop,
+        )
+    }
 
     /// Executes an instruction that overwrites a leaf node.
     /// Composing programs should check that the data hashed into previous_leaf
@@ -270,17 +378,15 @@ pub mod spl_account_compression {
         fill_in_proof_from_canopy(canopy_bytes, header.get_max_depth(), index, &mut proof)?;
         let id = ctx.accounts.merkle_tree.key();
         // A call is made to ConcurrentMerkleTree::set_leaf(root, previous_leaf, new_leaf, proof, index)
-        let change_log_event = merkle_tree_apply_fn_mut!(
-            header,
-            id,
-            tree_bytes,
-            set_leaf,
-            root,
+        let args = &SetLeafArgs {
+            current_root: root,
             previous_leaf,
             new_leaf,
-            &proof,
+            proof_vec: proof,
             index,
-        )?;
+        };
+        let change_log_event = merkle_tree_set_leaf(&header, id, tree_bytes, args)?;
+
         update_canopy(
             canopy_bytes,
             header.get_max_depth(),
@@ -347,7 +453,14 @@ pub mod spl_account_compression {
         fill_in_proof_from_canopy(canopy_bytes, header.get_max_depth(), index, &mut proof)?;
         let id = ctx.accounts.merkle_tree.key();
 
-        merkle_tree_apply_fn!(header, id, tree_bytes, prove_leaf, root, leaf, &proof, index)?;
+        let args = &ProveLeafArgs {
+            current_root: root,
+            leaf,
+            proof_vec: proof,
+            index,
+        };
+        merkle_tree_prove_leaf(&header, id, tree_bytes, args)?;
+
         Ok(())
     }
 
@@ -373,7 +486,7 @@ pub mod spl_account_compression {
         let id = ctx.accounts.merkle_tree.key();
         let merkle_tree_size = merkle_tree_get_size(&header)?;
         let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
-        let change_log_event = merkle_tree_apply_fn_mut!(header, id, tree_bytes, append, leaf)?;
+        let change_log_event = merkle_tree_append_leaf(&header, id, tree_bytes, &leaf)?;
         update_canopy(
             canopy_bytes,
             header.get_max_depth(),
@@ -418,16 +531,14 @@ pub mod spl_account_compression {
         fill_in_proof_from_canopy(canopy_bytes, header.get_max_depth(), index, &mut proof)?;
         // A call is made to ConcurrentMerkleTree::fill_empty_or_append
         let id = ctx.accounts.merkle_tree.key();
-        let change_log_event = merkle_tree_apply_fn_mut!(
-            header,
-            id,
-            tree_bytes,
-            fill_empty_or_append,
-            root,
+        let args = &FillEmptyOrAppendArgs {
+            current_root: root,
             leaf,
-            &proof,
+            proof_vec: proof,
             index,
-        )?;
+        };
+        let change_log_event = merkle_tree_fill_empty_or_append(&header, id, tree_bytes, args)?;
+
         update_canopy(
             canopy_bytes,
             header.get_max_depth(),
@@ -456,7 +567,7 @@ pub mod spl_account_compression {
         let (tree_bytes, canopy_bytes) = rest.split_at_mut(merkle_tree_size);
 
         let id = ctx.accounts.merkle_tree.key();
-        merkle_tree_apply_fn_mut!(header, id, tree_bytes, prove_tree_is_empty,)?;
+        assert_tree_is_empty(&header, id, tree_bytes)?;
 
         // Close merkle tree account
         // 1. Move lamports
diff --git a/account-compression/programs/account-compression/src/macros.rs b/account-compression/programs/account-compression/src/macros.rs
index cba647cf50b..fd2e339fb56 100644
--- a/account-compression/programs/account-compression/src/macros.rs
+++ b/account-compression/programs/account-compression/src/macros.rs
@@ -4,8 +4,8 @@ enum TreeLoad {
     Mutable,
 }
 
-/// This macro applies functions on a ConcurrentMerkleT:ee and emits leaf information
-/// needed to sync the merkle tree state with off-chain indexers.
+/// This macro applies functions on a ConcurrentMerkleT:ee and emits leaf
+/// information needed to sync the merkle tree state with off-chain indexers.
 #[macro_export]
 macro_rules! _merkle_tree_depth_size_apply_fn {
     ($max_depth:literal, $max_size:literal, $id:ident, $bytes:ident, $func:ident, TreeLoad::Mutable, $($arg:tt)*)
@@ -118,3 +118,8 @@ macro_rules! merkle_tree_apply_fn {
         _merkle_tree_apply_fn!($header, $id, $bytes, $func, TreeLoad::Immutable, $($arg)*)
     };
 }
+
+pub(crate) use {
+    _merkle_tree_apply_fn, _merkle_tree_depth_size_apply_fn, merkle_tree_apply_fn,
+    merkle_tree_apply_fn_mut,
+};
diff --git a/account-compression/programs/account-compression/src/state/concurrent_merkle_tree_header.rs b/account-compression/programs/account-compression/src/state/concurrent_merkle_tree_header.rs
index 6d326b76142..5483a12947f 100644
--- a/account-compression/programs/account-compression/src/state/concurrent_merkle_tree_header.rs
+++ b/account-compression/programs/account-compression/src/state/concurrent_merkle_tree_header.rs
@@ -24,6 +24,9 @@ impl std::fmt::Display for CompressionAccountType {
     }
 }
 
+#[cfg(feature = "idl-build")]
+impl anchor_lang::IdlBuild for CompressionAccountType {}
+
 /// Initialization parameters for an SPL ConcurrentMerkleTree.
 ///
 /// Only the following permutations are valid:
@@ -65,9 +68,14 @@ pub struct ConcurrentMerkleTreeHeaderDataV1 {
     /// Provides a lower-bound on what slot to start (re-)building a tree from.
     creation_slot: u64,
 
+    /// A flag indicating whether the tree has been initialized with a root.
+    /// This field was added together with the `finalize_tree_with_root` instruction.
+    /// It takes 1 byte of space taken from the previous padding for existing accounts.
+    is_batch_initialized: bool,
+
     /// Needs padding for the account to be 8-byte aligned
     /// 8-byte alignment is necessary to zero-copy the SPL ConcurrentMerkleTree
-    _padding: [u8; 6],
+    _padding: [u8; 5],
 }
 
 #[repr(C)]
@@ -95,6 +103,24 @@ impl ConcurrentMerkleTreeHeader {
                 header.max_depth = max_depth;
                 header.authority = *authority;
                 header.creation_slot = creation_slot;
+                // is_batch_initialized is left false by default
+            }
+        }
+    }
+
+    /// Initializes the header with the given parameters and sets the `is_batch_initialized` flag to
+    /// true.
+    pub fn initialize_batched(
+        &mut self,
+        max_depth: u32,
+        max_buffer_size: u32,
+        authority: &Pubkey,
+        creation_slot: u64,
+    ) {
+        self.initialize(max_depth, max_buffer_size, authority, creation_slot);
+        match self.header {
+            ConcurrentMerkleTreeHeaderData::V1(ref mut header) => {
+                header.is_batch_initialized = true;
             }
         }
     }
@@ -117,6 +143,12 @@ impl ConcurrentMerkleTreeHeader {
         }
     }
 
+    pub fn get_is_batch_initialized(&self) -> bool {
+        match &self.header {
+            ConcurrentMerkleTreeHeaderData::V1(header) => header.is_batch_initialized,
+        }
+    }
+
     pub fn set_new_authority(&mut self, new_authority: &Pubkey) {
         match self.header {
             ConcurrentMerkleTreeHeaderData::V1(ref mut header) => {
@@ -155,6 +187,18 @@ impl ConcurrentMerkleTreeHeader {
         }
         Ok(())
     }
+
+    pub fn assert_is_batch_initialized(&self) -> Result<()> {
+        match &self.header {
+            ConcurrentMerkleTreeHeaderData::V1(header) => {
+                require!(
+                    header.is_batch_initialized,
+                    AccountCompressionError::BatchNotInitialized
+                );
+            }
+        }
+        Ok(())
+    }
 }
 
 pub fn merkle_tree_get_size(header: &ConcurrentMerkleTreeHeader) -> Result<usize> {
@@ -166,10 +210,10 @@ pub fn merkle_tree_get_size(header: &ConcurrentMerkleTreeHeader) -> Result<usize
         (7, 16) => Ok(size_of::<ConcurrentMerkleTree<7, 16>>()),
         (8, 16) => Ok(size_of::<ConcurrentMerkleTree<8, 16>>()),
         (9, 16) => Ok(size_of::<ConcurrentMerkleTree<9, 16>>()),
-        (10, 32)=> Ok(size_of::<ConcurrentMerkleTree<10, 32>>()),
-        (11, 32)=> Ok(size_of::<ConcurrentMerkleTree<11, 32>>()),
-        (12, 32)=> Ok(size_of::<ConcurrentMerkleTree<12, 32>>()),
-        (13, 32)=> Ok(size_of::<ConcurrentMerkleTree<13, 32>>()),
+        (10, 32) => Ok(size_of::<ConcurrentMerkleTree<10, 32>>()),
+        (11, 32) => Ok(size_of::<ConcurrentMerkleTree<11, 32>>()),
+        (12, 32) => Ok(size_of::<ConcurrentMerkleTree<12, 32>>()),
+        (13, 32) => Ok(size_of::<ConcurrentMerkleTree<13, 32>>()),
         (14, 64) => Ok(size_of::<ConcurrentMerkleTree<14, 64>>()),
         (14, 256) => Ok(size_of::<ConcurrentMerkleTree<14, 256>>()),
         (14, 1024) => Ok(size_of::<ConcurrentMerkleTree<14, 1024>>()),
diff --git a/account-compression/sdk/README.md b/account-compression/sdk/README.md
index b4f81da6d62..00c37ff2169 100644
--- a/account-compression/sdk/README.md
+++ b/account-compression/sdk/README.md
@@ -6,13 +6,13 @@ For more information, see the full [Solana account compression SDK documentation
 ## Install
 
 ```shell
-npm install --save @solana/spl-account-compression @solana/web3.js
+npm install --save @solana/spl-account-compression @solana/web3.js@1
 ```
 
 __OR__
 
 ```shell
-yarn add @solana/spl-account-compression @solana/web3.js
+yarn add @solana/spl-account-compression @solana/web3.js@1
 ```
 
 ## Information
@@ -167,7 +167,7 @@ Here are some examples using account compression in the wild:
 
 * Solana Program Library [tests](https://github.com/solana-labs/solana-program-library/tree/master/account-compression/sdk/tests)
 
-* Metaplex Program Library Compressed NFT [tests](https://github.com/metaplex-foundation/metaplex-program-library/tree/master/bubblegum/js/tests)
+* Metaplex Program Library Compressed NFT [tests](https://github.com/metaplex-foundation/mpl-bubblegum/tree/main/clients/js/test)
 
 ## Build from Source
 
diff --git a/account-compression/sdk/idl/spl_account_compression.json b/account-compression/sdk/idl/spl_account_compression.json
index 1a5de6f83d9..a9477f25eca 100644
--- a/account-compression/sdk/idl/spl_account_compression.json
+++ b/account-compression/sdk/idl/spl_account_compression.json
@@ -1,5 +1,5 @@
 {
-  "version": "0.2.0",
+  "version": "0.3.1",
   "name": "spl_account_compression",
   "instructions": [
     {
@@ -51,18 +51,171 @@
         }
       ]
     },
+    {
+      "name": "prepareBatchMerkleTree",
+      "docs": [
+        "In order to initialize a tree with a root, we need to create the tree on-chain first with",
+        "the proper authority. The tree might contain a canopy, which is a cache of the uppermost",
+        "nodes. The canopy is used to decrease the size of the proof required to update the tree.",
+        "If the tree is expected to have a canopy, it needs to be prefilled with the necessary nodes.",
+        "There are 2 ways to initialize a merkle tree:",
+        "1. Initialize an empty tree",
+        "2. Initialize a tree with a root and leaf",
+        "For the former case, the canopy will be empty which is expected for an empty tree. The",
+        "expected flow is `init_empty_merkle_tree`. For the latter case, the canopy should be",
+        "filled with the necessary nodes to render the tree usable. Thus we need to prefill the",
+        "canopy with the necessary nodes. The expected flow for a tree without canopy is",
+        "`prepare_batch_merkle_tree` -> `init_prepared_tree_with_root`. The expected flow for a tree",
+        "with canopy is `prepare_batch_merkle_tree` -> `append_canopy_nodes` (multiple times",
+        "until all of the canopy is filled) -> `init_prepared_tree_with_root`. This instruction",
+        "initializes the tree header while leaving the tree itself uninitialized. This allows",
+        "distinguishing between an empty tree and a tree prepare to be initialized with a root."
+      ],
+      "accounts": [
+        {
+          "name": "merkleTree",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true,
+          "docs": [
+            "Authority that controls write-access to the tree",
+            "Typically a program, e.g., the Bubblegum contract validates that leaves are valid NFTs."
+          ]
+        },
+        {
+          "name": "noop",
+          "isMut": false,
+          "isSigner": false,
+          "docs": ["Program used to emit changelogs as cpi instruction data."]
+        }
+      ],
+      "args": [
+        {
+          "name": "maxDepth",
+          "type": "u32"
+        },
+        {
+          "name": "maxBufferSize",
+          "type": "u32"
+        }
+      ]
+    },
+    {
+      "name": "appendCanopyNodes",
+      "docs": [
+        "This instruction pre-initializes the canopy with the specified leaf nodes of the canopy.",
+        "This is intended to be used after `prepare_batch_merkle_tree` and in conjunction with the",
+        "`init_prepared_tree_with_root` instruction that'll finalize the tree initialization.",
+        "The canopy is used to cache the uppermost nodes of the tree, which allows for a smaller",
+        "proof size when updating the tree. The canopy should be filled with the necessary nodes",
+        "before calling `init_prepared_tree_with_root`. You may call this instruction multiple",
+        "times to fill the canopy with the necessary nodes. The canopy may be filled with the",
+        "nodes in any order. The already filled nodes may be replaced with new nodes before calling",
+        "`init_prepared_tree_with_root` if the step was done in error.",
+        "The canopy should be filled with all the nodes that are to the left of the rightmost",
+        "leaf of the tree before calling `init_prepared_tree_with_root`. The canopy should not",
+        "contain any nodes to the right of the rightmost leaf of the tree.",
+        "This instruction calculates and filles in all the canopy nodes \"above\" the provided ones.",
+        "The validation of the canopy is done in the `init_prepared_tree_with_root` instruction."
+      ],
+      "accounts": [
+        {
+          "name": "merkleTree",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true,
+          "docs": [
+            "Authority that controls write-access to the tree",
+            "Typically a program, e.g., the Bubblegum contract validates that leaves are valid NFTs."
+          ]
+        },
+        {
+          "name": "noop",
+          "isMut": false,
+          "isSigner": false,
+          "docs": ["Program used to emit changelogs as cpi instruction data."]
+        }
+      ],
+      "args": [
+        {
+          "name": "startIndex",
+          "type": "u32"
+        },
+        {
+          "name": "canopyNodes",
+          "type": {
+            "vec": {
+              "array": ["u8", 32]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "initPreparedTreeWithRoot",
+      "docs": [
+        "Initializes a prepared tree with a root and a rightmost leaf. The rightmost leaf is used to",
+        "verify the canopy if the tree has it. Before calling this instruction, the tree should be",
+        "prepared with `prepare_batch_merkle_tree` and the canopy should be filled with the necessary",
+        "nodes with `append_canopy_nodes` (if the canopy is used). This method should be used for",
+        "batch creation of trees. The indexing of such batches should be done off-chain. The",
+        "programs calling this instruction should take care of ensuring the indexing is possible.",
+        "For example, staking may be required to ensure the tree creator has some responsibility",
+        "for what is being indexed. If indexing is not possible, there should be a mechanism to",
+        "penalize the tree creator."
+      ],
+      "accounts": [
+        {
+          "name": "merkleTree",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true,
+          "docs": [
+            "Authority that controls write-access to the tree",
+            "Typically a program, e.g., the Bubblegum contract validates that leaves are valid NFTs."
+          ]
+        },
+        {
+          "name": "noop",
+          "isMut": false,
+          "isSigner": false,
+          "docs": ["Program used to emit changelogs as cpi instruction data."]
+        }
+      ],
+      "args": [
+        {
+          "name": "root",
+          "type": {
+            "array": ["u8", 32]
+          }
+        },
+        {
+          "name": "rightmostLeaf",
+          "type": {
+            "array": ["u8", 32]
+          }
+        },
+        {
+          "name": "rightmostIndex",
+          "type": "u32"
+        }
+      ]
+    },
     {
       "name": "replaceLeaf",
       "docs": [
-        "Note:",
-        "Supporting this instruction open a security vulnerability for indexers.",
-        "This instruction has been deemed unusable for publicly indexed compressed NFTs.",
-        "Indexing batched data in this way requires indexers to read in the `uri`s onto physical storage",
-        "and then into their database. This opens up a DOS attack vector, whereby this instruction is",
-        "repeatedly invoked, causing indexers to fail.",
-        "",
-        "Because this instruction was deemed insecure, this instruction has been removed",
-        "until secure usage is available on-chain.",
         "Executes an instruction that overwrites a leaf node.",
         "Composing programs should check that the data hashed into previous_leaf",
         "matches the authority information necessary to execute this instruction."
@@ -407,6 +560,15 @@
             ],
             "type": "u64"
           },
+          {
+            "name": "isBatchInitialized",
+            "docs": [
+              "A flag indicating whether the tree has been initialized with a root.",
+              "This field was added together with the `finalize_tree_with_root` instruction.",
+              "It takes 1 byte of space taken from the previous padding for existing accounts."
+            ],
+            "type": "bool"
+          },
           {
             "name": "padding",
             "docs": [
@@ -414,7 +576,7 @@
               "8-byte alignment is necessary to zero-copy the SPL ConcurrentMerkleTree"
             ],
             "type": {
-              "array": ["u8", 6]
+              "array": ["u8", 5]
             }
           }
         ]
@@ -570,12 +732,37 @@
       "code": 6008,
       "name": "LeafIndexOutOfBounds",
       "msg": "Leaf index of concurrent merkle tree is out of bounds"
+    },
+    {
+      "code": 6009,
+      "name": "CanopyNotAllocated",
+      "msg": "Tree was initialized without allocating space for the canopy"
+    },
+    {
+      "code": 6010,
+      "name": "TreeAlreadyInitialized",
+      "msg": "Tree was already initialized"
+    },
+    {
+      "code": 6011,
+      "name": "BatchNotInitialized",
+      "msg": "Tree header was not initialized for batch processing"
+    },
+    {
+      "code": 6012,
+      "name": "CanopyRootMismatch",
+      "msg": "Canopy root does not match the root of the tree"
+    },
+    {
+      "code": 6013,
+      "name": "CanopyRightmostLeafMismatch",
+      "msg": "Canopy contains nodes to the right of the rightmost leaf of the tree"
     }
   ],
   "metadata": {
     "address": "cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK",
     "origin": "anchor",
-    "binaryVersion": "0.25.0",
-    "libVersion": "0.25.0"
+    "binaryVersion": "0.29.0",
+    "libVersion": "0.29.0"
   }
 }
diff --git a/account-compression/sdk/package.json b/account-compression/sdk/package.json
index 71b2eab418a..c5b5069991b 100644
--- a/account-compression/sdk/package.json
+++ b/account-compression/sdk/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@solana/spl-account-compression",
   "description": "SPL Account Compression Program JS API",
-  "version": "0.2.1",
+  "version": "0.4.1",
   "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
   "repository": {
     "url": "https://github.com/solana-labs/solana-program-library",
@@ -35,14 +35,11 @@
   "scripts": {
     "build": "rm -rf dist/ && tsc -p tsconfig.json",
     "build:program": "cargo build-sbf --manifest-path=../programs/account-compression/Cargo.toml && cargo build-sbf --manifest-path=../programs/noop/Cargo.toml",
-    "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-    "pretty": "prettier --check '{,{src,test}/**/}*.{j,t}s'",
-    "pretty:fix": "prettier --write '{,{src,test}/**/}*.{j,t}s'",
-    "lint": "set -ex; npm run pretty; eslint . --ext .js,.ts",
-    "lint:fix": "npm run pretty:fix && eslint . --fix --ext .js,.ts",
+    "lint": "set -ex; eslint . --ext .js,.ts",
+    "lint:fix": "eslint . --fix --ext .js,.ts",
     "docs": "rm -rf docs/ && typedoc --out docs",
     "deploy:docs": "npm run docs && gh-pages --dest account-compression/sdk --dist docs --dotfiles",
-    "start-validator": "solana-test-validator --reset --quiet --bpf-program cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK ../target/deploy/spl_account_compression.so --bpf-program noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV ../target/deploy/spl_noop.so",
+    "start-validator": "solana-test-validator --reset --quiet --bpf-program cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK ../target/deploy/spl_account_compression.so --bpf-program noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV ../target/deploy/spl_noop.so --account 27QMkDMpBoAhmWj6xxQNYdqXZL5nnC8tkZcEtkNxCqeX pre-batch-init-tree-account.json",
     "run-tests": "jest tests --detectOpenHandles",
     "run-tests:events": "jest tests/events --detectOpenHandles",
     "run-tests:accounts": "jest tests/accounts --detectOpenHandles",
@@ -61,38 +58,34 @@
     "typescript-collections": "^1.3.3"
   },
   "peerDependencies": {
-    "@solana/web3.js": "^1.93.0"
+    "@solana/web3.js": "^1.95.4"
   },
   "devDependencies": {
     "@metaplex-foundation/rustbin": "^0.3.5",
     "@metaplex-foundation/solita": "0.20.1",
-    "@project-serum/anchor": "^0.26.0",
+    "@coral-xyz/anchor": "^0.29.0",
     "@solana/eslint-config-solana": "^3.0.3",
-    "@solana/prettier-config-solana": "^0.0.5",
-    "@types/bn.js": "^5.1.0",
-    "@types/jest": "^29.5.12",
-    "@types/node-fetch": "^2.6.11",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
+    "@types/bn.js": "^5.1.6",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.5",
+    "@types/node-fetch": "^2.6.12",
+    "@typescript-eslint/eslint-plugin": "^8.4.0",
+    "@typescript-eslint/parser": "^8.4.0",
     "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-turbo": "^2.0.4",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jest": "^28.6.0",
-    "eslint-plugin-mocha": "^10.4.3",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-simple-import-sort": "^12.1.0",
+    "eslint-config-turbo": "^2.3.3",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.10.0",
+    "eslint-plugin-mocha": "^10.5.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-sort-keys-fix": "^1.1.2",
-    "gh-pages": "^6.1.1",
+    "gh-pages": "^6.3.0",
     "jest": "^29.0.1",
     "jest-config": "^29.0.1",
-    "prettier": "^3.3.2",
-    "start-server-and-test": "^2.0.4",
-    "ts-jest": "^29.1.5",
+    "start-server-and-test": "^2.0.9",
+    "ts-jest": "^29.2.5",
     "ts-jest-resolver": "^2.0.1",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.25.13",
-    "typescript": "5.4.5"
-  },
-  "prettier": "@solana/prettier-config-solana"
+    "typedoc": "^0.27.6",
+    "typescript": "5.7.2"
+  }
 }
diff --git a/account-compression/sdk/src/.prettierignore b/account-compression/sdk/src/.prettierignore
deleted file mode 100644
index 3380d72b2f8..00000000000
--- a/account-compression/sdk/src/.prettierignore
+++ /dev/null
@@ -1,2 +0,0 @@
-test/dist
-docs/
\ No newline at end of file
diff --git a/account-compression/sdk/src/accounts/ConcurrentMerkleTreeAccount.ts b/account-compression/sdk/src/accounts/ConcurrentMerkleTreeAccount.ts
index 2e602599b18..bef2f4954cb 100644
--- a/account-compression/sdk/src/accounts/ConcurrentMerkleTreeAccount.ts
+++ b/account-compression/sdk/src/accounts/ConcurrentMerkleTreeAccount.ts
@@ -121,6 +121,14 @@ export class ConcurrentMerkleTreeAccount {
     getCanopyDepth(): number {
         return getCanopyDepth(this.canopy.canopyBytes.length);
     }
+
+    /**
+     * Returns the flag that indicates if the tree has been batch initialized
+     * @returns the flag
+     */
+    getIsBatchInitialized(): boolean {
+        return this.getHeaderV1().isBatchInitialized;
+    }
 }
 
 /**
diff --git a/account-compression/sdk/src/generated/errors/index.ts b/account-compression/sdk/src/generated/errors/index.ts
index 4600510da7f..03066ebcf49 100644
--- a/account-compression/sdk/src/generated/errors/index.ts
+++ b/account-compression/sdk/src/generated/errors/index.ts
@@ -194,6 +194,106 @@ export class LeafIndexOutOfBoundsError extends Error {
 createErrorFromCodeLookup.set(0x1778, () => new LeafIndexOutOfBoundsError());
 createErrorFromNameLookup.set('LeafIndexOutOfBounds', () => new LeafIndexOutOfBoundsError());
 
+/**
+ * CanopyNotAllocated: 'Tree was initialized without allocating space for the canopy'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CanopyNotAllocatedError extends Error {
+    readonly code: number = 0x1779;
+    readonly name: string = 'CanopyNotAllocated';
+    constructor() {
+        super('Tree was initialized without allocating space for the canopy');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, CanopyNotAllocatedError);
+        }
+    }
+}
+
+createErrorFromCodeLookup.set(0x1779, () => new CanopyNotAllocatedError());
+createErrorFromNameLookup.set('CanopyNotAllocated', () => new CanopyNotAllocatedError());
+
+/**
+ * TreeAlreadyInitialized: 'Tree was already initialized'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class TreeAlreadyInitializedError extends Error {
+    readonly code: number = 0x177a;
+    readonly name: string = 'TreeAlreadyInitialized';
+    constructor() {
+        super('Tree was already initialized');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, TreeAlreadyInitializedError);
+        }
+    }
+}
+
+createErrorFromCodeLookup.set(0x177a, () => new TreeAlreadyInitializedError());
+createErrorFromNameLookup.set('TreeAlreadyInitialized', () => new TreeAlreadyInitializedError());
+
+/**
+ * BatchNotInitialized: 'Tree header was not initialized for batch processing'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class BatchNotInitializedError extends Error {
+    readonly code: number = 0x177b;
+    readonly name: string = 'BatchNotInitialized';
+    constructor() {
+        super('Tree header was not initialized for batch processing');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, BatchNotInitializedError);
+        }
+    }
+}
+
+createErrorFromCodeLookup.set(0x177b, () => new BatchNotInitializedError());
+createErrorFromNameLookup.set('BatchNotInitialized', () => new BatchNotInitializedError());
+
+/**
+ * CanopyRootMismatch: 'Canopy root does not match the root of the tree'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CanopyRootMismatchError extends Error {
+    readonly code: number = 0x177c;
+    readonly name: string = 'CanopyRootMismatch';
+    constructor() {
+        super('Canopy root does not match the root of the tree');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, CanopyRootMismatchError);
+        }
+    }
+}
+
+createErrorFromCodeLookup.set(0x177c, () => new CanopyRootMismatchError());
+createErrorFromNameLookup.set('CanopyRootMismatch', () => new CanopyRootMismatchError());
+
+/**
+ * CanopyRightmostLeafMismatch: 'Canopy contains nodes to the right of the rightmost leaf of the tree'
+ *
+ * @category Errors
+ * @category generated
+ */
+export class CanopyRightmostLeafMismatchError extends Error {
+    readonly code: number = 0x177d;
+    readonly name: string = 'CanopyRightmostLeafMismatch';
+    constructor() {
+        super('Canopy contains nodes to the right of the rightmost leaf of the tree');
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, CanopyRightmostLeafMismatchError);
+        }
+    }
+}
+
+createErrorFromCodeLookup.set(0x177d, () => new CanopyRightmostLeafMismatchError());
+createErrorFromNameLookup.set('CanopyRightmostLeafMismatch', () => new CanopyRightmostLeafMismatchError());
+
 /**
  * Attempts to resolve a custom program error from the provided error code.
  * @category Errors
diff --git a/account-compression/sdk/src/generated/instructions/appendCanopyNodes.ts b/account-compression/sdk/src/generated/instructions/appendCanopyNodes.ts
new file mode 100644
index 00000000000..5cf4ddff765
--- /dev/null
+++ b/account-compression/sdk/src/generated/instructions/appendCanopyNodes.ts
@@ -0,0 +1,105 @@
+/**
+ * This code was GENERATED using the solita package.
+ * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
+ *
+ * See: https://github.com/metaplex-foundation/solita
+ */
+
+import * as beet from '@metaplex-foundation/beet';
+import * as web3 from '@solana/web3.js';
+
+/**
+ * @category Instructions
+ * @category AppendCanopyNodes
+ * @category generated
+ */
+export type AppendCanopyNodesInstructionArgs = {
+    canopyNodes: number[] /* size: 32 */[];
+    startIndex: number;
+};
+/**
+ * @category Instructions
+ * @category AppendCanopyNodes
+ * @category generated
+ */
+export const appendCanopyNodesStruct = new beet.FixableBeetArgsStruct<
+    AppendCanopyNodesInstructionArgs & {
+        instructionDiscriminator: number[] /* size: 8 */;
+    }
+>(
+    [
+        ['instructionDiscriminator', beet.uniformFixedSizeArray(beet.u8, 8)],
+        ['startIndex', beet.u32],
+        ['canopyNodes', beet.array(beet.uniformFixedSizeArray(beet.u8, 32))],
+    ],
+    'AppendCanopyNodesInstructionArgs',
+);
+/**
+ * Accounts required by the _appendCanopyNodes_ instruction
+ *
+ * @property [_writable_] merkleTree
+ * @property [**signer**] authority
+ * @property [] noop
+ * @category Instructions
+ * @category AppendCanopyNodes
+ * @category generated
+ */
+export type AppendCanopyNodesInstructionAccounts = {
+    anchorRemainingAccounts?: web3.AccountMeta[];
+    authority: web3.PublicKey;
+    merkleTree: web3.PublicKey;
+    noop: web3.PublicKey;
+};
+
+export const appendCanopyNodesInstructionDiscriminator = [139, 155, 238, 167, 11, 243, 132, 205];
+
+/**
+ * Creates a _AppendCanopyNodes_ instruction.
+ *
+ * @param accounts that will be accessed while the instruction is processed
+ * @param args to provide as instruction data to the program
+ *
+ * @category Instructions
+ * @category AppendCanopyNodes
+ * @category generated
+ */
+export function createAppendCanopyNodesInstruction(
+    accounts: AppendCanopyNodesInstructionAccounts,
+    args: AppendCanopyNodesInstructionArgs,
+    programId = new web3.PublicKey('cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK'),
+) {
+    const [data] = appendCanopyNodesStruct.serialize({
+        instructionDiscriminator: appendCanopyNodesInstructionDiscriminator,
+        ...args,
+    });
+    const keys: web3.AccountMeta[] = [
+        {
+            isSigner: false,
+            isWritable: true,
+            pubkey: accounts.merkleTree,
+        },
+        {
+            isSigner: true,
+            isWritable: false,
+            pubkey: accounts.authority,
+        },
+        {
+            isSigner: false,
+            isWritable: false,
+            pubkey: accounts.noop,
+        },
+    ];
+
+    if (accounts.anchorRemainingAccounts != null) {
+        for (const acc of accounts.anchorRemainingAccounts) {
+            keys.push(acc);
+        }
+    }
+
+    const ix = new web3.TransactionInstruction({
+        data,
+        keys,
+        programId,
+    });
+    return ix;
+}
diff --git a/account-compression/sdk/src/generated/instructions/index.ts b/account-compression/sdk/src/generated/instructions/index.ts
index 7194bbb5b9e..10605ab4704 100644
--- a/account-compression/sdk/src/generated/instructions/index.ts
+++ b/account-compression/sdk/src/generated/instructions/index.ts
@@ -1,7 +1,10 @@
 export * from './append';
+export * from './appendCanopyNodes';
 export * from './closeEmptyTree';
 export * from './initEmptyMerkleTree';
+export * from './initPreparedTreeWithRoot';
 export * from './insertOrAppend';
+export * from './prepareBatchMerkleTree';
 export * from './replaceLeaf';
 export * from './transferAuthority';
 export * from './verifyLeaf';
diff --git a/account-compression/sdk/src/generated/instructions/initPreparedTreeWithRoot.ts b/account-compression/sdk/src/generated/instructions/initPreparedTreeWithRoot.ts
new file mode 100644
index 00000000000..b729a877a95
--- /dev/null
+++ b/account-compression/sdk/src/generated/instructions/initPreparedTreeWithRoot.ts
@@ -0,0 +1,107 @@
+/**
+ * This code was GENERATED using the solita package.
+ * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
+ *
+ * See: https://github.com/metaplex-foundation/solita
+ */
+
+import * as beet from '@metaplex-foundation/beet';
+import * as web3 from '@solana/web3.js';
+
+/**
+ * @category Instructions
+ * @category InitPreparedTreeWithRoot
+ * @category generated
+ */
+export type InitPreparedTreeWithRootInstructionArgs = {
+    rightmostIndex: number;
+    rightmostLeaf: number[] /* size: 32 */;
+    root: number[] /* size: 32 */;
+};
+/**
+ * @category Instructions
+ * @category InitPreparedTreeWithRoot
+ * @category generated
+ */
+export const initPreparedTreeWithRootStruct = new beet.BeetArgsStruct<
+    InitPreparedTreeWithRootInstructionArgs & {
+        instructionDiscriminator: number[] /* size: 8 */;
+    }
+>(
+    [
+        ['instructionDiscriminator', beet.uniformFixedSizeArray(beet.u8, 8)],
+        ['root', beet.uniformFixedSizeArray(beet.u8, 32)],
+        ['rightmostLeaf', beet.uniformFixedSizeArray(beet.u8, 32)],
+        ['rightmostIndex', beet.u32],
+    ],
+    'InitPreparedTreeWithRootInstructionArgs',
+);
+/**
+ * Accounts required by the _initPreparedTreeWithRoot_ instruction
+ *
+ * @property [_writable_] merkleTree
+ * @property [**signer**] authority
+ * @property [] noop
+ * @category Instructions
+ * @category InitPreparedTreeWithRoot
+ * @category generated
+ */
+export type InitPreparedTreeWithRootInstructionAccounts = {
+    anchorRemainingAccounts?: web3.AccountMeta[];
+    authority: web3.PublicKey;
+    merkleTree: web3.PublicKey;
+    noop: web3.PublicKey;
+};
+
+export const initPreparedTreeWithRootInstructionDiscriminator = [218, 248, 192, 55, 91, 205, 122, 10];
+
+/**
+ * Creates a _InitPreparedTreeWithRoot_ instruction.
+ *
+ * @param accounts that will be accessed while the instruction is processed
+ * @param args to provide as instruction data to the program
+ *
+ * @category Instructions
+ * @category InitPreparedTreeWithRoot
+ * @category generated
+ */
+export function createInitPreparedTreeWithRootInstruction(
+    accounts: InitPreparedTreeWithRootInstructionAccounts,
+    args: InitPreparedTreeWithRootInstructionArgs,
+    programId = new web3.PublicKey('cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK'),
+) {
+    const [data] = initPreparedTreeWithRootStruct.serialize({
+        instructionDiscriminator: initPreparedTreeWithRootInstructionDiscriminator,
+        ...args,
+    });
+    const keys: web3.AccountMeta[] = [
+        {
+            isSigner: false,
+            isWritable: true,
+            pubkey: accounts.merkleTree,
+        },
+        {
+            isSigner: true,
+            isWritable: false,
+            pubkey: accounts.authority,
+        },
+        {
+            isSigner: false,
+            isWritable: false,
+            pubkey: accounts.noop,
+        },
+    ];
+
+    if (accounts.anchorRemainingAccounts != null) {
+        for (const acc of accounts.anchorRemainingAccounts) {
+            keys.push(acc);
+        }
+    }
+
+    const ix = new web3.TransactionInstruction({
+        data,
+        keys,
+        programId,
+    });
+    return ix;
+}
diff --git a/account-compression/sdk/src/generated/instructions/prepareBatchMerkleTree.ts b/account-compression/sdk/src/generated/instructions/prepareBatchMerkleTree.ts
new file mode 100644
index 00000000000..0d5aa007db4
--- /dev/null
+++ b/account-compression/sdk/src/generated/instructions/prepareBatchMerkleTree.ts
@@ -0,0 +1,105 @@
+/**
+ * This code was GENERATED using the solita package.
+ * Please DO NOT EDIT THIS FILE, instead rerun solita to update it or write a wrapper to add functionality.
+ *
+ * See: https://github.com/metaplex-foundation/solita
+ */
+
+import * as beet from '@metaplex-foundation/beet';
+import * as web3 from '@solana/web3.js';
+
+/**
+ * @category Instructions
+ * @category PrepareBatchMerkleTree
+ * @category generated
+ */
+export type PrepareBatchMerkleTreeInstructionArgs = {
+    maxBufferSize: number;
+    maxDepth: number;
+};
+/**
+ * @category Instructions
+ * @category PrepareBatchMerkleTree
+ * @category generated
+ */
+export const prepareBatchMerkleTreeStruct = new beet.BeetArgsStruct<
+    PrepareBatchMerkleTreeInstructionArgs & {
+        instructionDiscriminator: number[] /* size: 8 */;
+    }
+>(
+    [
+        ['instructionDiscriminator', beet.uniformFixedSizeArray(beet.u8, 8)],
+        ['maxDepth', beet.u32],
+        ['maxBufferSize', beet.u32],
+    ],
+    'PrepareBatchMerkleTreeInstructionArgs',
+);
+/**
+ * Accounts required by the _prepareBatchMerkleTree_ instruction
+ *
+ * @property [_writable_] merkleTree
+ * @property [**signer**] authority
+ * @property [] noop
+ * @category Instructions
+ * @category PrepareBatchMerkleTree
+ * @category generated
+ */
+export type PrepareBatchMerkleTreeInstructionAccounts = {
+    anchorRemainingAccounts?: web3.AccountMeta[];
+    authority: web3.PublicKey;
+    merkleTree: web3.PublicKey;
+    noop: web3.PublicKey;
+};
+
+export const prepareBatchMerkleTreeInstructionDiscriminator = [230, 124, 120, 196, 249, 134, 199, 128];
+
+/**
+ * Creates a _PrepareBatchMerkleTree_ instruction.
+ *
+ * @param accounts that will be accessed while the instruction is processed
+ * @param args to provide as instruction data to the program
+ *
+ * @category Instructions
+ * @category PrepareBatchMerkleTree
+ * @category generated
+ */
+export function createPrepareBatchMerkleTreeInstruction(
+    accounts: PrepareBatchMerkleTreeInstructionAccounts,
+    args: PrepareBatchMerkleTreeInstructionArgs,
+    programId = new web3.PublicKey('cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK'),
+) {
+    const [data] = prepareBatchMerkleTreeStruct.serialize({
+        instructionDiscriminator: prepareBatchMerkleTreeInstructionDiscriminator,
+        ...args,
+    });
+    const keys: web3.AccountMeta[] = [
+        {
+            isSigner: false,
+            isWritable: true,
+            pubkey: accounts.merkleTree,
+        },
+        {
+            isSigner: true,
+            isWritable: false,
+            pubkey: accounts.authority,
+        },
+        {
+            isSigner: false,
+            isWritable: false,
+            pubkey: accounts.noop,
+        },
+    ];
+
+    if (accounts.anchorRemainingAccounts != null) {
+        for (const acc of accounts.anchorRemainingAccounts) {
+            keys.push(acc);
+        }
+    }
+
+    const ix = new web3.TransactionInstruction({
+        data,
+        keys,
+        programId,
+    });
+    return ix;
+}
diff --git a/account-compression/sdk/src/generated/types/AccountCompressionEvent.ts b/account-compression/sdk/src/generated/types/AccountCompressionEvent.ts
index 4bce6560620..ee25ced07a1 100644
--- a/account-compression/sdk/src/generated/types/AccountCompressionEvent.ts
+++ b/account-compression/sdk/src/generated/types/AccountCompressionEvent.ts
@@ -62,4 +62,4 @@ export const accountCompressionEventBeet = beet.dataEnum<AccountCompressionEvent
             'AccountCompressionEventRecord["ApplicationData"]',
         ),
     ],
-]) as beet.FixableBeet<AccountCompressionEvent>;
+]) as beet.FixableBeet<AccountCompressionEvent, AccountCompressionEvent>;
diff --git a/account-compression/sdk/src/generated/types/ApplicationDataEvent.ts b/account-compression/sdk/src/generated/types/ApplicationDataEvent.ts
index eef6c13b391..d6fd2aff4bf 100644
--- a/account-compression/sdk/src/generated/types/ApplicationDataEvent.ts
+++ b/account-compression/sdk/src/generated/types/ApplicationDataEvent.ts
@@ -49,4 +49,4 @@ export const applicationDataEventBeet = beet.dataEnum<ApplicationDataEventRecord
             'ApplicationDataEventRecord["V1"]',
         ),
     ],
-]) as beet.FixableBeet<ApplicationDataEvent>;
+]) as beet.FixableBeet<ApplicationDataEvent, ApplicationDataEvent>;
diff --git a/account-compression/sdk/src/generated/types/ChangeLogEvent.ts b/account-compression/sdk/src/generated/types/ChangeLogEvent.ts
index ffd34de7791..9418cff3bcf 100644
--- a/account-compression/sdk/src/generated/types/ChangeLogEvent.ts
+++ b/account-compression/sdk/src/generated/types/ChangeLogEvent.ts
@@ -48,4 +48,4 @@ export const changeLogEventBeet = beet.dataEnum<ChangeLogEventRecord>([
             'ChangeLogEventRecord["V1"]',
         ),
     ],
-]) as beet.FixableBeet<ChangeLogEvent>;
+]) as beet.FixableBeet<ChangeLogEvent, ChangeLogEvent>;
diff --git a/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderData.ts b/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderData.ts
index f49f8f38996..3c1c8011f10 100644
--- a/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderData.ts
+++ b/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderData.ts
@@ -53,4 +53,4 @@ export const concurrentMerkleTreeHeaderDataBeet = beet.dataEnum<ConcurrentMerkle
             'ConcurrentMerkleTreeHeaderDataRecord["V1"]',
         ),
     ],
-]) as beet.FixableBeet<ConcurrentMerkleTreeHeaderData>;
+]) as beet.FixableBeet<ConcurrentMerkleTreeHeaderData, ConcurrentMerkleTreeHeaderData>;
diff --git a/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderDataV1.ts b/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderDataV1.ts
index 19a48b0d366..7e3b0e54e78 100644
--- a/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderDataV1.ts
+++ b/account-compression/sdk/src/generated/types/ConcurrentMerkleTreeHeaderDataV1.ts
@@ -11,9 +11,10 @@ import * as web3 from '@solana/web3.js';
 export type ConcurrentMerkleTreeHeaderDataV1 = {
     authority: web3.PublicKey;
     creationSlot: beet.bignum;
+    isBatchInitialized: boolean;
     maxBufferSize: number;
     maxDepth: number;
-    padding: number[] /* size: 6 */;
+    padding: number[] /* size: 5 */;
 };
 
 /**
@@ -26,7 +27,8 @@ export const concurrentMerkleTreeHeaderDataV1Beet = new beet.BeetArgsStruct<Conc
         ['maxDepth', beet.u32],
         ['authority', beetSolana.publicKey],
         ['creationSlot', beet.u64],
-        ['padding', beet.uniformFixedSizeArray(beet.u8, 6)],
+        ['isBatchInitialized', beet.bool],
+        ['padding', beet.uniformFixedSizeArray(beet.u8, 5)],
     ],
     'ConcurrentMerkleTreeHeaderDataV1',
 );
diff --git a/account-compression/sdk/src/instructions/index.ts b/account-compression/sdk/src/instructions/index.ts
index 150acfea3b8..0f4b8cdc052 100644
--- a/account-compression/sdk/src/instructions/index.ts
+++ b/account-compression/sdk/src/instructions/index.ts
@@ -3,9 +3,12 @@ import { Connection, PublicKey, SystemProgram, TransactionInstruction } from '@s
 import { getConcurrentMerkleTreeAccountSize } from '../accounts';
 import { SPL_NOOP_PROGRAM_ID, ValidDepthSizePair } from '../constants';
 import {
+    createAppendCanopyNodesInstruction,
     createAppendInstruction,
     createCloseEmptyTreeInstruction,
     createInitEmptyMerkleTreeInstruction,
+    createInitPreparedTreeWithRootInstruction,
+    createPrepareBatchMerkleTreeInstruction,
     createReplaceLeafInstruction,
     createTransferAuthorityInstruction,
     createVerifyLeafInstruction,
@@ -53,6 +56,94 @@ export function createInitEmptyMerkleTreeIx(
     );
 }
 
+/**
+ * (Devnet only) Helper function for {@link createPrepareBatchMerkleTreeInstruction}
+ * @param merkleTree
+ * @param authority
+ * @param depthSizePair
+ * @returns
+ */
+export function prepareTreeIx(
+    merkleTree: PublicKey,
+    authority: PublicKey,
+    depthSizePair: ValidDepthSizePair,
+): TransactionInstruction {
+    return createPrepareBatchMerkleTreeInstruction(
+        {
+            authority: authority,
+            merkleTree,
+            noop: SPL_NOOP_PROGRAM_ID,
+        },
+        depthSizePair,
+    );
+}
+
+/**
+ * (Devnet only) Helper function for {@link createAppendCanopyNodesInstruction}
+ * @param merkleTree
+ * @param authority
+ * @param canopyNodes
+ * @param startIndex
+ * @returns
+ */
+export function createAppendCanopyNodesIx(
+    merkleTree: PublicKey,
+    authority: PublicKey,
+    canopyNodes: ArrayLike<number>[] | Buffer[],
+    startIndex: number,
+): TransactionInstruction {
+    return createAppendCanopyNodesInstruction(
+        {
+            authority,
+            merkleTree,
+            noop: SPL_NOOP_PROGRAM_ID,
+        },
+        {
+            canopyNodes: canopyNodes.map(node => Array.from(node)),
+            startIndex,
+        },
+    );
+}
+
+/**
+ * (Devnet only) Helper function for {@link createInitPreparedTreeWithRootInstruction}
+ * @param merkleTree
+ * @param authority
+ * @param root
+ * @param rightmostLeaf
+ * @param rightmostIndex
+ * @param proof
+ * @returns
+ */
+export function createInitPreparedTreeWithRootIx(
+    merkleTree: PublicKey,
+    authority: PublicKey,
+    root: ArrayLike<number> | Buffer,
+    rightmostLeaf: ArrayLike<number> | Buffer,
+    rightmostIndex: number,
+    proof: Buffer[],
+): TransactionInstruction {
+    return createInitPreparedTreeWithRootInstruction(
+        {
+            anchorRemainingAccounts: proof.map(node => {
+                return {
+                    isSigner: false,
+                    isWritable: false,
+                    pubkey: new PublicKey(node),
+                };
+            }),
+            authority,
+            merkleTree,
+            noop: SPL_NOOP_PROGRAM_ID,
+        },
+        {
+            rightmostIndex,
+            rightmostLeaf: Array.from(rightmostLeaf),
+            root: Array.from(root),
+        },
+    );
+}
+
 /**
  * Helper function for {@link createReplaceLeafInstruction}
  * @param merkleTree
diff --git a/account-compression/sdk/tests/accountCompression.test.ts b/account-compression/sdk/tests/accountCompression.test.ts
index 3a6d996d021..deb7a2e3173 100644
--- a/account-compression/sdk/tests/accountCompression.test.ts
+++ b/account-compression/sdk/tests/accountCompression.test.ts
@@ -1,22 +1,28 @@
 import { strict as assert } from 'node:assert';
 
-import { AnchorProvider } from '@project-serum/anchor';
-import NodeWallet from '@project-serum/anchor/dist/cjs/nodewallet';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import NodeWallet from '@coral-xyz/anchor/dist/cjs/nodewallet';
 import { Connection, Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { BN } from 'bn.js';
 import * as crypto from 'crypto';
 
 import {
     ConcurrentMerkleTreeAccount,
+    createAppendCanopyNodesIx,
     createAppendIx,
     createCloseEmptyTreeInstruction,
+    createCloseEmptyTreeIx,
+    createInitEmptyMerkleTreeIx,
+    createInitPreparedTreeWithRootIx,
     createReplaceIx,
     createTransferAuthorityIx,
     createVerifyLeafIx,
+    prepareTreeIx,
     ValidDepthSizePair,
 } from '../src';
 import { hash, MerkleTree } from '../src/merkle-tree';
-import { createTreeOnChain, execute } from './utils';
+import { assertCMTProperties } from './accounts/concurrentMerkleTreeAccount.test';
+import { createTreeOnChain, execute, prepareTree } from './utils';
 
 // eslint-disable-next-line no-empty
 describe('Account Compression', () => {
@@ -50,10 +56,551 @@ describe('Account Compression', () => {
 
         await provider.connection.confirmTransaction(
             await provider.connection.requestAirdrop(payer, 1e10),
-            'confirmed'
+            'confirmed',
         );
     });
 
+    describe('Having prepared a tree without canopy', () => {
+        const depth = 3;
+        const size = 8;
+        const canopyDepth = 0;
+        const leaves = [
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+        ];
+        let anotherKeyPair: Keypair;
+        let another: PublicKey;
+
+        beforeEach(async () => {
+            const cmtKeypair = await prepareTree({
+                canopyDepth,
+                depthSizePair: {
+                    maxBufferSize: size,
+                    maxDepth: depth,
+                },
+                payer: payerKeypair,
+                provider,
+            });
+            cmt = cmtKeypair.publicKey;
+            anotherKeyPair = Keypair.generate();
+            another = anotherKeyPair.publicKey;
+            await provider.connection.confirmTransaction(
+                await provider.connection.requestAirdrop(another, 1e10),
+                'confirmed',
+            );
+        });
+        it('Should be able to finalize the tree', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+            const canopyDepth = 0;
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+
+            await execute(provider, [finalize], [payerKeypair]);
+
+            const splCMT = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, cmt);
+            assertCMTProperties(splCMT, depth, size, payer, root, canopyDepth, true);
+            assert(splCMT.getBufferSize() == 1, 'Buffer size does not match');
+        });
+        it('Should fail to append canopy node for a tree without canopy', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 0);
+            try {
+                await execute(provider, [appendIx], [payerKeypair]);
+                assert(false, 'Canopy appending should have failed to execute for a tree without canopy');
+            } catch {}
+        });
+        it('Should fail to finalize the tree with another payer authority', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                another,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+
+            try {
+                await execute(provider, [finalize], [anotherKeyPair]);
+                assert(false, 'Finalizing with another payer should have failed');
+            } catch {}
+        });
+        it('Should fail to finalize the tree with a wrong proof', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+            // Replace valid proof with random bytes so it is wrong
+            const proof = merkleTreeRaw.getProof(leaves.length - 1);
+            proof.proof = proof.proof.map(_ => {
+                return crypto.randomBytes(32);
+            });
+
+            const finalize = createInitPreparedTreeWithRootIx(cmt, payer, root, leaf, leaves.length - 1, proof.proof);
+
+            try {
+                await execute(provider, [finalize], [payerKeypair]);
+                assert(false, 'Finalizing with a wrong proof should have failed');
+            } catch {}
+        });
+        it('Should fail to double finalize the tree', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+
+            await execute(provider, [finalize], [payerKeypair]);
+
+            try {
+                await execute(provider, [finalize], [payerKeypair]);
+                assert(false, 'Double finalizing should have failed');
+            } catch {}
+        });
+
+        it('Should be able to close a prepared tree', async () => {
+            let payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            let treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed')!;
+
+            const payerLamports = payerInfo!.lamports;
+            const treeLamports = treeInfo!.lamports;
+
+            const closeIx = createCloseEmptyTreeIx(cmt, payer, payer);
+            await execute(provider, [closeIx], [payerKeypair]);
+
+            payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            const finalLamports = payerInfo!.lamports;
+            assert(
+                finalLamports === payerLamports + treeLamports - 5000,
+                'Expected payer to have received the lamports from the closed tree account',
+            );
+
+            treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed');
+            assert(treeInfo === null, 'Expected the merkle tree account info to be null');
+        });
+    });
+    describe('Having prepared a tree with canopy', () => {
+        const depth = 3;
+        const size = 8;
+        const canopyDepth = 2;
+        const leaves = [
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+            crypto.randomBytes(32),
+        ];
+        let anotherKeyPair: Keypair;
+        let another: PublicKey;
+        beforeEach(async () => {
+            const cmtKeypair = await prepareTree({
+                canopyDepth,
+                depthSizePair: {
+                    maxBufferSize: size,
+                    maxDepth: depth,
+                },
+                payer: payerKeypair,
+                provider,
+            });
+            cmt = cmtKeypair.publicKey;
+            anotherKeyPair = Keypair.generate();
+            another = anotherKeyPair.publicKey;
+            await provider.connection.confirmTransaction(
+                await provider.connection.requestAirdrop(another, 1e10),
+                'confirmed',
+            );
+        });
+        it('Should be able to append a single canopy node', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 0);
+            await execute(provider, [appendIx], [payerKeypair]);
+        });
+        it('Should be able to append a single canopy node at the index more then 0', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 1);
+            await execute(provider, [appendIx], [payerKeypair]);
+        });
+        it('Should be able to append several canopy nodes at the start of the node leaves', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32), crypto.randomBytes(32)], 0);
+            await execute(provider, [appendIx], [payerKeypair]);
+        });
+        it('Should fail to append canopy node with another payer authority', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, another, [crypto.randomBytes(32)], 0);
+            try {
+                await execute(provider, [appendIx], [anotherKeyPair]);
+                assert(false, 'Appending with another payer should have failed');
+            } catch {}
+        });
+        it('Should fail to append canopy nodes over the limit', async () => {
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                Array.from({ length: 3 }, () => crypto.randomBytes(32)),
+                0,
+            );
+            try {
+                await execute(provider, [appendIx], [payerKeypair]);
+                assert(false, 'Appending over the limit should have failed');
+            } catch {}
+        });
+        it('Should fail to append canopy nodes over the limit starting from the last index', async () => {
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                Array.from({ length: 2 }, () => crypto.randomBytes(32)),
+                1,
+            );
+            try {
+                await execute(provider, [appendIx], [payerKeypair]);
+                assert(false, 'Appending over the limit should have failed');
+            } catch {}
+        });
+        it('Should fail to append 0 canopy nodes', async () => {
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [], 0);
+            try {
+                await execute(provider, [appendIx], [payerKeypair]);
+                assert(false, 'Appending 0 nodes should have failed');
+            } catch {}
+        });
+        it('Should fail to finalize the tree without canopy', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+
+            try {
+                await execute(provider, [finalize], [payerKeypair]);
+                assert(false, 'Finalizing without canopy should have failed');
+            } catch {}
+        });
+        it('Should fail to finalize the tree with an incomplete canopy', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [merkleTreeRaw.leaves[0].parent!.node!], 0);
+            await execute(provider, [appendIx], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+
+            try {
+                await execute(provider, [finalize], [payerKeypair]);
+                assert(false, 'Finalization for an incomplete canopy should have failed');
+            } catch {}
+        });
+        it('Should finalize the tree with a complete canopy', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            // take every second leaf and append it's parent node to the canopy
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves.filter((_, i) => i % 2 === 0).map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+            const splCMT = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, cmt);
+            assertCMTProperties(splCMT, depth, size, payer, root, canopyDepth, true);
+        });
+        it('Should be able to setup canopy with several transactions', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+            // take every second leaf of the first half of a tree and append it's parent node to the canopy
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(0, leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            // take every second leaf of the second half of a tree and append it's parent node to the canopy
+            const appendIx2 = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                2,
+            );
+            await execute(provider, [appendIx2], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+        });
+        it('Should be able to setup canopy with several transactions in reverse order', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                2,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            const appendIx2 = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(0, leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx2], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+        });
+        it('Should be able to replace a canopy node', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(0, leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            const appendIx2 = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 2);
+            await execute(provider, [appendIx2], [payerKeypair]);
+            const replaceIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                2,
+            );
+            await execute(provider, [replaceIx], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+        });
+        it('Should fail to replace a canopy node for a finalised tree', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves.filter((_, i) => i % 2 === 0).map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+            const replaceIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 0);
+            try {
+                await execute(provider, [replaceIx], [payerKeypair]);
+                assert(false, 'Replacing a canopy node for a finalised tree should have failed');
+            } catch {}
+        });
+        it('Should fail to initialize an empty tree after preparing a tree', async () => {
+            const ixs = [
+                createInitEmptyMerkleTreeIx(cmt, payer, {
+                    maxBufferSize: size,
+                    maxDepth: depth,
+                }),
+            ];
+            try {
+                await execute(provider, ixs, [payerKeypair]);
+                assert(false, 'Initializing an empty tree after preparing a tree should have failed');
+            } catch {}
+        });
+        it('Should be able to close a prepared tree after setting the canopy', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+
+            const appendIx = createAppendCanopyNodesIx(
+                cmt,
+                payer,
+                merkleTreeRaw.leaves
+                    .slice(0, leaves.length / 2)
+                    .filter((_, i) => i % 2 === 0)
+                    .map(leaf => leaf.parent!.node!),
+                0,
+            );
+            await execute(provider, [appendIx], [payerKeypair]);
+            let payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            let treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed')!;
+
+            const payerLamports = payerInfo!.lamports;
+            const treeLamports = treeInfo!.lamports;
+
+            const closeIx = createCloseEmptyTreeIx(cmt, payer, payer);
+            await execute(provider, [closeIx], [payerKeypair]);
+
+            payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            const finalLamports = payerInfo!.lamports;
+            assert(
+                finalLamports === payerLamports + treeLamports - 5000,
+                'Expected payer to have received the lamports from the closed tree account',
+            );
+
+            treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed');
+            assert(treeInfo === null, 'Expected the merkle tree account info to be null');
+        });
+    });
+    describe('Having prepared an empty tree with canopy', () => {
+        const depth = 3;
+        const size = 8;
+        const canopyDepth = 2;
+        // empty leaves represent the empty tree
+        const leaves = [
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+            Buffer.alloc(32),
+        ];
+        let anotherKeyPair: Keypair;
+        let another: PublicKey;
+        beforeEach(async () => {
+            const cmtKeypair = await prepareTree({
+                canopyDepth,
+                depthSizePair: {
+                    maxBufferSize: size,
+                    maxDepth: depth,
+                },
+                payer: payerKeypair,
+                provider,
+            });
+            cmt = cmtKeypair.publicKey;
+            anotherKeyPair = Keypair.generate();
+            another = anotherKeyPair.publicKey;
+            await provider.connection.confirmTransaction(
+                await provider.connection.requestAirdrop(another, 1e10),
+                'confirmed',
+            );
+        });
+
+        it('Should be able to finalize an empty tree with empty canopy and close it afterwards', async () => {
+            const merkleTreeRaw = new MerkleTree(leaves);
+            const root = merkleTreeRaw.root;
+            const leaf = leaves[leaves.length - 1];
+
+            const finalize = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                root,
+                leaf,
+                leaves.length - 1,
+                merkleTreeRaw.getProof(leaves.length - 1).proof,
+            );
+            await execute(provider, [finalize], [payerKeypair]);
+            let payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            let treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed')!;
+
+            const payerLamports = payerInfo!.lamports;
+            const treeLamports = treeInfo!.lamports;
+
+            const closeIx = createCloseEmptyTreeIx(cmt, payer, payer);
+            await execute(provider, [closeIx], [payerKeypair]);
+
+            payerInfo = await provider.connection.getAccountInfo(payer, 'confirmed')!;
+            const finalLamports = payerInfo!.lamports;
+            assert(
+                finalLamports === payerLamports + treeLamports - 5000,
+                'Expected payer to have received the lamports from the closed tree account',
+            );
+
+            treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed');
+            assert(treeInfo === null, 'Expected the merkle tree account info to be null');
+        });
+    });
+
     describe('Having created a tree with a single leaf', () => {
         beforeEach(async () => {
             [cmtKeypair, offChainTree] = await createTreeOnChain(provider, payerKeypair, 1, DEPTH_SIZE_PAIR);
@@ -71,7 +618,7 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root matches root of updated off chain tree'
+                'Updated on chain root matches root of updated off chain tree',
             );
         });
         it('Verify proof works for that leaf', async () => {
@@ -90,7 +637,7 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root matches root of updated off chain tree'
+                'Updated on chain root matches root of updated off chain tree',
             );
         });
         it('Verify leaf fails when proof fails', async () => {
@@ -121,7 +668,7 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root matches root of updated off chain tree'
+                'Updated on chain root matches root of updated off chain tree',
             );
         });
         it('Replace that leaf', async () => {
@@ -140,7 +687,7 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root matches root of updated off chain tree'
+                'Updated on chain root matches root of updated off chain tree',
             );
         });
 
@@ -159,9 +706,33 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root matches root of updated off chain tree'
+                'Updated on chain root matches root of updated off chain tree',
             );
         });
+
+        it('Should fail to prepare a batch ready tree for an existing tree', async () => {
+            const prepareIx = prepareTreeIx(cmt, payer, DEPTH_SIZE_PAIR);
+            try {
+                await execute(provider, [prepareIx], [payerKeypair]);
+                assert(false, 'Prepare a batch tree should have failed for the existing tree');
+            } catch {}
+        });
+
+        it('Should fail to finalize an existing tree', async () => {
+            const index = offChainTree.leaves.length - 1;
+            const finalizeIx = createInitPreparedTreeWithRootIx(
+                cmt,
+                payer,
+                offChainTree.root,
+                offChainTree.leaves[index].node,
+                index,
+                offChainTree.getProof(index).proof,
+            );
+            try {
+                await execute(provider, [finalizeIx], [payerKeypair]);
+                assert(false, 'Finalize an existing tree should have failed');
+            } catch {}
+        });
     });
 
     describe('Examples transferring authority', () => {
@@ -172,7 +743,7 @@ describe('Account Compression', () => {
 
         beforeEach(async () => {
             await provider.connection.confirmTransaction(
-                await (connection as Connection).requestAirdrop(authority, 1e10)
+                await (connection as Connection).requestAirdrop(authority, 1e10),
             );
             [cmtKeypair, offChainTree] = await createTreeOnChain(provider, authorityKeypair, 1, DEPTH_SIZE_PAIR);
             cmt = cmtKeypair.publicKey;
@@ -196,7 +767,7 @@ describe('Account Compression', () => {
 
             assert(
                 splCMT.getAuthority().equals(randomSigner),
-                `Upon transferring authority, authority should be ${randomSigner.toString()}, but was instead updated to ${splCMT.getAuthority()}`
+                `Upon transferring authority, authority should be ${randomSigner.toString()}, but was instead updated to ${splCMT.getAuthority()}`,
             );
 
             // Attempting to replace with new authority now works
@@ -245,7 +816,7 @@ describe('Account Compression', () => {
 
             assert(
                 Buffer.from(onChainRoot).equals(offChainTree.root),
-                'Updated on chain root does not match root of updated off chain tree'
+                'Updated on chain root does not match root of updated off chain tree',
             );
         });
         it('Empty all of the leaves and close the tree', async () => {
@@ -283,7 +854,7 @@ describe('Account Compression', () => {
             const finalLamports = payerInfo!.lamports;
             assert(
                 finalLamports === payerLamports + treeLamports - 5000,
-                'Expected payer to have received the lamports from the closed tree account'
+                'Expected payer to have received the lamports from the closed tree account',
             );
 
             treeInfo = await provider.connection.getAccountInfo(cmt, 'confirmed');
@@ -298,7 +869,7 @@ describe('Account Compression', () => {
             try {
                 await execute(provider, [ix], [payerKeypair]);
                 assert(false, 'Closing a tree account before it is empty should ALWAYS error');
-            } catch (e) {}
+            } catch {}
         });
     });
 
@@ -343,13 +914,13 @@ describe('Account Compression', () => {
             try {
                 await execute(provider, [replaceIx], [payerKeypair]);
                 assert(false, 'Attacker was able to successfully write fake existence of a leaf');
-            } catch (e) {}
+            } catch {}
 
             const splCMT = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, cmt);
 
             assert(
                 splCMT.getCurrentBufferIndex() === 0,
-                "CMT updated its active index after attacker's transaction, when it shouldn't have done anything"
+                "CMT updated its active index after attacker's transaction, when it shouldn't have done anything",
             );
         });
     });
@@ -361,7 +932,7 @@ describe('Account Compression', () => {
                 payerKeypair,
                 2 ** DEPTH,
                 { maxBufferSize: 8, maxDepth: DEPTH },
-                DEPTH // Store full tree on chain
+                DEPTH, // Store full tree on chain
             );
             cmt = cmtKeypair.publicKey;
 
@@ -391,7 +962,7 @@ describe('Account Compression', () => {
                 payerKeypair,
                 0,
                 { maxBufferSize: 8, maxDepth: DEPTH },
-                DEPTH // Store full tree on chain
+                DEPTH, // Store full tree on chain
             );
             cmt = cmtKeypair.publicKey;
 
@@ -476,6 +1047,22 @@ describe('Account Compression', () => {
                 await execute(provider, [replaceIx, replaceBackIx], [payerKeypair], true, true);
             }
         });
+
+        it('Should fail to append a canopy node for an existing tree', async () => {
+            [cmtKeypair, offChainTree] = await createTreeOnChain(
+                provider,
+                payerKeypair,
+                0,
+                { maxBufferSize: 8, maxDepth: DEPTH },
+                DEPTH, // Store full tree on chain
+            );
+            cmt = cmtKeypair.publicKey;
+            const appendIx = createAppendCanopyNodesIx(cmt, payer, [crypto.randomBytes(32)], 0);
+            try {
+                await execute(provider, [appendIx], [payerKeypair]);
+                assert(false, 'Appending a canopy node for an existing tree should have failed');
+            } catch {}
+        });
     });
     describe(`Having created a tree with 8 leaves`, () => {
         beforeEach(async () => {
@@ -503,7 +1090,7 @@ describe('Account Compression', () => {
             try {
                 await execute(provider, [replaceIx], [payerKeypair]);
                 throw Error('This replace instruction should have failed because the leaf index is OOB');
-            } catch (_e) {}
+            } catch {}
         });
     });
 });
diff --git a/account-compression/sdk/tests/accounts/concurrentMerkleTreeAccount.test.ts b/account-compression/sdk/tests/accounts/concurrentMerkleTreeAccount.test.ts
index 4c1658df208..5e85aaca0c9 100644
--- a/account-compression/sdk/tests/accounts/concurrentMerkleTreeAccount.test.ts
+++ b/account-compression/sdk/tests/accounts/concurrentMerkleTreeAccount.test.ts
@@ -1,37 +1,42 @@
 import { strict as assert } from 'node:assert';
 
-import { AnchorProvider } from '@project-serum/anchor';
-import NodeWallet from '@project-serum/anchor/dist/cjs/nodewallet';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import NodeWallet from '@coral-xyz/anchor/dist/cjs/nodewallet';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 
 import { ALL_DEPTH_SIZE_PAIRS, ConcurrentMerkleTreeAccount, getConcurrentMerkleTreeAccountSize } from '../../src';
 import { emptyNode, MerkleTree } from '../../src/merkle-tree';
 import { createEmptyTreeOnChain, createTreeOnChain } from '../utils';
 
-function assertCMTProperties(
+export function assertCMTProperties(
     onChainCMT: ConcurrentMerkleTreeAccount,
     expectedMaxDepth: number,
     expectedMaxBufferSize: number,
     expectedAuthority: PublicKey,
     expectedRoot: Buffer,
-    expectedCanopyDepth?: number
+    expectedCanopyDepth?: number,
+    expectedIsBatchInitialized = false,
 ) {
     assert(
         onChainCMT.getMaxDepth() === expectedMaxDepth,
-        `Max depth does not match ${onChainCMT.getMaxDepth()}, expected ${expectedMaxDepth}`
+        `Max depth does not match ${onChainCMT.getMaxDepth()}, expected ${expectedMaxDepth}`,
     );
     assert(
         onChainCMT.getMaxBufferSize() === expectedMaxBufferSize,
-        `Max buffer size does not match ${onChainCMT.getMaxBufferSize()}, expected ${expectedMaxBufferSize}`
+        `Max buffer size does not match ${onChainCMT.getMaxBufferSize()}, expected ${expectedMaxBufferSize}`,
     );
     assert(onChainCMT.getAuthority().equals(expectedAuthority), 'Failed to write auth pubkey');
     assert(onChainCMT.getCurrentRoot().equals(expectedRoot), 'On chain root does not match root passed in instruction');
     if (expectedCanopyDepth) {
         assert(
             onChainCMT.getCanopyDepth() === expectedCanopyDepth,
-            'On chain canopy depth does not match expected canopy depth'
+            'On chain canopy depth does not match expected canopy depth',
         );
     }
+    assert(
+        onChainCMT.getIsBatchInitialized() === expectedIsBatchInitialized,
+        'On chain isBatchInitialized does not match expected value',
+    );
 }
 
 describe('ConcurrentMerkleTreeAccount tests', () => {
@@ -57,7 +62,7 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
 
         await provider.connection.confirmTransaction(
             await provider.connection.requestAirdrop(payer, 1e10),
-            'confirmed'
+            'confirmed',
         );
     });
 
@@ -76,7 +81,7 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
             const cmt = await ConcurrentMerkleTreeAccount.fromAccountAddress(
                 connection,
                 cmtKeypair.publicKey,
-                'confirmed'
+                'confirmed',
             );
 
             await assertCMTProperties(cmt, MAX_DEPTH, MAX_SIZE, payer, offChainTree.root);
@@ -97,7 +102,7 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
                 const cmt = await ConcurrentMerkleTreeAccount.fromAccountAddress(
                     connection,
                     cmtKeypair.publicKey,
-                    'confirmed'
+                    'confirmed',
                 );
 
                 // Verify it was initialized correctly
@@ -106,7 +111,7 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
                     depthSizePair.maxDepth,
                     depthSizePair.maxBufferSize,
                     payer,
-                    emptyNode(depthSizePair.maxDepth)
+                    emptyNode(depthSizePair.maxDepth),
                 );
             }
         });
@@ -129,12 +134,12 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
                     provider,
                     payerKeypair,
                     { maxBufferSize, maxDepth },
-                    canopyDepth
+                    canopyDepth,
                 );
                 const cmt = await ConcurrentMerkleTreeAccount.fromAccountAddress(
                     connection,
                     cmtKeypair.publicKey,
-                    'confirmed'
+                    'confirmed',
                 );
 
                 // Verify it was initialized correctly
@@ -142,4 +147,30 @@ describe('ConcurrentMerkleTreeAccount tests', () => {
             }
         });
     });
+
+    describe('Can deserialize an existing CMTAccount from a real on-chain CMT created before the is_batch_initialized field was introduced inplace of the first byte of _padding', () => {
+        it('Interpreted on-chain fields correctly', async () => {
+            // The account data was generated by running:
+            //      $ solana account 27QMkDMpBoAhmWj6xxQNYdqXZL5nnC8tkZcEtkNxCqeX \
+            //                       --output-file tests/fixtures/pre-batch-init-tree-account.json \
+            //                       --output json
+            const deployedAccount = new PublicKey('27QMkDMpBoAhmWj6xxQNYdqXZL5nnC8tkZcEtkNxCqeX');
+            const cmt = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, deployedAccount, 'confirmed');
+            const expectedMaxDepth = 10;
+            const expectedMaxBufferSize = 32;
+            const expectedCanopyDepth = 0;
+            const expectedAuthority = new PublicKey('BFNT941iRwYPe2Js64dTJSoksGCptWAwrkKMaSN73XK2');
+            const expectedRoot = new PublicKey('83UjseEuEgxyVyDTmrJCQ9QbeksdRZ7KPDZGQYc5cAgF').toBuffer();
+            const expectedIsBatchInitialized = false;
+            await assertCMTProperties(
+                cmt,
+                expectedMaxDepth,
+                expectedMaxBufferSize,
+                expectedAuthority,
+                expectedRoot,
+                expectedCanopyDepth,
+                expectedIsBatchInitialized,
+            );
+        });
+    });
 });
diff --git a/account-compression/sdk/tests/events/applicationData.test.ts b/account-compression/sdk/tests/events/applicationData.test.ts
index 14a1f5a60ce..8f82490348d 100644
--- a/account-compression/sdk/tests/events/applicationData.test.ts
+++ b/account-compression/sdk/tests/events/applicationData.test.ts
@@ -1,27 +1,24 @@
-import { strict as assert } from "node:assert";
+import { strict as assert } from 'node:assert';
 
-import { BN } from "bn.js";
+import { BN } from 'bn.js';
 
-import { deserializeApplicationDataEvent } from "../../src";
+import { deserializeApplicationDataEvent } from '../../src';
 
-describe("Serde tests", () => {
-  describe("ApplicationDataEvent tests", () => {
-    it("Can serialize and deserialize ApplicationDataEvent", () => {
-      const data = Buffer.from("Hello world");
-      const applicationDataEvent = Buffer.concat([
-        Buffer.from([0x1]), // ApplicationData Event tag
-        Buffer.from([0x0]), // version 0 tag
-        Buffer.from(new BN.BN(data.length).toArray("le", 4)), // Size of application data (for Vec)
-        data, // serialized application data (for Vec)
-      ]);
+describe('Serde tests', () => {
+    describe('ApplicationDataEvent tests', () => {
+        it('Can serialize and deserialize ApplicationDataEvent', () => {
+            const data = Buffer.from('Hello world');
+            const applicationDataEvent = Buffer.concat([
+                Buffer.from([0x1]), // ApplicationData Event tag
+                Buffer.from([0x0]), // version 0 tag
+                Buffer.from(new BN.BN(data.length).toArray('le', 4)), // Size of application data (for Vec)
+                data, // serialized application data (for Vec)
+            ]);
 
-      const deserialized =
-        deserializeApplicationDataEvent(applicationDataEvent);
-      const decoder = new TextDecoder();
-      const deserializedData = decoder.decode(
-        deserialized.fields[0].applicationData
-      );
-      assert("Hello world" === deserializedData);
+            const deserialized = deserializeApplicationDataEvent(applicationDataEvent);
+            const decoder = new TextDecoder();
+            const deserializedData = decoder.decode(deserialized.fields[0].applicationData);
+            assert('Hello world' === deserializedData);
+        });
     });
-  });
 });
diff --git a/account-compression/sdk/tests/events/changelog.test.ts b/account-compression/sdk/tests/events/changelog.test.ts
index aa432493ddf..114e8a9d5f7 100644
--- a/account-compression/sdk/tests/events/changelog.test.ts
+++ b/account-compression/sdk/tests/events/changelog.test.ts
@@ -1,116 +1,100 @@
-import { strict as assert } from "node:assert";
+import { strict as assert } from 'node:assert';
 
-import { AnchorProvider } from "@project-serum/anchor";
-import NodeWallet from "@project-serum/anchor/dist/cjs/nodewallet";
-import { bs58 } from "@project-serum/anchor/dist/cjs/utils/bytes";
-import { Connection, Keypair, PublicKey } from "@solana/web3.js";
-import { BN } from "bn.js";
-import * as crypto from "crypto";
+import { AnchorProvider } from '@coral-xyz/anchor';
+import NodeWallet from '@coral-xyz/anchor/dist/cjs/nodewallet';
+import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { BN } from 'bn.js';
+import * as crypto from 'crypto';
 
-import {
-  createAppendIx,
-  deserializeChangeLogEventV1,
-  SPL_NOOP_PROGRAM_ID,
-} from "../../src";
-import { MerkleTree } from "../../src/merkle-tree";
-import { createTreeOnChain,execute } from "../utils";
+import { createAppendIx, deserializeChangeLogEventV1, SPL_NOOP_PROGRAM_ID } from '../../src';
+import { MerkleTree } from '../../src/merkle-tree';
+import { createTreeOnChain, execute } from '../utils';
 
-describe("Serde tests", () => {
-  let offChainTree: MerkleTree;
-  let cmtKeypair: Keypair;
-  let payerKeypair: Keypair;
-  let payer: PublicKey;
-  let connection: Connection;
-  let provider: AnchorProvider;
+describe('Serde tests', () => {
+    let offChainTree: MerkleTree;
+    let cmtKeypair: Keypair;
+    let payerKeypair: Keypair;
+    let payer: PublicKey;
+    let connection: Connection;
+    let provider: AnchorProvider;
 
-  const MAX_SIZE = 64;
-  const MAX_DEPTH = 14;
+    const MAX_SIZE = 64;
+    const MAX_DEPTH = 14;
 
-  beforeEach(async () => {
-    payerKeypair = Keypair.generate();
-    payer = payerKeypair.publicKey;
+    beforeEach(async () => {
+        payerKeypair = Keypair.generate();
+        payer = payerKeypair.publicKey;
 
-    connection = new Connection("http://127.0.0.1:8899", {
-      commitment: "confirmed",
-    });
-    const wallet = new NodeWallet(payerKeypair);
-    provider = new AnchorProvider(connection, wallet, {
-      commitment: connection.commitment,
-      skipPreflight: true,
-    });
+        connection = new Connection('http://127.0.0.1:8899', {
+            commitment: 'confirmed',
+        });
+        const wallet = new NodeWallet(payerKeypair);
+        provider = new AnchorProvider(connection, wallet, {
+            commitment: connection.commitment,
+            skipPreflight: true,
+        });
 
-    await provider.connection.confirmTransaction(
-      await provider.connection.requestAirdrop(payer, 1e10),
-      "confirmed"
-    );
-  });
-  describe("ChangeLogEvent tests", () => {
-    let cmt: PublicKey;
-    beforeEach(async () => {
-      [cmtKeypair, offChainTree] = await createTreeOnChain(
-        provider,
-        payerKeypair,
-        0,
-        { maxBufferSize: MAX_SIZE, maxDepth: MAX_DEPTH }
-      );
-      cmt = cmtKeypair.publicKey;
+        await provider.connection.confirmTransaction(
+            await provider.connection.requestAirdrop(payer, 1e10),
+            'confirmed',
+        );
     });
-    it("Can deserialize a ChangeLogEvent", async () => {
-      const newLeaf = crypto.randomBytes(32);
-      const txId = await execute(
-        provider,
-        [createAppendIx(cmt, payer, newLeaf)],
-        [payerKeypair]
-      );
-      offChainTree.updateLeaf(0, newLeaf);
+    describe('ChangeLogEvent tests', () => {
+        let cmt: PublicKey;
+        beforeEach(async () => {
+            [cmtKeypair, offChainTree] = await createTreeOnChain(provider, payerKeypair, 0, {
+                maxBufferSize: MAX_SIZE,
+                maxDepth: MAX_DEPTH,
+            });
+            cmt = cmtKeypair.publicKey;
+        });
+        it('Can deserialize a ChangeLogEvent', async () => {
+            const newLeaf = crypto.randomBytes(32);
+            const txId = await execute(provider, [createAppendIx(cmt, payer, newLeaf)], [payerKeypair]);
+            offChainTree.updateLeaf(0, newLeaf);
 
-      const transaction = await connection.getTransaction(txId, {
-        commitment: "confirmed",
-        maxSupportedTransactionVersion: 2,
-      });
+            const transaction = await connection.getTransaction(txId, {
+                commitment: 'confirmed',
+                maxSupportedTransactionVersion: 2,
+            });
 
-      // Get noop program instruction
-      const accountKeys = transaction!.transaction.message.getAccountKeys();
-      const noopInstruction =
-        transaction!.meta!.innerInstructions![0].instructions[0];
-      const programId = accountKeys.get(noopInstruction.programIdIndex)!;
-      if (!programId.equals(SPL_NOOP_PROGRAM_ID)) {
-        throw Error(
-          `Only inner ix should be a noop, but instead is a ${programId.toBase58()}`
-        );
-      }
-      const cpiData = Buffer.from(bs58.decode(noopInstruction.data));
-      const changeLogEvent = deserializeChangeLogEventV1(cpiData);
+            // Get noop program instruction
+            const accountKeys = transaction!.transaction.message.getAccountKeys();
+            const noopInstruction = transaction!.meta!.innerInstructions![0].instructions[0];
+            const programId = accountKeys.get(noopInstruction.programIdIndex)!;
+            if (!programId.equals(SPL_NOOP_PROGRAM_ID)) {
+                throw Error(`Only inner ix should be a noop, but instead is a ${programId.toBase58()}`);
+            }
+            const cpiData = Buffer.from(bs58.decode(noopInstruction.data));
+            const changeLogEvent = deserializeChangeLogEventV1(cpiData);
 
-      assert(
-        changeLogEvent.treeId.equals(cmt),
-        `Tree id in changeLog differs from expected tree ${cmt.toBase58()}`
-      );
-      assert(
-        changeLogEvent.index === 0,
-        `ChangeLog should have index 0, but has index ${changeLogEvent.index}`
-      );
-      assert(
-        new BN.BN(changeLogEvent.seq).toNumber() === 1,
-        `ChangeLog should have sequence number of 1, but has seq number of ${changeLogEvent.seq.toString()}`
-      );
+            assert(
+                changeLogEvent.treeId.equals(cmt),
+                `Tree id in changeLog differs from expected tree ${cmt.toBase58()}`,
+            );
+            assert(changeLogEvent.index === 0, `ChangeLog should have index 0, but has index ${changeLogEvent.index}`);
+            assert(
+                new BN.BN(changeLogEvent.seq).toNumber() === 1,
+                `ChangeLog should have sequence number of 1, but has seq number of ${changeLogEvent.seq.toString()}`,
+            );
 
-      // Check that the emitted ChangeLog path matches up with the updated Tree
-      let nodeIndex = 0 + (1 << MAX_DEPTH);
-      let realTreeNode = offChainTree.leaves[0];
-      while (nodeIndex > 0) {
-        const clNode = changeLogEvent.path.shift()!;
-        assert(
-          nodeIndex === clNode.index,
-          `Expected changeLog index to be ${nodeIndex} but is ${clNode.index}`
-        );
-        assert(
-          realTreeNode!.node.equals(Buffer.from(clNode.node)),
-          `ChangeLog node differs at node index: ${clNode.index}`
-        );
-        realTreeNode = realTreeNode.parent!;
-        nodeIndex = nodeIndex >> 1;
-      }
+            // Check that the emitted ChangeLog path matches up with the updated Tree
+            let nodeIndex = 0 + (1 << MAX_DEPTH);
+            let realTreeNode = offChainTree.leaves[0];
+            while (nodeIndex > 0) {
+                const clNode = changeLogEvent.path.shift()!;
+                assert(
+                    nodeIndex === clNode.index,
+                    `Expected changeLog index to be ${nodeIndex} but is ${clNode.index}`,
+                );
+                assert(
+                    realTreeNode!.node.equals(Buffer.from(clNode.node)),
+                    `ChangeLog node differs at node index: ${clNode.index}`,
+                );
+                realTreeNode = realTreeNode.parent!;
+                nodeIndex = nodeIndex >> 1;
+            }
+        });
     });
-  });
 });
diff --git a/account-compression/sdk/tests/fixtures/pre-batch-init-tree-account.json b/account-compression/sdk/tests/fixtures/pre-batch-init-tree-account.json
new file mode 100644
index 00000000000..98adaa774dc
--- /dev/null
+++ b/account-compression/sdk/tests/fixtures/pre-batch-init-tree-account.json
@@ -0,0 +1,14 @@
+{
+  "pubkey": "27QMkDMpBoAhmWj6xxQNYdqXZL5nnC8tkZcEtkNxCqeX",
+  "account": {
+    "lamports": 84132480,
+    "data": [
+      "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",
+      "base64"
+    ],
+    "owner": "cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK",
+    "executable": false,
+    "rentEpoch": 18446744073709551615,
+    "space": 11960
+  }
+}
\ No newline at end of file
diff --git a/account-compression/sdk/tests/merkleTree.test.ts b/account-compression/sdk/tests/merkleTree.test.ts
index f2e4814f363..1ecc6763b2d 100644
--- a/account-compression/sdk/tests/merkleTree.test.ts
+++ b/account-compression/sdk/tests/merkleTree.test.ts
@@ -1,35 +1,31 @@
-import { strict as assert } from "node:assert";
+import { strict as assert } from 'node:assert';
 
-import * as crypto from "crypto";
+import * as crypto from 'crypto';
 
-import { emptyNode, MerkleTree } from "../src";
+import { emptyNode, MerkleTree } from '../src';
 
-describe("MerkleTree tests", () => {
-  it("Check constructor equivalence for depth 2 tree", () => {
-    const leaves = [
-      crypto.randomBytes(32),
-      crypto.randomBytes(32),
-      crypto.randomBytes(32),
-    ];
-    const rawLeaves = leaves.concat(emptyNode(0));
-    const merkleTreeRaw = new MerkleTree(rawLeaves);
-    const merkleTreeSparse = MerkleTree.sparseMerkleTreeFromLeaves(leaves, 2);
+describe('MerkleTree tests', () => {
+    it('Check constructor equivalence for depth 2 tree', () => {
+        const leaves = [crypto.randomBytes(32), crypto.randomBytes(32), crypto.randomBytes(32)];
+        const rawLeaves = leaves.concat(emptyNode(0));
+        const merkleTreeRaw = new MerkleTree(rawLeaves);
+        const merkleTreeSparse = MerkleTree.sparseMerkleTreeFromLeaves(leaves, 2);
 
-    assert(merkleTreeRaw.root.equals(merkleTreeSparse.root));
-  });
+        assert(merkleTreeRaw.root.equals(merkleTreeSparse.root));
+    });
 
-  const TEST_DEPTH = 14;
-  it(`Check proofs for 2^${TEST_DEPTH} tree`, () => {
-    const leaves: Buffer[] = [];
-    for (let i = 0; i < 2 ** TEST_DEPTH; i++) {
-      leaves.push(crypto.randomBytes(32));
-    }
-    const merkleTree = new MerkleTree(leaves);
+    const TEST_DEPTH = 14;
+    it(`Check proofs for 2^${TEST_DEPTH} tree`, () => {
+        const leaves: Buffer[] = [];
+        for (let i = 0; i < 2 ** TEST_DEPTH; i++) {
+            leaves.push(crypto.randomBytes(32));
+        }
+        const merkleTree = new MerkleTree(leaves);
 
-    // Check proofs
-    for (let i = 0; i < leaves.length; i++) {
-      const proof = merkleTree.getProof(i);
-      assert(MerkleTree.verify(merkleTree.getRoot(), proof));
-    }
-  });
+        // Check proofs
+        for (let i = 0; i < leaves.length; i++) {
+            const proof = merkleTree.getProof(i);
+            assert(MerkleTree.verify(merkleTree.getRoot(), proof));
+        }
+    });
 });
diff --git a/account-compression/sdk/tests/utils.ts b/account-compression/sdk/tests/utils.ts
index d57c297ce3f..4e49c305c71 100644
--- a/account-compression/sdk/tests/utils.ts
+++ b/account-compression/sdk/tests/utils.ts
@@ -1,15 +1,21 @@
-import { AnchorProvider } from '@project-serum/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
 import { Keypair, SendTransactionError, Signer, Transaction, TransactionInstruction } from '@solana/web3.js';
 import * as crypto from 'crypto';
 
-import { createAllocTreeIx, createAppendIx, createInitEmptyMerkleTreeIx, ValidDepthSizePair } from '../src';
+import {
+    createAllocTreeIx,
+    createAppendIx,
+    createInitEmptyMerkleTreeIx,
+    prepareTreeIx,
+    ValidDepthSizePair,
+} from '../src';
 import { MerkleTree } from '../src/merkle-tree';
 
 /// Wait for a transaction of a certain id to confirm and optionally log its messages
 export async function confirmAndLogTx(provider: AnchorProvider, txId: string, verbose = false) {
     const tx = await provider.connection.confirmTransaction(txId, 'confirmed');
     if (tx.value.err || verbose) {
-        console.log((await provider.connection.getConfirmedTransaction(txId, 'confirmed'))!.meta!.logMessages);
+        console.log((await provider.connection.getTransaction(txId, { commitment: 'confirmed' }))!.meta!.logMessages);
     }
     if (tx.value.err) {
         console.log('Transaction failed');
@@ -23,7 +29,7 @@ export async function execute(
     instructions: TransactionInstruction[],
     signers: Signer[],
     skipPreflight = false,
-    verbose = false
+    verbose = false,
 ): Promise<string> {
     let tx = new Transaction();
     instructions.map(ix => {
@@ -38,12 +44,12 @@ export async function execute(
     } catch (e) {
         if (e instanceof SendTransactionError) {
             console.log('Tx error!', e.logs);
-	}
+        }
         throw e;
     }
 
     if (verbose && txid) {
-        console.log((await provider.connection.getConfirmedTransaction(txid, 'confirmed'))!.meta!.logMessages);
+        console.log((await provider.connection.getTransaction(txid, { commitment: 'confirmed' }))!.meta!.logMessages);
     }
 
     return txid;
@@ -54,7 +60,7 @@ export async function createTreeOnChain(
     payer: Keypair,
     numLeaves: number,
     depthSizePair: ValidDepthSizePair,
-    canopyDepth = 0
+    canopyDepth = 0,
 ): Promise<[Keypair, MerkleTree]> {
     const cmtKeypair = Keypair.generate();
 
@@ -69,7 +75,7 @@ export async function createTreeOnChain(
         cmtKeypair.publicKey,
         payer.publicKey,
         depthSizePair,
-        canopyDepth
+        canopyDepth,
     );
 
     const ixs = [allocAccountIx, createInitEmptyMerkleTreeIx(cmtKeypair.publicKey, payer.publicKey, depthSizePair)];
@@ -97,7 +103,7 @@ export async function createEmptyTreeOnChain(
     provider: AnchorProvider,
     payer: Keypair,
     depthSizePair: ValidDepthSizePair,
-    canopyDepth = 0
+    canopyDepth = 0,
 ): Promise<Keypair> {
     const cmtKeypair = Keypair.generate();
     const allocAccountIx = await createAllocTreeIx(
@@ -105,7 +111,7 @@ export async function createEmptyTreeOnChain(
         cmtKeypair.publicKey,
         payer.publicKey,
         depthSizePair,
-        canopyDepth
+        canopyDepth,
     );
 
     const ixs = [allocAccountIx, createInitEmptyMerkleTreeIx(cmtKeypair.publicKey, payer.publicKey, depthSizePair)];
@@ -115,3 +121,28 @@ export async function createEmptyTreeOnChain(
 
     return cmtKeypair;
 }
+
+export type PrepareTreeArgs = {
+    canopyDepth: number;
+    depthSizePair: ValidDepthSizePair;
+    payer: Keypair;
+    provider: AnchorProvider;
+};
+
+export async function prepareTree(args: PrepareTreeArgs): Promise<Keypair> {
+    const { provider, payer, depthSizePair, canopyDepth } = args;
+    const cmtKeypair = Keypair.generate();
+    const allocAccountIx = await createAllocTreeIx(
+        provider.connection,
+        cmtKeypair.publicKey,
+        payer.publicKey,
+        depthSizePair,
+        canopyDepth,
+    );
+
+    const ixs = [allocAccountIx, prepareTreeIx(cmtKeypair.publicKey, payer.publicKey, depthSizePair)];
+
+    const txId = await execute(provider, ixs, [payer, cmtKeypair]);
+    await confirmAndLogTx(provider, txId as string);
+    return cmtKeypair;
+}
diff --git a/associated-token-account/README.md b/associated-token-account/README.md
new file mode 100644
index 00000000000..5ed8fdcbbe1
--- /dev/null
+++ b/associated-token-account/README.md
@@ -0,0 +1,2 @@
+NOTE: The associated-token-account program and clients are now maintained at
+[solana-program/associated-token-account](https://github.com/solana-program/associated-token-account).
diff --git a/associated-token-account/program-test/Cargo.toml b/associated-token-account/program-test/Cargo.toml
deleted file mode 100644
index dc10bce2a75..00000000000
--- a/associated-token-account/program-test/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL Associated Token Account Program Tests"
-edition = "2021"
-license = "Apache-2.0"
-name = "spl-associated-token-account-test"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "0.0.1"
-
-[features]
-test-sbf = []
-
-[dev-dependencies]
-solana-program = ">=1.18.11,<=2"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "3.0.2", path = "../program", features = ["no-entrypoint"] }
-spl-token = { version = "4.0", path = "../../token/program", features = ["no-entrypoint"] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
diff --git a/associated-token-account/program-test/tests/create_idempotent.rs b/associated-token-account/program-test/tests/create_idempotent.rs
deleted file mode 100644
index 2e54f1c3abe..00000000000
--- a/associated-token-account/program-test/tests/create_idempotent.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-
-use {
-    program_test::program_test_2022,
-    solana_program::{instruction::*, pubkey::Pubkey},
-    solana_program_test::*,
-    solana_sdk::{
-        account::Account as SolanaAccount,
-        program_option::COption,
-        program_pack::Pack,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction::create_account,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_associated_token_account::{
-        error::AssociatedTokenAccountError,
-        get_associated_token_address_with_program_id,
-        instruction::{
-            create_associated_token_account, create_associated_token_account_idempotent,
-        },
-    },
-    spl_token_2022::{
-        extension::ExtensionType,
-        instruction::initialize_account,
-        state::{Account, AccountState},
-    },
-};
-
-#[tokio::test]
-async fn success_account_exists() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let expected_token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    let instruction = create_associated_token_account_idempotent(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account now exists
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len);
-    assert_eq!(associated_account.owner, spl_token_2022::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-
-    // Unchecked instruction fails
-    let instruction = create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::IllegalOwner)
-    );
-
-    // Get a new blockhash, succeed with create if non existent
-    let recent_blockhash = banks_client
-        .get_new_latest_blockhash(&recent_blockhash)
-        .await
-        .unwrap();
-
-    let instruction = create_associated_token_account_idempotent(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account is unchanged
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len);
-    assert_eq!(associated_account.owner, spl_token_2022::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-}
-
-#[tokio::test]
-async fn fail_account_exists_with_wrong_owner() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let wrong_owner = Pubkey::new_unique();
-    let mut associated_token_account =
-        SolanaAccount::new(1_000_000_000, Account::LEN, &spl_token_2022::id());
-    let token_account = Account {
-        mint: token_mint_address,
-        owner: wrong_owner,
-        amount: 0,
-        delegate: COption::None,
-        state: AccountState::Initialized,
-        is_native: COption::None,
-        delegated_amount: 0,
-        close_authority: COption::None,
-    };
-    Account::pack(token_account, &mut associated_token_account.data).unwrap();
-    let mut pt = program_test_2022(token_mint_address, true);
-    pt.add_account(associated_token_address, associated_token_account);
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    // fail creating token account if non existent
-    let instruction = create_associated_token_account_idempotent(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(AssociatedTokenAccountError::InvalidOwner as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_non_ata() {
-    let token_mint_address = Pubkey::new_unique();
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let token_account_balance = rent.minimum_balance(token_account_len);
-
-    let wallet_address = Pubkey::new_unique();
-    let account = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            create_account(
-                &payer.pubkey(),
-                &account.pubkey(),
-                token_account_balance,
-                token_account_len as u64,
-                &spl_token_2022::id(),
-            ),
-            initialize_account(
-                &spl_token_2022::id(),
-                &account.pubkey(),
-                &token_mint_address,
-                &wallet_address,
-            )
-            .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[&payer, &account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let mut instruction = create_associated_token_account_idempotent(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    instruction.accounts[1] = AccountMeta::new(account.pubkey(), false); // <-- Invalid associated_account_address
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-    );
-}
diff --git a/associated-token-account/program-test/tests/extended_mint.rs b/associated-token-account/program-test/tests/extended_mint.rs
deleted file mode 100644
index 747644814b9..00000000000
--- a/associated-token-account/program-test/tests/extended_mint.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-// Mark this test as BPF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-
-use {
-    program_test::program_test_2022,
-    solana_program::{instruction::*, pubkey::Pubkey, system_instruction},
-    solana_program_test::*,
-    solana_sdk::{
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_associated_token_account::{
-        get_associated_token_address_with_program_id, instruction::create_associated_token_account,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            transfer_fee, BaseStateWithExtensions, ExtensionType, StateWithExtensionsOwned,
-        },
-        state::{Account, Mint},
-    },
-};
-
-#[tokio::test]
-async fn test_associated_token_account_with_transfer_fees() {
-    let wallet_sender = Keypair::new();
-    let wallet_address_sender = wallet_sender.pubkey();
-    let wallet_address_receiver = Pubkey::new_unique();
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(Pubkey::new_unique(), true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-
-    // create extended mint
-    // ... in the future, a mint can be pre-loaded in program_test.rs like the
-    // regular mint
-    let mint_account = Keypair::new();
-    let token_mint_address = mint_account.pubkey();
-    let mint_authority = Keypair::new();
-    let space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::TransferFeeConfig])
-            .unwrap();
-    let maximum_fee = 100;
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &mint_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &spl_token_2022::id(),
-            ),
-            transfer_fee::instruction::initialize_transfer_fee_config(
-                &spl_token_2022::id(),
-                &token_mint_address,
-                Some(&mint_authority.pubkey()),
-                Some(&mint_authority.pubkey()),
-                1_000,
-                maximum_fee,
-            )
-            .unwrap(),
-            spl_token_2022::instruction::initialize_mint(
-                &spl_token_2022::id(),
-                &token_mint_address,
-                &mint_authority.pubkey(),
-                Some(&mint_authority.pubkey()),
-                0,
-            )
-            .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &mint_account], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // create extended ATAs
-    let mut transaction = Transaction::new_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address_sender,
-            &token_mint_address,
-            &spl_token_2022::id(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let recent_blockhash = banks_client
-        .get_new_latest_blockhash(&recent_blockhash)
-        .await
-        .unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address_receiver,
-            &token_mint_address,
-            &spl_token_2022::id(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let associated_token_address_sender = get_associated_token_address_with_program_id(
-        &wallet_address_sender,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    let associated_token_address_receiver = get_associated_token_address_with_program_id(
-        &wallet_address_receiver,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    // mint tokens
-    let sender_amount = 50 * maximum_fee;
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_token_2022::instruction::mint_to(
-            &spl_token_2022::id(),
-            &token_mint_address,
-            &associated_token_address_sender,
-            &mint_authority.pubkey(),
-            &[],
-            sender_amount,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &mint_authority], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // not enough tokens
-    let mut transaction = Transaction::new_with_payer(
-        &[transfer_fee::instruction::transfer_checked_with_fee(
-            &spl_token_2022::id(),
-            &associated_token_address_sender,
-            &token_mint_address,
-            &associated_token_address_receiver,
-            &wallet_address_sender,
-            &[],
-            10_001,
-            0,
-            maximum_fee,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &wallet_sender], recent_blockhash);
-    let err = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenError::InsufficientFunds as u32)
-        )
-    );
-
-    let recent_blockhash = banks_client
-        .get_new_latest_blockhash(&recent_blockhash)
-        .await
-        .unwrap();
-
-    // success
-    let transfer_amount = 500;
-    let fee = 50;
-    let mut transaction = Transaction::new_with_payer(
-        &[transfer_fee::instruction::transfer_checked_with_fee(
-            &spl_token_2022::id(),
-            &associated_token_address_sender,
-            &token_mint_address,
-            &associated_token_address_receiver,
-            &wallet_address_sender,
-            &[],
-            transfer_amount,
-            0,
-            fee,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &wallet_sender], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let sender_account = banks_client
-        .get_account(associated_token_address_sender)
-        .await
-        .unwrap()
-        .unwrap();
-    let sender_state = StateWithExtensionsOwned::<Account>::unpack(sender_account.data).unwrap();
-    assert_eq!(sender_state.base.amount, sender_amount - transfer_amount);
-    let extension = sender_state
-        .get_extension::<transfer_fee::TransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-
-    let receiver_account = banks_client
-        .get_account(associated_token_address_receiver)
-        .await
-        .unwrap()
-        .unwrap();
-    let receiver_state =
-        StateWithExtensionsOwned::<Account>::unpack(receiver_account.data).unwrap();
-    assert_eq!(receiver_state.base.amount, transfer_amount - fee);
-    let extension = receiver_state
-        .get_extension::<transfer_fee::TransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, fee.into());
-}
diff --git a/associated-token-account/program-test/tests/fixtures/token-mint-data.bin b/associated-token-account/program-test/tests/fixtures/token-mint-data.bin
deleted file mode 100644
index 4a48512c02a..00000000000
Binary files a/associated-token-account/program-test/tests/fixtures/token-mint-data.bin and /dev/null differ
diff --git a/associated-token-account/program-test/tests/process_create_associated_token_account.rs b/associated-token-account/program-test/tests/process_create_associated_token_account.rs
deleted file mode 100644
index f535d661c1f..00000000000
--- a/associated-token-account/program-test/tests/process_create_associated_token_account.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-// Mark this test as BPF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-
-use {
-    program_test::program_test_2022,
-    solana_program::{instruction::*, pubkey::Pubkey, system_instruction, sysvar},
-    solana_program_test::*,
-    solana_sdk::{
-        signature::Signer,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_associated_token_account::{
-        get_associated_token_address_with_program_id, instruction::create_associated_token_account,
-    },
-    spl_token_2022::{extension::ExtensionType, state::Account},
-};
-
-#[tokio::test]
-async fn test_associated_token_address() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-
-    let expected_token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Associated account does not exist
-    assert_eq!(
-        banks_client
-            .get_account(associated_token_address)
-            .await
-            .expect("get_account"),
-        None,
-    );
-
-    let mut transaction = Transaction::new_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address,
-            &token_mint_address,
-            &spl_token_2022::id(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account now exists
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len,);
-    assert_eq!(associated_account.owner, spl_token_2022::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-}
-
-#[tokio::test]
-async fn test_create_with_fewer_lamports() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let expected_token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Transfer lamports into `associated_token_address` before creating it - enough
-    // to be rent-exempt for 0 data, but not for an initialized token account
-    let mut transaction = Transaction::new_with_payer(
-        &[system_instruction::transfer(
-            &payer.pubkey(),
-            &associated_token_address,
-            rent.minimum_balance(0),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert_eq!(
-        banks_client
-            .get_balance(associated_token_address)
-            .await
-            .unwrap(),
-        rent.minimum_balance(0)
-    );
-
-    // Check that the program adds the extra lamports
-    let mut transaction = Transaction::new_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address,
-            &token_mint_address,
-            &spl_token_2022::id(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert_eq!(
-        banks_client
-            .get_balance(associated_token_address)
-            .await
-            .unwrap(),
-        expected_token_account_balance,
-    );
-}
-
-#[tokio::test]
-async fn test_create_with_excess_lamports() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-
-    let expected_token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Transfer 1 lamport into `associated_token_address` before creating it
-    let mut transaction = Transaction::new_with_payer(
-        &[system_instruction::transfer(
-            &payer.pubkey(),
-            &associated_token_address,
-            expected_token_account_balance + 1,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert_eq!(
-        banks_client
-            .get_balance(associated_token_address)
-            .await
-            .unwrap(),
-        expected_token_account_balance + 1
-    );
-
-    // Check that the program doesn't add any lamports
-    let mut transaction = Transaction::new_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address,
-            &token_mint_address,
-            &spl_token_2022::id(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert_eq!(
-        banks_client
-            .get_balance(associated_token_address)
-            .await
-            .unwrap(),
-        expected_token_account_balance + 1
-    );
-}
-
-#[tokio::test]
-async fn test_create_account_mismatch() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let _associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-
-    let mut instruction = create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    instruction.accounts[1] = AccountMeta::new(Pubkey::default(), false); // <-- Invalid associated_account_address
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-    );
-
-    let mut instruction = create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    instruction.accounts[2] = AccountMeta::new(Pubkey::default(), false); // <-- Invalid wallet_address
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-    );
-
-    let mut instruction = create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-    instruction.accounts[3] = AccountMeta::new(Pubkey::default(), false); // <-- Invalid token_mint_address
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-    );
-}
-
-#[tokio::test]
-async fn test_create_associated_token_account_using_legacy_implicit_instruction() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address = get_associated_token_address_with_program_id(
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test_2022(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let expected_token_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap();
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Associated account does not exist
-    assert_eq!(
-        banks_client
-            .get_account(associated_token_address)
-            .await
-            .expect("get_account"),
-        None,
-    );
-
-    let mut create_associated_token_account_ix = create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-        &spl_token_2022::id(),
-    );
-
-    // Use implicit  instruction and rent account to replicate the legacy invocation
-    create_associated_token_account_ix.data = vec![];
-    create_associated_token_account_ix
-        .accounts
-        .push(AccountMeta::new_readonly(sysvar::rent::id(), false));
-
-    let mut transaction =
-        Transaction::new_with_payer(&[create_associated_token_account_ix], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account now exists
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len);
-    assert_eq!(associated_account.owner, spl_token_2022::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-}
diff --git a/associated-token-account/program-test/tests/program_test.rs b/associated-token-account/program-test/tests/program_test.rs
deleted file mode 100644
index 7008931e7ef..00000000000
--- a/associated-token-account/program-test/tests/program_test.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use {
-    solana_program::pubkey::Pubkey,
-    solana_program_test::{ProgramTest, *},
-    spl_associated_token_account::{id, processor::process_instruction},
-};
-
-#[allow(dead_code)]
-pub fn program_test(token_mint_address: Pubkey, use_latest_spl_token: bool) -> ProgramTest {
-    let mut pc = ProgramTest::new(
-        "spl_associated_token_account",
-        id(),
-        processor!(process_instruction),
-    );
-
-    if use_latest_spl_token {
-        pc.prefer_bpf(false);
-        // TODO: Remove when spl-token is available by default in program-test
-        pc.add_program(
-            "spl_token",
-            spl_token::id(),
-            processor!(spl_token::processor::Processor::process),
-        );
-    }
-
-    // Add a token mint account
-    //
-    // The account data was generated by running:
-    //      $ solana account EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
-    //                       --output-file tests/fixtures/token-mint-data.bin
-    //
-    pc.add_account_with_file_data(
-        token_mint_address,
-        1461600,
-        spl_token::id(),
-        "token-mint-data.bin",
-    );
-
-    // Dial down the BPF compute budget to detect if the program gets bloated in the
-    // future
-    pc.set_compute_max_units(60_000);
-
-    pc
-}
-
-#[allow(dead_code)]
-pub fn program_test_2022(
-    token_mint_address: Pubkey,
-    use_latest_spl_token_2022: bool,
-) -> ProgramTest {
-    let mut pc = ProgramTest::new(
-        "spl_associated_token_account",
-        id(),
-        processor!(process_instruction),
-    );
-
-    if use_latest_spl_token_2022 {
-        pc.prefer_bpf(false);
-        // TODO: Remove when spl-token-2022 is available by default in program-test
-        pc.add_program(
-            "spl_token_2022",
-            spl_token_2022::id(),
-            processor!(spl_token_2022::processor::Processor::process),
-        );
-    }
-
-    // Add a token mint account
-    //
-    // The account data was generated by running:
-    //      $ solana account EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
-    //                       --output-file tests/fixtures/token-mint-data.bin
-    //
-    pc.add_account_with_file_data(
-        token_mint_address,
-        1461600,
-        spl_token_2022::id(),
-        "token-mint-data.bin",
-    );
-
-    // Dial down the BPF compute budget to detect if the program gets bloated in the
-    // future
-    pc.set_compute_max_units(50_000);
-
-    pc
-}
diff --git a/associated-token-account/program-test/tests/recover_nested.rs b/associated-token-account/program-test/tests/recover_nested.rs
deleted file mode 100644
index 86374a2eacc..00000000000
--- a/associated-token-account/program-test/tests/recover_nested.rs
+++ /dev/null
@@ -1,677 +0,0 @@
-// Mark this test as BPF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-
-use {
-    program_test::{program_test, program_test_2022},
-    solana_program::{pubkey::Pubkey, system_instruction},
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::{AccountMeta, InstructionError},
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_associated_token_account::{get_associated_token_address_with_program_id, instruction},
-    spl_token_2022::{
-        extension::{ExtensionType, StateWithExtensionsOwned},
-        state::{Account, Mint},
-    },
-};
-
-async fn create_mint(context: &mut ProgramTestContext, program_id: &Pubkey) -> (Pubkey, Keypair) {
-    let mint_account = Keypair::new();
-    let token_mint_address = mint_account.pubkey();
-    let mint_authority = Keypair::new();
-    let space = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &mint_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                program_id,
-            ),
-            spl_token_2022::instruction::initialize_mint(
-                program_id,
-                &token_mint_address,
-                &mint_authority.pubkey(),
-                Some(&mint_authority.pubkey()),
-                0,
-            )
-            .unwrap(),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_account],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-    (token_mint_address, mint_authority)
-}
-
-async fn create_associated_token_account(
-    context: &mut ProgramTestContext,
-    owner: &Pubkey,
-    mint: &Pubkey,
-    program_id: &Pubkey,
-) -> Pubkey {
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::create_associated_token_account(
-            &context.payer.pubkey(),
-            owner,
-            mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    get_associated_token_address_with_program_id(owner, mint, program_id)
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn try_recover_nested(
-    context: &mut ProgramTestContext,
-    program_id: &Pubkey,
-    nested_mint: Pubkey,
-    nested_mint_authority: Keypair,
-    nested_associated_token_address: Pubkey,
-    destination_token_address: Pubkey,
-    wallet: Keypair,
-    recover_transaction: Transaction,
-    expected_error: Option<InstructionError>,
-) {
-    let nested_account = context
-        .banks_client
-        .get_account(nested_associated_token_address)
-        .await
-        .unwrap()
-        .unwrap();
-    let lamports = nested_account.lamports;
-
-    // mint to nested account
-    let amount = 100;
-    let transaction = Transaction::new_signed_with_payer(
-        &[spl_token_2022::instruction::mint_to(
-            program_id,
-            &nested_mint,
-            &nested_associated_token_address,
-            &nested_mint_authority.pubkey(),
-            &[],
-            amount,
-        )
-        .unwrap()],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &nested_mint_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // transfer / close nested account
-    let result = context
-        .banks_client
-        .process_transaction(recover_transaction)
-        .await;
-
-    if let Some(expected_error) = expected_error {
-        let error = result.unwrap_err().unwrap();
-        assert_eq!(error, TransactionError::InstructionError(0, expected_error));
-    } else {
-        result.unwrap();
-        // nested account is gone
-        assert!(context
-            .banks_client
-            .get_account(nested_associated_token_address)
-            .await
-            .unwrap()
-            .is_none());
-        let destination_account = context
-            .banks_client
-            .get_account(destination_token_address)
-            .await
-            .unwrap()
-            .unwrap();
-        let destination_state =
-            StateWithExtensionsOwned::<Account>::unpack(destination_account.data).unwrap();
-        assert_eq!(destination_state.base.amount, amount);
-        let wallet_account = context
-            .banks_client
-            .get_account(wallet.pubkey())
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(wallet_account.lamports, lamports);
-    }
-}
-
-async fn check_same_mint(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &mint, program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &mint,
-        program_id,
-    )
-    .await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wallet.pubkey(),
-            &mint,
-            &mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        None,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn success_same_mint_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_same_mint(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn success_same_mint() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_same_mint(&mut context, &spl_token::id()).await;
-}
-
-async fn check_different_mints(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let (owner_mint, _owner_mint_authority) = create_mint(context, program_id).await;
-    let (nested_mint, nested_mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &owner_mint, program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &nested_mint,
-        program_id,
-    )
-    .await;
-    let destination_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &nested_mint, program_id).await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wallet.pubkey(),
-            &owner_mint,
-            &nested_mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        nested_mint,
-        nested_mint_authority,
-        nested_associated_token_address,
-        destination_token_address,
-        wallet,
-        transaction,
-        None,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn success_different_mints() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_different_mints(&mut context, &spl_token::id()).await;
-}
-
-#[tokio::test]
-async fn success_different_mints_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_different_mints(&mut context, &spl_token_2022::id()).await;
-}
-
-async fn check_missing_wallet_signature(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &mint, program_id).await;
-
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &mint,
-        program_id,
-    )
-    .await;
-
-    let mut recover = instruction::recover_nested(&wallet.pubkey(), &mint, &mint, program_id);
-    recover.accounts[5] = AccountMeta::new(wallet.pubkey(), false);
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[recover],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::MissingRequiredSignature),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_missing_wallet_signature_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_missing_wallet_signature(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn fail_missing_wallet_signature() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_missing_wallet_signature(&mut context, &spl_token::id()).await;
-}
-
-async fn check_wrong_signer(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let wrong_wallet = Keypair::new();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &mint, program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &mint,
-        program_id,
-    )
-    .await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wrong_wallet.pubkey(),
-            &mint,
-            &mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wrong_wallet,
-        transaction,
-        Some(InstructionError::IllegalOwner),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_wrong_signer_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_wrong_signer(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn fail_wrong_signer() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_wrong_signer(&mut context, &spl_token::id()).await;
-}
-
-async fn check_not_nested(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let wrong_wallet = Pubkey::new_unique();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &mint, program_id).await;
-    let nested_associated_token_address =
-        create_associated_token_account(context, &wrong_wallet, &mint, program_id).await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wallet.pubkey(),
-            &mint,
-            &mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::IllegalOwner),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_not_nested_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_not_nested(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn fail_not_nested() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_not_nested(&mut context, &spl_token::id()).await;
-}
-
-async fn check_wrong_address_derivation_owner(
-    context: &mut ProgramTestContext,
-    program_id: &Pubkey,
-) {
-    let wallet = Keypair::new();
-    let wrong_wallet = Pubkey::new_unique();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(context, &wallet.pubkey(), &mint, program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &mint,
-        program_id,
-    )
-    .await;
-
-    let wrong_owner_associated_token_address =
-        get_associated_token_address_with_program_id(&mint, &wrong_wallet, program_id);
-    let mut recover = instruction::recover_nested(&wallet.pubkey(), &mint, &mint, program_id);
-    recover.accounts[3] = AccountMeta::new(wrong_owner_associated_token_address, false);
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[recover],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        wrong_owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::InvalidSeeds),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_wrong_address_derivation_owner_2022() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_wrong_address_derivation_owner(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn fail_wrong_address_derivation_owner() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_wrong_address_derivation_owner(&mut context, &spl_token::id()).await;
-}
-
-async fn check_owner_account_does_not_exist(context: &mut ProgramTestContext, program_id: &Pubkey) {
-    let wallet = Keypair::new();
-    let (mint, mint_authority) = create_mint(context, program_id).await;
-
-    let owner_associated_token_address =
-        get_associated_token_address_with_program_id(&wallet.pubkey(), &mint, program_id);
-    let nested_associated_token_address = create_associated_token_account(
-        context,
-        &owner_associated_token_address,
-        &mint,
-        program_id,
-    )
-    .await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wallet.pubkey(),
-            &mint,
-            &mint,
-            program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        context,
-        program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::IllegalOwner),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_owner_account_does_not_exist() {
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    check_owner_account_does_not_exist(&mut context, &spl_token_2022::id()).await;
-}
-
-#[tokio::test]
-async fn fail_wrong_spl_token_program() {
-    let wallet = Keypair::new();
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let mut context = pt.start_with_context().await;
-    let program_id = spl_token_2022::id();
-    let wrong_program_id = spl_token::id();
-    let (mint, mint_authority) = create_mint(&mut context, &program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(&mut context, &wallet.pubkey(), &mint, &program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        &mut context,
-        &owner_associated_token_address,
-        &mint,
-        &program_id,
-    )
-    .await;
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::recover_nested(
-            &wallet.pubkey(),
-            &mint,
-            &mint,
-            &wrong_program_id,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        &mut context,
-        &program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::IllegalOwner),
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn fail_destination_not_wallet_ata() {
-    let wallet = Keypair::new();
-    let wrong_wallet = Pubkey::new_unique();
-    let dummy_mint = Pubkey::new_unique();
-    let pt = program_test_2022(dummy_mint, true);
-    let program_id = spl_token_2022::id();
-    let mut context = pt.start_with_context().await;
-    let (mint, mint_authority) = create_mint(&mut context, &program_id).await;
-
-    let owner_associated_token_address =
-        create_associated_token_account(&mut context, &wallet.pubkey(), &mint, &program_id).await;
-    let nested_associated_token_address = create_associated_token_account(
-        &mut context,
-        &owner_associated_token_address,
-        &mint,
-        &program_id,
-    )
-    .await;
-    let wrong_destination_associated_token_account_address =
-        create_associated_token_account(&mut context, &wrong_wallet, &mint, &program_id).await;
-
-    let mut recover = instruction::recover_nested(&wallet.pubkey(), &mint, &mint, &program_id);
-    recover.accounts[2] =
-        AccountMeta::new(wrong_destination_associated_token_account_address, false);
-
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[recover],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wallet],
-        context.last_blockhash,
-    );
-    try_recover_nested(
-        &mut context,
-        &program_id,
-        mint,
-        mint_authority,
-        nested_associated_token_address,
-        owner_associated_token_address,
-        wallet,
-        transaction,
-        Some(InstructionError::InvalidSeeds),
-    )
-    .await;
-}
diff --git a/associated-token-account/program-test/tests/spl_token_create.rs b/associated-token-account/program-test/tests/spl_token_create.rs
deleted file mode 100644
index 903d12fb4d2..00000000000
--- a/associated-token-account/program-test/tests/spl_token_create.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Mark this test as BPF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-
-#[allow(deprecated)]
-use spl_associated_token_account::create_associated_token_account as deprecated_create_associated_token_account;
-use {
-    program_test::program_test,
-    solana_program::pubkey::Pubkey,
-    solana_program_test::*,
-    solana_sdk::{program_pack::Pack, signature::Signer, transaction::Transaction},
-    spl_associated_token_account::{
-        get_associated_token_address, instruction::create_associated_token_account,
-    },
-    spl_token::state::Account,
-};
-
-#[tokio::test]
-async fn success_create() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address =
-        get_associated_token_address(&wallet_address, &token_mint_address);
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let expected_token_account_len = Account::LEN;
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Associated account does not exist
-    assert_eq!(
-        banks_client
-            .get_account(associated_token_address)
-            .await
-            .expect("get_account"),
-        None,
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[create_associated_token_account(
-            &payer.pubkey(),
-            &wallet_address,
-            &token_mint_address,
-            &spl_token::id(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account now exists
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len);
-    assert_eq!(associated_account.owner, spl_token::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-}
-
-#[tokio::test]
-async fn success_using_deprecated_instruction_creator() {
-    let wallet_address = Pubkey::new_unique();
-    let token_mint_address = Pubkey::new_unique();
-    let associated_token_address =
-        get_associated_token_address(&wallet_address, &token_mint_address);
-
-    let (mut banks_client, payer, recent_blockhash) =
-        program_test(token_mint_address, true).start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let expected_token_account_len = Account::LEN;
-    let expected_token_account_balance = rent.minimum_balance(expected_token_account_len);
-
-    // Associated account does not exist
-    assert_eq!(
-        banks_client
-            .get_account(associated_token_address)
-            .await
-            .expect("get_account"),
-        None,
-    );
-
-    // Use legacy instruction creator
-    #[allow(deprecated)]
-    let create_associated_token_account_ix = deprecated_create_associated_token_account(
-        &payer.pubkey(),
-        &wallet_address,
-        &token_mint_address,
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[create_associated_token_account_ix],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Associated account now exists
-    let associated_account = banks_client
-        .get_account(associated_token_address)
-        .await
-        .expect("get_account")
-        .expect("associated_account not none");
-    assert_eq!(associated_account.data.len(), expected_token_account_len);
-    assert_eq!(associated_account.owner, spl_token::id());
-    assert_eq!(associated_account.lamports, expected_token_account_balance);
-}
diff --git a/associated-token-account/program/Cargo.toml b/associated-token-account/program/Cargo.toml
deleted file mode 100644
index fbceb0e7781..00000000000
--- a/associated-token-account/program/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-name = "spl-associated-token-account"
-version = "3.0.2"
-description = "Solana Program Library Associated Token Account"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-assert_matches = "1.5.0"
-borsh = "1.5.1"
-num-derive = "0.4"
-num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = [
-  "no-entrypoint",
-] }
-thiserror = "1.0"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/associated-token-account/program/program-id.md b/associated-token-account/program/program-id.md
deleted file mode 100644
index de8233b720f..00000000000
--- a/associated-token-account/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL
diff --git a/associated-token-account/program/run-tests.sh b/associated-token-account/program/run-tests.sh
deleted file mode 100755
index 603e3c552b2..00000000000
--- a/associated-token-account/program/run-tests.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")"
-cargo clippy
-cargo build
-cargo build-sbf
-
-if [[ $1 = -v ]]; then
-  export RUST_LOG=solana=debug
-fi
-
-cargo test
-cargo test-sbf
diff --git a/associated-token-account/program/src/error.rs b/associated-token-account/program/src/error.rs
deleted file mode 100644
index ae858a0d537..00000000000
--- a/associated-token-account/program/src/error.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//! Error types
-
-use {
-    num_derive::FromPrimitive,
-    solana_program::{decode_error::DecodeError, program_error::ProgramError},
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the program.
-#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
-pub enum AssociatedTokenAccountError {
-    // 0
-    /// Associated token account owner does not match address derivation
-    #[error("Associated token account owner does not match address derivation")]
-    InvalidOwner,
-}
-impl From<AssociatedTokenAccountError> for ProgramError {
-    fn from(e: AssociatedTokenAccountError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for AssociatedTokenAccountError {
-    fn type_of() -> &'static str {
-        "AssociatedTokenAccountError"
-    }
-}
diff --git a/associated-token-account/program/src/instruction.rs b/associated-token-account/program/src/instruction.rs
deleted file mode 100644
index 728d2abcf3a..00000000000
--- a/associated-token-account/program/src/instruction.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! Program instructions
-
-use {
-    crate::{get_associated_token_address_with_program_id, id},
-    assert_matches::assert_matches,
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        pubkey::Pubkey,
-    },
-};
-
-/// Instructions supported by the AssociatedTokenAccount program
-#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub enum AssociatedTokenAccountInstruction {
-    /// Creates an associated token account for the given wallet address and
-    /// token mint Returns an error if the account exists.
-    ///
-    ///   0. `[writeable,signer]` Funding account (must be a system account)
-    ///   1. `[writeable]` Associated token account address to be created
-    ///   2. `[]` Wallet address for the new associated token account
-    ///   3. `[]` The token mint for the new associated token account
-    ///   4. `[]` System program
-    ///   5. `[]` SPL Token program
-    Create,
-    /// Creates an associated token account for the given wallet address and
-    /// token mint, if it doesn't already exist.  Returns an error if the
-    /// account exists, but with a different owner.
-    ///
-    ///   0. `[writeable,signer]` Funding account (must be a system account)
-    ///   1. `[writeable]` Associated token account address to be created
-    ///   2. `[]` Wallet address for the new associated token account
-    ///   3. `[]` The token mint for the new associated token account
-    ///   4. `[]` System program
-    ///   5. `[]` SPL Token program
-    CreateIdempotent,
-    /// Transfers from and closes a nested associated token account: an
-    /// associated token account owned by an associated token account.
-    ///
-    /// The tokens are moved from the nested associated token account to the
-    /// wallet's associated token account, and the nested account lamports are
-    /// moved to the wallet.
-    ///
-    /// Note: Nested token accounts are an anti-pattern, and almost always
-    /// created unintentionally, so this instruction should only be used to
-    /// recover from errors.
-    ///
-    ///   0. `[writeable]` Nested associated token account, must be owned by `3`
-    ///   1. `[]` Token mint for the nested associated token account
-    ///   2. `[writeable]` Wallet's associated token account
-    ///   3. `[]` Owner associated token account address, must be owned by `5`
-    ///   4. `[]` Token mint for the owner associated token account
-    ///   5. `[writeable, signer]` Wallet address for the owner associated token
-    ///      account
-    ///   6. `[]` SPL Token program
-    RecoverNested,
-}
-
-fn build_associated_token_account_instruction(
-    funding_address: &Pubkey,
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    token_program_id: &Pubkey,
-    instruction: AssociatedTokenAccountInstruction,
-) -> Instruction {
-    let associated_account_address = get_associated_token_address_with_program_id(
-        wallet_address,
-        token_mint_address,
-        token_program_id,
-    );
-    // safety check, assert if not a creation instruction
-    assert_matches!(
-        instruction,
-        AssociatedTokenAccountInstruction::Create
-            | AssociatedTokenAccountInstruction::CreateIdempotent
-    );
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*funding_address, true),
-            AccountMeta::new(associated_account_address, false),
-            AccountMeta::new_readonly(*wallet_address, false),
-            AccountMeta::new_readonly(*token_mint_address, false),
-            AccountMeta::new_readonly(solana_program::system_program::id(), false),
-            AccountMeta::new_readonly(*token_program_id, false),
-        ],
-        data: borsh::to_vec(&instruction).unwrap(),
-    }
-}
-
-/// Creates Create instruction
-pub fn create_associated_token_account(
-    funding_address: &Pubkey,
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Instruction {
-    build_associated_token_account_instruction(
-        funding_address,
-        wallet_address,
-        token_mint_address,
-        token_program_id,
-        AssociatedTokenAccountInstruction::Create,
-    )
-}
-
-/// Creates CreateIdempotent instruction
-pub fn create_associated_token_account_idempotent(
-    funding_address: &Pubkey,
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Instruction {
-    build_associated_token_account_instruction(
-        funding_address,
-        wallet_address,
-        token_mint_address,
-        token_program_id,
-        AssociatedTokenAccountInstruction::CreateIdempotent,
-    )
-}
-
-/// Creates a `RecoverNested` instruction
-pub fn recover_nested(
-    wallet_address: &Pubkey,
-    owner_token_mint_address: &Pubkey,
-    nested_token_mint_address: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Instruction {
-    let owner_associated_account_address = get_associated_token_address_with_program_id(
-        wallet_address,
-        owner_token_mint_address,
-        token_program_id,
-    );
-    let destination_associated_account_address = get_associated_token_address_with_program_id(
-        wallet_address,
-        nested_token_mint_address,
-        token_program_id,
-    );
-    let nested_associated_account_address = get_associated_token_address_with_program_id(
-        &owner_associated_account_address, // ATA is wrongly used as a wallet_address
-        nested_token_mint_address,
-        token_program_id,
-    );
-
-    let instruction_data = AssociatedTokenAccountInstruction::RecoverNested;
-
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(nested_associated_account_address, false),
-            AccountMeta::new_readonly(*nested_token_mint_address, false),
-            AccountMeta::new(destination_associated_account_address, false),
-            AccountMeta::new_readonly(owner_associated_account_address, false),
-            AccountMeta::new_readonly(*owner_token_mint_address, false),
-            AccountMeta::new(*wallet_address, true),
-            AccountMeta::new_readonly(*token_program_id, false),
-        ],
-        data: borsh::to_vec(&instruction_data).unwrap(),
-    }
-}
diff --git a/associated-token-account/program/src/lib.rs b/associated-token-account/program/src/lib.rs
deleted file mode 100644
index 927f9d48185..00000000000
--- a/associated-token-account/program/src/lib.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//! Convention for associating token accounts with a user wallet
-#![deny(missing_docs)]
-#![forbid(unsafe_code)]
-
-mod entrypoint;
-pub mod error;
-pub mod instruction;
-pub mod processor;
-pub mod tools;
-
-// Export current SDK types for downstream users building with a different SDK
-// version
-pub use solana_program;
-use solana_program::{
-    instruction::{AccountMeta, Instruction},
-    pubkey::Pubkey,
-    sysvar,
-};
-
-solana_program::declare_id!("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
-
-pub(crate) fn get_associated_token_address_and_bump_seed(
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    program_id: &Pubkey,
-    token_program_id: &Pubkey,
-) -> (Pubkey, u8) {
-    get_associated_token_address_and_bump_seed_internal(
-        wallet_address,
-        token_mint_address,
-        program_id,
-        token_program_id,
-    )
-}
-
-/// Derives the associated token account address for the given wallet address
-/// and token mint
-pub fn get_associated_token_address(
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-) -> Pubkey {
-    get_associated_token_address_with_program_id(
-        wallet_address,
-        token_mint_address,
-        &spl_token::id(),
-    )
-}
-
-/// Derives the associated token account address for the given wallet address,
-/// token mint and token program id
-pub fn get_associated_token_address_with_program_id(
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Pubkey {
-    get_associated_token_address_and_bump_seed(
-        wallet_address,
-        token_mint_address,
-        &id(),
-        token_program_id,
-    )
-    .0
-}
-
-fn get_associated_token_address_and_bump_seed_internal(
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-    program_id: &Pubkey,
-    token_program_id: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[
-            &wallet_address.to_bytes(),
-            &token_program_id.to_bytes(),
-            &token_mint_address.to_bytes(),
-        ],
-        program_id,
-    )
-}
-
-/// Create an associated token account for the given wallet address and token
-/// mint
-///
-/// Accounts expected by this instruction:
-///
-///   0. `[writeable,signer]` Funding account (must be a system account)
-///   1. `[writeable]` Associated token account address to be created
-///   2. `[]` Wallet address for the new associated token account
-///   3. `[]` The token mint for the new associated token account
-///   4. `[]` System program
-///   5. `[]` SPL Token program
-#[deprecated(
-    since = "1.0.5",
-    note = "please use `instruction::create_associated_token_account` instead"
-)]
-pub fn create_associated_token_account(
-    funding_address: &Pubkey,
-    wallet_address: &Pubkey,
-    token_mint_address: &Pubkey,
-) -> Instruction {
-    let associated_account_address =
-        get_associated_token_address(wallet_address, token_mint_address);
-
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*funding_address, true),
-            AccountMeta::new(associated_account_address, false),
-            AccountMeta::new_readonly(*wallet_address, false),
-            AccountMeta::new_readonly(*token_mint_address, false),
-            AccountMeta::new_readonly(solana_program::system_program::id(), false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(sysvar::rent::id(), false),
-        ],
-        data: vec![],
-    }
-}
diff --git a/associated-token-account/program/src/processor.rs b/associated-token-account/program/src/processor.rs
deleted file mode 100644
index 20767a247d1..00000000000
--- a/associated-token-account/program/src/processor.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{
-        error::AssociatedTokenAccountError,
-        instruction::AssociatedTokenAccountInstruction,
-        tools::account::{create_pda_account, get_account_len},
-        *,
-    },
-    borsh::BorshDeserialize,
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program::{invoke, invoke_signed},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        rent::Rent,
-        system_program,
-        sysvar::Sysvar,
-    },
-    spl_token_2022::{
-        extension::{ExtensionType, StateWithExtensions},
-        state::{Account, Mint},
-    },
-};
-
-/// Specify when to create the associated token account
-#[derive(PartialEq)]
-enum CreateMode {
-    /// Always try to create the ATA
-    Always,
-    /// Only try to create the ATA if non-existent
-    Idempotent,
-}
-
-/// Instruction processor
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let instruction = if input.is_empty() {
-        AssociatedTokenAccountInstruction::Create
-    } else {
-        AssociatedTokenAccountInstruction::try_from_slice(input)
-            .map_err(|_| ProgramError::InvalidInstructionData)?
-    };
-
-    msg!("{:?}", instruction);
-
-    match instruction {
-        AssociatedTokenAccountInstruction::Create => {
-            process_create_associated_token_account(program_id, accounts, CreateMode::Always)
-        }
-        AssociatedTokenAccountInstruction::CreateIdempotent => {
-            process_create_associated_token_account(program_id, accounts, CreateMode::Idempotent)
-        }
-        AssociatedTokenAccountInstruction::RecoverNested => {
-            process_recover_nested(program_id, accounts)
-        }
-    }
-}
-
-/// Processes CreateAssociatedTokenAccount instruction
-fn process_create_associated_token_account(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    create_mode: CreateMode,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let funder_info = next_account_info(account_info_iter)?;
-    let associated_token_account_info = next_account_info(account_info_iter)?;
-    let wallet_account_info = next_account_info(account_info_iter)?;
-    let spl_token_mint_info = next_account_info(account_info_iter)?;
-    let system_program_info = next_account_info(account_info_iter)?;
-    let spl_token_program_info = next_account_info(account_info_iter)?;
-    let spl_token_program_id = spl_token_program_info.key;
-
-    let (associated_token_address, bump_seed) = get_associated_token_address_and_bump_seed_internal(
-        wallet_account_info.key,
-        spl_token_mint_info.key,
-        program_id,
-        spl_token_program_id,
-    );
-    if associated_token_address != *associated_token_account_info.key {
-        msg!("Error: Associated address does not match seed derivation");
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    if create_mode == CreateMode::Idempotent
-        && associated_token_account_info.owner == spl_token_program_id
-    {
-        let ata_data = associated_token_account_info.data.borrow();
-        if let Ok(associated_token_account) = StateWithExtensions::<Account>::unpack(&ata_data) {
-            if associated_token_account.base.owner != *wallet_account_info.key {
-                let error = AssociatedTokenAccountError::InvalidOwner;
-                msg!("{}", error);
-                return Err(error.into());
-            }
-            if associated_token_account.base.mint != *spl_token_mint_info.key {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            return Ok(());
-        }
-    }
-    if *associated_token_account_info.owner != system_program::id() {
-        return Err(ProgramError::IllegalOwner);
-    }
-
-    let rent = Rent::get()?;
-
-    let associated_token_account_signer_seeds: &[&[_]] = &[
-        &wallet_account_info.key.to_bytes(),
-        &spl_token_program_id.to_bytes(),
-        &spl_token_mint_info.key.to_bytes(),
-        &[bump_seed],
-    ];
-
-    let account_len = get_account_len(
-        spl_token_mint_info,
-        spl_token_program_info,
-        &[ExtensionType::ImmutableOwner],
-    )?;
-
-    create_pda_account(
-        funder_info,
-        &rent,
-        account_len,
-        spl_token_program_id,
-        system_program_info,
-        associated_token_account_info,
-        associated_token_account_signer_seeds,
-    )?;
-
-    msg!("Initialize the associated token account");
-    invoke(
-        &spl_token_2022::instruction::initialize_immutable_owner(
-            spl_token_program_id,
-            associated_token_account_info.key,
-        )?,
-        &[
-            associated_token_account_info.clone(),
-            spl_token_program_info.clone(),
-        ],
-    )?;
-    invoke(
-        &spl_token_2022::instruction::initialize_account3(
-            spl_token_program_id,
-            associated_token_account_info.key,
-            spl_token_mint_info.key,
-            wallet_account_info.key,
-        )?,
-        &[
-            associated_token_account_info.clone(),
-            spl_token_mint_info.clone(),
-            wallet_account_info.clone(),
-            spl_token_program_info.clone(),
-        ],
-    )
-}
-
-/// Processes `RecoverNested` instruction
-pub fn process_recover_nested(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let nested_associated_token_account_info = next_account_info(account_info_iter)?;
-    let nested_token_mint_info = next_account_info(account_info_iter)?;
-    let destination_associated_token_account_info = next_account_info(account_info_iter)?;
-    let owner_associated_token_account_info = next_account_info(account_info_iter)?;
-    let owner_token_mint_info = next_account_info(account_info_iter)?;
-    let wallet_account_info = next_account_info(account_info_iter)?;
-    let spl_token_program_info = next_account_info(account_info_iter)?;
-    let spl_token_program_id = spl_token_program_info.key;
-
-    // Check owner address derivation
-    let (owner_associated_token_address, bump_seed) =
-        get_associated_token_address_and_bump_seed_internal(
-            wallet_account_info.key,
-            owner_token_mint_info.key,
-            program_id,
-            spl_token_program_id,
-        );
-    if owner_associated_token_address != *owner_associated_token_account_info.key {
-        msg!("Error: Owner associated address does not match seed derivation");
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    // Check nested address derivation
-    let (nested_associated_token_address, _) = get_associated_token_address_and_bump_seed_internal(
-        owner_associated_token_account_info.key,
-        nested_token_mint_info.key,
-        program_id,
-        spl_token_program_id,
-    );
-    if nested_associated_token_address != *nested_associated_token_account_info.key {
-        msg!("Error: Nested associated address does not match seed derivation");
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    // Check destination address derivation
-    let (destination_associated_token_address, _) =
-        get_associated_token_address_and_bump_seed_internal(
-            wallet_account_info.key,
-            nested_token_mint_info.key,
-            program_id,
-            spl_token_program_id,
-        );
-    if destination_associated_token_address != *destination_associated_token_account_info.key {
-        msg!("Error: Destination associated address does not match seed derivation");
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    if !wallet_account_info.is_signer {
-        msg!("Wallet of the owner associated token account must sign");
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    if owner_token_mint_info.owner != spl_token_program_id {
-        msg!("Owner mint not owned by provided token program");
-        return Err(ProgramError::IllegalOwner);
-    }
-
-    // Account data is dropped at the end of this, so the CPI can succeed
-    // without a double-borrow
-    let (amount, decimals) = {
-        // Check owner associated token account data
-        if owner_associated_token_account_info.owner != spl_token_program_id {
-            msg!("Owner associated token account not owned by provided token program, recreate the owner associated token account first");
-            return Err(ProgramError::IllegalOwner);
-        }
-        let owner_account_data = owner_associated_token_account_info.data.borrow();
-        let owner_account = StateWithExtensions::<Account>::unpack(&owner_account_data)?;
-        if owner_account.base.owner != *wallet_account_info.key {
-            msg!("Owner associated token account not owned by provided wallet");
-            return Err(AssociatedTokenAccountError::InvalidOwner.into());
-        }
-
-        // Check nested associated token account data
-        if nested_associated_token_account_info.owner != spl_token_program_id {
-            msg!("Nested associated token account not owned by provided token program");
-            return Err(ProgramError::IllegalOwner);
-        }
-        let nested_account_data = nested_associated_token_account_info.data.borrow();
-        let nested_account = StateWithExtensions::<Account>::unpack(&nested_account_data)?;
-        if nested_account.base.owner != *owner_associated_token_account_info.key {
-            msg!("Nested associated token account not owned by provided associated token account");
-            return Err(AssociatedTokenAccountError::InvalidOwner.into());
-        }
-        let amount = nested_account.base.amount;
-
-        // Check nested token mint data
-        if nested_token_mint_info.owner != spl_token_program_id {
-            msg!("Nested mint account not owned by provided token program");
-            return Err(ProgramError::IllegalOwner);
-        }
-        let nested_mint_data = nested_token_mint_info.data.borrow();
-        let nested_mint = StateWithExtensions::<Mint>::unpack(&nested_mint_data)?;
-        let decimals = nested_mint.base.decimals;
-        (amount, decimals)
-    };
-
-    // Transfer everything out
-    let owner_associated_token_account_signer_seeds: &[&[_]] = &[
-        &wallet_account_info.key.to_bytes(),
-        &spl_token_program_id.to_bytes(),
-        &owner_token_mint_info.key.to_bytes(),
-        &[bump_seed],
-    ];
-    invoke_signed(
-        &spl_token_2022::instruction::transfer_checked(
-            spl_token_program_id,
-            nested_associated_token_account_info.key,
-            nested_token_mint_info.key,
-            destination_associated_token_account_info.key,
-            owner_associated_token_account_info.key,
-            &[],
-            amount,
-            decimals,
-        )?,
-        &[
-            nested_associated_token_account_info.clone(),
-            nested_token_mint_info.clone(),
-            destination_associated_token_account_info.clone(),
-            owner_associated_token_account_info.clone(),
-            spl_token_program_info.clone(),
-        ],
-        &[owner_associated_token_account_signer_seeds],
-    )?;
-
-    // Close the nested account so it's never used again
-    invoke_signed(
-        &spl_token_2022::instruction::close_account(
-            spl_token_program_id,
-            nested_associated_token_account_info.key,
-            wallet_account_info.key,
-            owner_associated_token_account_info.key,
-            &[],
-        )?,
-        &[
-            nested_associated_token_account_info.clone(),
-            wallet_account_info.clone(),
-            owner_associated_token_account_info.clone(),
-            spl_token_program_info.clone(),
-        ],
-        &[owner_associated_token_account_signer_seeds],
-    )
-}
diff --git a/associated-token-account/program/src/tools/account.rs b/associated-token-account/program/src/tools/account.rs
deleted file mode 100644
index 2001e227e50..00000000000
--- a/associated-token-account/program/src/tools/account.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-//! Account utility functions
-
-use {
-    solana_program::{
-        account_info::AccountInfo,
-        entrypoint::ProgramResult,
-        program::{get_return_data, invoke, invoke_signed},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        rent::Rent,
-        system_instruction,
-    },
-    spl_token_2022::extension::ExtensionType,
-    std::convert::TryInto,
-};
-
-/// Creates associated token account using Program Derived Address for the given
-/// seeds
-pub fn create_pda_account<'a>(
-    payer: &AccountInfo<'a>,
-    rent: &Rent,
-    space: usize,
-    owner: &Pubkey,
-    system_program: &AccountInfo<'a>,
-    new_pda_account: &AccountInfo<'a>,
-    new_pda_signer_seeds: &[&[u8]],
-) -> ProgramResult {
-    if new_pda_account.lamports() > 0 {
-        let required_lamports = rent
-            .minimum_balance(space)
-            .max(1)
-            .saturating_sub(new_pda_account.lamports());
-
-        if required_lamports > 0 {
-            invoke(
-                &system_instruction::transfer(payer.key, new_pda_account.key, required_lamports),
-                &[
-                    payer.clone(),
-                    new_pda_account.clone(),
-                    system_program.clone(),
-                ],
-            )?;
-        }
-
-        invoke_signed(
-            &system_instruction::allocate(new_pda_account.key, space as u64),
-            &[new_pda_account.clone(), system_program.clone()],
-            &[new_pda_signer_seeds],
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(new_pda_account.key, owner),
-            &[new_pda_account.clone(), system_program.clone()],
-            &[new_pda_signer_seeds],
-        )
-    } else {
-        invoke_signed(
-            &system_instruction::create_account(
-                payer.key,
-                new_pda_account.key,
-                rent.minimum_balance(space).max(1),
-                space as u64,
-                owner,
-            ),
-            &[
-                payer.clone(),
-                new_pda_account.clone(),
-                system_program.clone(),
-            ],
-            &[new_pda_signer_seeds],
-        )
-    }
-}
-
-/// Determines the required initial data length for a new token account based on
-/// the extensions initialized on the Mint
-pub fn get_account_len<'a>(
-    mint: &AccountInfo<'a>,
-    spl_token_program: &AccountInfo<'a>,
-    extension_types: &[ExtensionType],
-) -> Result<usize, ProgramError> {
-    invoke(
-        &spl_token_2022::instruction::get_account_data_size(
-            spl_token_program.key,
-            mint.key,
-            extension_types,
-        )?,
-        &[mint.clone(), spl_token_program.clone()],
-    )?;
-    get_return_data()
-        .ok_or(ProgramError::InvalidInstructionData)
-        .and_then(|(key, data)| {
-            if key != *spl_token_program.key {
-                return Err(ProgramError::IncorrectProgramId);
-            }
-            data.try_into()
-                .map(usize::from_le_bytes)
-                .map_err(|_| ProgramError::InvalidInstructionData)
-        })
-}
diff --git a/associated-token-account/program/src/tools/mod.rs b/associated-token-account/program/src/tools/mod.rs
deleted file mode 100644
index 5cb1ab5f753..00000000000
--- a/associated-token-account/program/src/tools/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Utility functions
-
-pub mod account;
diff --git a/binary-option/client/binary_option.py b/binary-option/client/binary_option.py
index 08972560f00..da78cc00545 100644
--- a/binary-option/client/binary_option.py
+++ b/binary-option/client/binary_option.py
@@ -140,7 +140,7 @@ def __init__(self, cfg):
 
     def initialize(self, api_endpoint, escrow_mint, decimals=2, skip_confirmation=True):
         msg = ""
-        # Initialize Clinet
+        # Initialize Client
         client = Client(api_endpoint)
         msg += "Initialized client"
         # Create account objects
diff --git a/binary-option/client/requirements.txt b/binary-option/client/requirements.txt
index 766d0de789b..cd8592a055d 100644
--- a/binary-option/client/requirements.txt
+++ b/binary-option/client/requirements.txt
@@ -1,12 +1,12 @@
 attrs==21.2.0
 base58==2.1.0
-certifi==2023.7.22
+certifi==2024.7.4
 cffi==1.14.5
 chardet==4.0.0
 cheroot==8.5.2
 CherryPy==18.6.0
 construct==2.10.67
-cryptography==42.0.4
+cryptography==43.0.1
 ed25519==1.5
 idna==3.7
 iniconfig==1.1.1
diff --git a/binary-option/program/Cargo.toml b/binary-option/program/Cargo.toml
index 8e2d46e47d2..b9b64a6b6e1 100644
--- a/binary-option/program/Cargo.toml
+++ b/binary-option/program/Cargo.toml
@@ -9,14 +9,17 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
-thiserror = "1.0"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+solana-program = "2.1.0"
+thiserror = "2.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-arrayref = "0.3.7"
-borsh = "1.5.1"
-uint = "0.9"
+arrayref = "0.3.9"
+borsh = "1.5.3"
+uint = "0.10"
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/binary-oracle-pair/program/Cargo.toml b/binary-oracle-pair/program/Cargo.toml
index 7d1ff233663..afea331bd9d 100644
--- a/binary-oracle-pair/program/Cargo.toml
+++ b/binary-oracle-pair/program/Cargo.toml
@@ -13,17 +13,20 @@ test-sbf = []
 [dependencies]
 num-derive = "0.4"
 num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-thiserror = "1.0"
-uint = "0.9"
-borsh = "1.5.1"
+thiserror = "2.0"
+uint = "0.10"
+borsh = "1.5.3"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/ci/cliff.toml b/ci/cliff.toml
new file mode 100644
index 00000000000..62578ee4bb0
--- /dev/null
+++ b/ci/cliff.toml
@@ -0,0 +1,58 @@
+# git-cliff configuration file
+# https://git-cliff.org/docs/configuration
+#
+# Lines starting with "#" are comments.
+# Configuration options are organized into tables and keys.
+# See documentation for more information on available options.
+
+[changelog]
+header = """
+## What's new
+"""
+# template for the changelog body
+# https://tera.netlify.app/docs
+body = """
+{% for group, commits in commits | group_by(attribute="group") %}\
+    {% for commit in commits %}
+        - {{ commit.message | upper_first | split(pat="\n") | first | trim }}\
+        {% if commit.remote.username %} by @{{ commit.remote.username }}{%- endif %}\
+    {% endfor %}\
+{% endfor %}
+"""
+# remove the leading and trailing whitespace from the template
+trim = true
+footer = """
+"""
+postprocessors = [ ]
+[git]
+# parse the commits based on https://www.conventionalcommits.org
+conventional_commits = true
+# filter out the commits that are not conventional
+filter_unconventional = false
+# process each line of a commit as an individual commit
+split_commits = false
+# regex for preprocessing the commit messages
+commit_preprocessors = []
+# regex for parsing and grouping commits
+commit_parsers = [
+    { message = "^build\\(deps\\)", skip = true },
+    { message = "^build\\(deps-dev\\)", skip = true },
+    { message = "^ci", skip = true },
+    { body = ".*", group = "Changes" },
+]
+# protect breaking changes from being skipped due to matching a skipping commit_parser
+protect_breaking_commits = false
+# filter out the commits that are not matched by commit parsers
+filter_commits = false
+# glob pattern for matching git tags
+tag_pattern = "v[0-9]*"
+# regex for skipping tags
+skip_tags = ""
+# regex for ignoring tags
+ignore_tags = ""
+# sort the tags topologically
+topo_order = false
+# sort the commits inside sections by oldest/newest order
+sort_commits = "newest"
+# limit the number of commits included in the changelog.
+# limit_commits = 42
diff --git a/ci/do-audit.sh b/ci/do-audit.sh
index f86ef5c8236..43ceb9c0ac8 100755
--- a/ci/do-audit.sh
+++ b/ci/do-audit.sh
@@ -5,30 +5,34 @@ cd "$(dirname "$0")/.."
 source ./ci/rust-version.sh stable
 
 cargo_audit_ignores=(
-  # Potential segfault in the time crate
-  #
-  # Blocked on chrono updating `time` to >= 0.2.23
-  --ignore RUSTSEC-2020-0071
-
-  # tokio: vulnerability affecting named pipes on Windows
-  #
-  # Exception is a stopgap to unblock CI
-  # https://github.com/solana-labs/solana/issues/29586
-  --ignore RUSTSEC-2023-0001
-
   # ed25519-dalek: Double Public Key Signing Function Oracle Attack
   #
-  # Remove once SPL upgrades to Solana v1.17 or greater
+  # Remove once SPL upgrades to ed25519-dalek v2
   --ignore RUSTSEC-2022-0093
 
-  # webpki: CPU denial of service in certificate path building
+  # curve25519-dalek
   #
-  # No fixed upgrade is available! Only fix is switching to rustls-webpki
-  --ignore RUSTSEC-2023-0052
+  # Remove once SPL upgrades to curve25519-dalek v4
+  --ignore RUSTSEC-2024-0344
 
-  # tungstenite
-  #
-  # Remove once SPL upgrades to Solana v1.17 or greater
-  --ignore RUSTSEC-2023-0065
+  # Crate:     tonic
+  # Version:   0.9.2
+  # Title:     Remotely exploitable Denial of Service in Tonic
+  # Date:      2024-10-01
+  # ID:        RUSTSEC-2024-0376
+  # URL:       https://rustsec.org/advisories/RUSTSEC-2024-0376
+  # Solution:  Upgrade to >=0.12.3
+  --ignore RUSTSEC-2024-0376
+
+  # Crate:     idna
+  # Version:   0.1.5
+  # Title:     `idna` accepts Punycode labels that do not produce any non-ASCII when decoded
+  # Date:      2024-12-09
+  # ID:        RUSTSEC-2024-0421
+  # URL:       https://rustsec.org/advisories/RUSTSEC-2024-0421
+  # Solution:  Upgrade to >=1.0.0
+  # need to solve this depentant tree:
+  # jsonrpc-core-client v18.0.0 -> jsonrpc-client-transports v18.0.0 -> url v1.7.2 -> idna v0.1.5
+  --ignore RUSTSEC-2024-0421
 )
 cargo +"$rust_stable" audit "${cargo_audit_ignores[@]}"
diff --git a/ci/js-test-account-compression.sh b/ci/js-test-account-compression.sh
index 38b6314eca2..4d60fd2abc2 100755
--- a/ci/js-test-account-compression.sh
+++ b/ci/js-test-account-compression.sh
@@ -2,11 +2,13 @@
 
 set -e
 cd "$(dirname "$0")/.."
+export SOLANA_VERSION="v2.0.14"
 source ./ci/solana-version.sh install
 
 set -x
-cd account-compression/sdk
 pnpm install
+pnpm format
+cd account-compression/sdk
 pnpm build
 pnpm build:program
 pnpm lint
diff --git a/ci/js-test-libraries.sh b/ci/js-test-libraries.sh
deleted file mode 100755
index fab495f0bba..00000000000
--- a/ci/js-test-libraries.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-cd "$(dirname "$0")/.."
-
-set -x
-cd libraries/type-length-value/js
-
-pnpm install
-pnpm lint
-pnpm build
-pnpm test
diff --git a/ci/js-test-memo.sh b/ci/js-test-memo.sh
deleted file mode 100755
index fe6b243384f..00000000000
--- a/ci/js-test-memo.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-cd "$(dirname "$0")/.."
-source ./ci/solana-version.sh install
-
-set -x
-cd memo/js
-
-pnpm install
-pnpm lint
-pnpm build
-pnpm test
diff --git a/ci/js-test-name-service.sh b/ci/js-test-name-service.sh
index f854b5fae67..e78cb1501a2 100755
--- a/ci/js-test-name-service.sh
+++ b/ci/js-test-name-service.sh
@@ -5,9 +5,10 @@ cd "$(dirname "$0")/.."
 source ./ci/solana-version.sh install
 
 set -x
-cd name-service/js
-
 pnpm install
+pnpm format
+
+cd name-service/js
 pnpm lint
 pnpm build:program
 pnpm build
diff --git a/ci/js-test-single-pool.sh b/ci/js-test-single-pool.sh
deleted file mode 100755
index 3842116df91..00000000000
--- a/ci/js-test-single-pool.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-source ./ci/solana-version.sh install
-
-cd single-pool/js
-pnpm install
-
-cd packages/modern
-pnpm lint
-pnpm build
-
-cd ../classic
-pnpm build:program
-pnpm lint
-pnpm build
-pnpm test
diff --git a/ci/js-test-stake-pool.sh b/ci/js-test-stake-pool.sh
deleted file mode 100755
index 4650f6597bc..00000000000
--- a/ci/js-test-stake-pool.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-
-pnpm install
-pnpm build
-
-cd stake-pool/js
-pnpm lint
-pnpm test
diff --git a/ci/js-test-token-group.sh b/ci/js-test-token-group.sh
deleted file mode 100755
index 7c84fd16218..00000000000
--- a/ci/js-test-token-group.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-cd "$(dirname "$0")/.."
-
-set -x
-pnpm install
-pnpm build
-
-cd token-group/js
-pnpm lint
-pnpm test
diff --git a/ci/js-test-token-lending.sh b/ci/js-test-token-lending.sh
index 8342a2ab47f..4753d04e2fc 100755
--- a/ci/js-test-token-lending.sh
+++ b/ci/js-test-token-lending.sh
@@ -5,6 +5,7 @@ cd "$(dirname "$0")/.."
 
 set -x
 pnpm install
+pnpm format
 pnpm build
 
 cd token-lending/js
diff --git a/ci/js-test-token-metadata.sh b/ci/js-test-token-metadata.sh
deleted file mode 100755
index 14c0fc472ac..00000000000
--- a/ci/js-test-token-metadata.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-cd "$(dirname "$0")/.."
-
-set -x
-pnpm install
-pnpm build
-
-cd token-metadata/js
-pnpm lint
-pnpm test
diff --git a/ci/js-test-token-swap.sh b/ci/js-test-token-swap.sh
index f08a7ea722a..923a72c7cf1 100755
--- a/ci/js-test-token-swap.sh
+++ b/ci/js-test-token-swap.sh
@@ -5,6 +5,7 @@ cd "$(dirname "$0")/.."
 source ./ci/solana-version.sh install
 
 pnpm install
+pnpm format
 pnpm build
 
 cd token-swap/js
diff --git a/ci/js-test-token.sh b/ci/js-test-token.sh
deleted file mode 100755
index f7d0db98f69..00000000000
--- a/ci/js-test-token.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-cd "$(dirname "$0")/.."
-source ./ci/solana-version.sh install
-
-set -x
-pnpm install
-pnpm build
-
-cd token/js
-pnpm build:program
-pnpm lint
-pnpm test
diff --git a/ci/publish-rust.sh b/ci/publish-rust.sh
new file mode 100755
index 00000000000..b5e6f362c3b
--- /dev/null
+++ b/ci/publish-rust.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+set -e
+base="$(dirname "${BASH_SOURCE[0]}")"
+source "$base/read-cargo-variable.sh"
+cd "$base/.."
+
+if [[ -z $1 ]]; then
+  echo 'A package manifest path — e.g. "token/program" — must be provided.'
+  exit 1
+fi
+PACKAGE_PATH=$1
+if [[ -z $2 ]]; then
+  echo 'A version level — e.g. "patch" — must be provided.'
+  exit 1
+fi
+LEVEL=$2
+DRY_RUN=$3
+
+# Go to the directory
+cd "${PACKAGE_PATH}"
+
+# Get the old version, used with git-cliff
+old_version=$(readCargoVariable version "Cargo.toml")
+package_name=$(readCargoVariable name "Cargo.toml")
+tag_name="$(echo $package_name | sed 's/spl-//')"
+
+# Publish the new version, commit the repo change, tag it, and push it all.
+if [[ -n ${DRY_RUN} ]]; then
+  cargo release ${LEVEL}
+else
+  cargo release ${LEVEL} --tag-name "${tag_name}-v{{version}}" --no-confirm --execute
+fi
+
+# Stop here if this is a dry run.
+if [[ -n $DRY_RUN ]]; then
+  exit 0
+fi
+
+# Get the new version.
+new_version=$(readCargoVariable version "Cargo.toml")
+new_git_tag="${tag_name}-v${new_version}"
+old_git_tag="${tag_name}-v${old_version}"
+release_title="SPL ${tag_name} - v${new_version}"
+
+# Expose the new version to CI if needed.
+if [[ -n $CI ]]; then
+  echo "new_git_tag=${new_git_tag}" >> $GITHUB_OUTPUT
+  echo "old_git_tag=${old_git_tag}" >> $GITHUB_OUTPUT
+  echo "release_title=${release_title}" >> $GITHUB_OUTPUT
+fi
diff --git a/ci/py-test-stake-pool.sh b/ci/py-test-stake-pool.sh
deleted file mode 100755
index 4c3ca8cfe72..00000000000
--- a/ci/py-test-stake-pool.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")/.."
-source ./ci/solana-version.sh install
-
-cd stake-pool/py
-python3 -m venv venv
-source ./venv/bin/activate
-pip3 install -r requirements.txt
-pip3 install -r optional-requirements.txt
-check_dirs=(
-  "bot"
-  "spl_token"
-  "stake"
-  "stake_pool"
-  "system"
-  "tests"
-  "vote"
-)
-flake8 "${check_dirs[@]}"
-mypy "${check_dirs[@]}"
-python3 -m pytest
diff --git a/ci/rust-version.sh b/ci/rust-version.sh
index 9282c3494bb..2d9d7060a83 100644
--- a/ci/rust-version.sh
+++ b/ci/rust-version.sh
@@ -26,7 +26,7 @@ fi
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2023-10-05
+  nightly_version=2024-08-08
 fi
 
 export rust_stable="$stable_version"
diff --git a/ci/solana-version.sh b/ci/solana-version.sh
index 90245e13114..a299a5ee36d 100755
--- a/ci/solana-version.sh
+++ b/ci/solana-version.sh
@@ -14,10 +14,7 @@
 if [[ -n $SOLANA_VERSION ]]; then
   solana_version="$SOLANA_VERSION"
 else
-  # This file is now out of sync with the versions in Cargo.toml.
-  # https://github.com/solana-labs/solana-program-library/pull/6182
-  # This will require some manual cleanup the next time the version is updated.
-  solana_version=v1.18.11
+  solana_version=v2.1.0
 fi
 
 export solana_version="$solana_version"
@@ -26,7 +23,7 @@ export PATH="$HOME"/.local/share/solana/install/active_release/bin:"$PATH"
 if [[ -n $1 ]]; then
   case $1 in
   install)
-    sh -c "$(curl -sSfL https://release.solana.com/$solana_version/install)"
+    sh -c "$(curl -sSfL https://release.anza.xyz/$solana_version/install)"
     solana --version
     ;;
   *)
diff --git a/coverage.sh b/coverage.sh
index e2923813d81..edaca0b88ba 100755
--- a/coverage.sh
+++ b/coverage.sh
@@ -22,8 +22,6 @@ reportName="lcov-${CI_COMMIT:0:9}"
 if [[ -z $1 ]]; then
   programs=(
     libraries/math
-    memo/program
-    token/program
     token-lending/program
     token-swap/program
   )
diff --git a/docs/package-lock.json b/docs/package-lock.json
index fdc79968146..0ac0508faa6 100644
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
@@ -4029,12 +4029,12 @@
       "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.18",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz",
-      "integrity": "sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==",
+      "version": "0.3.25",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
       "dependencies": {
-        "@jridgewell/resolve-uri": "3.1.0",
-        "@jridgewell/sourcemap-codec": "1.4.14"
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
     "node_modules/@leichtgewicht/ip-codec": {
@@ -4719,28 +4719,10 @@
         "@types/ms": "*"
       }
     },
-    "node_modules/@types/eslint": {
-      "version": "8.4.1",
-      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.1.tgz",
-      "integrity": "sha512-GE44+DNEyxxh2Kc6ro/VkIj+9ma0pO0bwv9+uHSyBrikYOHr8zYcdPvnBOp1aw8s+CjRvuSx7CyWqRrNFQ59mA==",
-      "dependencies": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "node_modules/@types/eslint-scope": {
-      "version": "3.7.3",
-      "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.3.tgz",
-      "integrity": "sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==",
-      "dependencies": {
-        "@types/eslint": "*",
-        "@types/estree": "*"
-      }
-    },
     "node_modules/@types/estree": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.1.tgz",
-      "integrity": "sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA=="
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+      "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw=="
     },
     "node_modules/@types/estree-jsx": {
       "version": "1.0.3",
@@ -5021,9 +5003,9 @@
       "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
     },
     "node_modules/@webassemblyjs/ast": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.6.tgz",
-      "integrity": "sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
+      "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
       "dependencies": {
         "@webassemblyjs/helper-numbers": "1.11.6",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
@@ -5040,9 +5022,9 @@
       "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q=="
     },
     "node_modules/@webassemblyjs/helper-buffer": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz",
-      "integrity": "sha512-z3nFzdcp1mb8nEOFFk8DrYLpHvhKC3grJD2ardfKOzmbmJvEf/tPIqCY+sNcwZIY8ZD7IkB2l7/pqhUhqm7hLA=="
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
+      "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw=="
     },
     "node_modules/@webassemblyjs/helper-numbers": {
       "version": "1.11.6",
@@ -5060,14 +5042,14 @@
       "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA=="
     },
     "node_modules/@webassemblyjs/helper-wasm-section": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz",
-      "integrity": "sha512-LPpZbSOwTpEC2cgn4hTydySy1Ke+XEu+ETXuoyvuyezHO3Kjdu90KK95Sh9xTbmjrCsUwvWwCOQQNta37VrS9g==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
+      "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6"
+        "@webassemblyjs/wasm-gen": "1.12.1"
       }
     },
     "node_modules/@webassemblyjs/ieee754": {
@@ -5092,26 +5074,26 @@
       "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA=="
     },
     "node_modules/@webassemblyjs/wasm-edit": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz",
-      "integrity": "sha512-Ybn2I6fnfIGuCR+Faaz7YcvtBKxvoLV3Lebn1tM4o/IAJzmi9AWYIPWpyBfU8cC+JxAO57bk4+zdsTjJR+VTOw==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
+      "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-opt": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6",
-        "@webassemblyjs/wast-printer": "1.11.6"
+        "@webassemblyjs/helper-wasm-section": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-opt": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1",
+        "@webassemblyjs/wast-printer": "1.12.1"
       }
     },
     "node_modules/@webassemblyjs/wasm-gen": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz",
-      "integrity": "sha512-3XOqkZP/y6B4F0PBAXvI1/bky7GryoogUtfwExeP/v7Nzwo1QLcq5oQmpKlftZLbT+ERUOAZVQjuNVak6UXjPA==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
+      "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
         "@webassemblyjs/ieee754": "1.11.6",
         "@webassemblyjs/leb128": "1.11.6",
@@ -5119,22 +5101,22 @@
       }
     },
     "node_modules/@webassemblyjs/wasm-opt": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz",
-      "integrity": "sha512-cOrKuLRE7PCe6AsOVl7WasYf3wbSo4CeOk6PkrjS7g57MFfVUF9u6ysQBBODX0LdgSvQqRiGz3CXvIDKcPNy4g==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
+      "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6"
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1"
       }
     },
     "node_modules/@webassemblyjs/wasm-parser": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz",
-      "integrity": "sha512-6ZwPeGzMJM3Dqp3hCsLgESxBGtT/OeCvCZ4TA1JUPYgmhAx38tTPR9JaKy0S5H3evQpO/h2uWs2j6Yc/fjkpTQ==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
+      "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@webassemblyjs/helper-api-error": "1.11.6",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
         "@webassemblyjs/ieee754": "1.11.6",
@@ -5143,11 +5125,11 @@
       }
     },
     "node_modules/@webassemblyjs/wast-printer": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz",
-      "integrity": "sha512-JM7AhRcE+yW2GWYaKeHL5vt4xqee5N2WcezptmgyhNS+ScggqcT1OtXykhAb13Sn5Yas0j2uv9tHgrjwvzAP4A==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
+      "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
       "dependencies": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@xtuc/long": "4.2.2"
       }
     },
@@ -5537,11 +5519,11 @@
       }
     },
     "node_modules/axios": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.2.tgz",
-      "integrity": "sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==",
+      "version": "1.7.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.4.tgz",
+      "integrity": "sha512-DukmaFRnY6AzAALSH4J2M3k6PkaC+MfaAGdEERRWcC9q3/TWQwLpHR8ZRLKTdQ3aBDL64EdluRDjJqKw+BPZEw==",
       "dependencies": {
-        "follow-redirects": "^1.15.0",
+        "follow-redirects": "^1.15.6",
         "form-data": "^4.0.0",
         "proxy-from-env": "^1.1.0"
       }
@@ -5664,9 +5646,9 @@
       }
     },
     "node_modules/body-parser": {
-      "version": "1.20.2",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.2.tgz",
-      "integrity": "sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==",
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
       "dependencies": {
         "bytes": "3.1.2",
         "content-type": "~1.0.5",
@@ -5676,7 +5658,7 @@
         "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
         "on-finished": "2.4.1",
-        "qs": "6.11.0",
+        "qs": "6.13.0",
         "raw-body": "2.5.2",
         "type-is": "~1.6.18",
         "unpipe": "1.0.0"
@@ -5924,12 +5906,18 @@
       }
     },
     "node_modules/call-bind": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
-      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
+      "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
       "dependencies": {
-        "function-bind": "^1.1.1",
-        "get-intrinsic": "^1.0.2"
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "set-function-length": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -6545,9 +6533,9 @@
       "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="
     },
     "node_modules/cookie": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
-      "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
       "engines": {
         "node": ">= 0.6"
       }
@@ -6700,9 +6688,9 @@
       }
     },
     "node_modules/cross-spawn": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.5.tgz",
+      "integrity": "sha512-ZVJrKKYunU38/76t0RMOulHOnUcbU9GbpWKAOZ0mhjr7CX6FVrH+4FrAapSOekrgFQ3f/8gwMEuIft0aKq6Hug==",
       "dependencies": {
         "path-key": "^3.1.0",
         "shebang-command": "^2.0.0",
@@ -7112,6 +7100,22 @@
         "node": ">=10"
       }
     },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/define-lazy-prop": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
@@ -7470,17 +7474,17 @@
       }
     },
     "node_modules/encodeurl": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
       "engines": {
         "node": ">= 0.8"
       }
     },
     "node_modules/enhanced-resolve": {
-      "version": "5.15.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.15.0.tgz",
-      "integrity": "sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==",
+      "version": "5.17.1",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
+      "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
       "dependencies": {
         "graceful-fs": "^4.2.4",
         "tapable": "^2.2.0"
@@ -7552,6 +7556,25 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/es-define-property": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
+      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "dependencies": {
+        "get-intrinsic": "^1.2.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/es-module-lexer": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.3.0.tgz",
@@ -8106,36 +8129,36 @@
       }
     },
     "node_modules/express": {
-      "version": "4.19.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.19.2.tgz",
-      "integrity": "sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==",
+      "version": "4.21.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.1.tgz",
+      "integrity": "sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==",
       "dependencies": {
         "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "1.20.2",
+        "body-parser": "1.20.3",
         "content-disposition": "0.5.4",
         "content-type": "~1.0.4",
-        "cookie": "0.6.0",
+        "cookie": "0.7.1",
         "cookie-signature": "1.0.6",
         "debug": "2.6.9",
         "depd": "2.0.0",
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "finalhandler": "1.2.0",
+        "finalhandler": "1.3.1",
         "fresh": "0.5.2",
         "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.1",
+        "merge-descriptors": "1.0.3",
         "methods": "~1.1.2",
         "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.7",
+        "path-to-regexp": "0.1.10",
         "proxy-addr": "~2.0.7",
-        "qs": "6.11.0",
+        "qs": "6.13.0",
         "range-parser": "~1.2.1",
         "safe-buffer": "5.2.1",
-        "send": "0.18.0",
-        "serve-static": "1.15.0",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
         "setprototypeof": "1.2.0",
         "statuses": "2.0.1",
         "type-is": "~1.6.18",
@@ -8176,9 +8199,9 @@
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
     },
     "node_modules/express/node_modules/path-to-regexp": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
-      "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
+      "version": "0.1.10",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.10.tgz",
+      "integrity": "sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w=="
     },
     "node_modules/express/node_modules/range-parser": {
       "version": "1.2.1",
@@ -8397,12 +8420,12 @@
       }
     },
     "node_modules/finalhandler": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
-      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
       "dependencies": {
         "debug": "2.6.9",
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
@@ -8758,9 +8781,12 @@
       }
     },
     "node_modules/function-bind": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
     },
     "node_modules/functional-red-black-tree": {
       "version": "1.0.1",
@@ -8795,13 +8821,18 @@
       }
     },
     "node_modules/get-intrinsic": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
-      "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
+      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
       "dependencies": {
-        "function-bind": "^1.1.1",
-        "has": "^1.0.3",
-        "has-symbols": "^1.0.1"
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3",
+        "hasown": "^2.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -8970,6 +9001,17 @@
         "node": ">= 4"
       }
     },
+    "node_modules/gopd": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
+      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "dependencies": {
+        "get-intrinsic": "^1.1.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/got": {
       "version": "12.6.1",
       "resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz",
@@ -9059,10 +9101,32 @@
         "node": ">=4"
       }
     },
-    "node_modules/has-symbols": {
+    "node_modules/has-property-descriptors": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
-      "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
+      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
       "engines": {
         "node": ">= 0.4"
       },
@@ -9100,6 +9164,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/hast-util-from-parse5": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz",
@@ -9961,9 +10036,9 @@
       }
     },
     "node_modules/http-proxy-middleware": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz",
-      "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==",
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz",
+      "integrity": "sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==",
       "dependencies": {
         "@types/http-proxy": "^1.17.8",
         "http-proxy": "^1.18.1",
@@ -11730,9 +11805,12 @@
       }
     },
     "node_modules/merge-descriptors": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
-      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w=="
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     },
     "node_modules/merge-stream": {
       "version": "2.0.0",
@@ -13558,11 +13636,11 @@
       ]
     },
     "node_modules/micromatch": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz",
-      "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==",
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "dependencies": {
-        "braces": "^3.0.2",
+        "braces": "^3.0.3",
         "picomatch": "^2.3.1"
       },
       "engines": {
@@ -13695,9 +13773,9 @@
       }
     },
     "node_modules/nanoid": {
-      "version": "3.3.6",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz",
-      "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==",
+      "version": "3.3.8",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
+      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
       "funding": [
         {
           "type": "github",
@@ -13877,9 +13955,12 @@
       }
     },
     "node_modules/object-inspect": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.0.tgz",
-      "integrity": "sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==",
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz",
+      "integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==",
+      "engines": {
+        "node": ">= 0.4"
+      },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
       }
@@ -15197,11 +15278,11 @@
       "integrity": "sha512-QFADYnsVoBMw1srW7OVKEYjG+MbIa49s54w1MA1EDY6r2r/sTcKKYqRX1f4GYvnXP7eN/Pe9HFcX+hwzmrXRHA=="
     },
     "node_modules/qs": {
-      "version": "6.11.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
-      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
       "dependencies": {
-        "side-channel": "^1.0.4"
+        "side-channel": "^1.0.6"
       },
       "engines": {
         "node": ">=0.6"
@@ -16955,9 +17036,9 @@
       }
     },
     "node_modules/send": {
-      "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
-      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
       "dependencies": {
         "debug": "2.6.9",
         "depd": "2.0.0",
@@ -16990,6 +17071,14 @@
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
       "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
     },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/send/node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -17097,19 +17186,35 @@
       }
     },
     "node_modules/serve-static": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
-      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
       "dependencies": {
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "parseurl": "~1.3.3",
-        "send": "0.18.0"
+        "send": "0.19.0"
       },
       "engines": {
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/setimmediate": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
@@ -17180,13 +17285,17 @@
       }
     },
     "node_modules/side-channel": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
-      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
+      "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
       "dependencies": {
-        "call-bind": "^1.0.0",
-        "get-intrinsic": "^1.0.2",
-        "object-inspect": "^1.9.0"
+        "call-bind": "^1.0.7",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.4",
+        "object-inspect": "^1.13.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -17688,12 +17797,12 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.17.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.17.1.tgz",
-      "integrity": "sha512-hVl35zClmpisy6oaoKALOpS0rDYLxRFLHhRuDlEGTKey9qHjS1w9GMORjuwIMt70Wan4lwsLYyWDVnWgF+KUEw==",
+      "version": "5.31.6",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz",
+      "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==",
       "dependencies": {
-        "@jridgewell/source-map": "^0.3.2",
-        "acorn": "^8.5.0",
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.8.2",
         "commander": "^2.20.0",
         "source-map-support": "~0.5.20"
       },
@@ -17705,15 +17814,15 @@
       }
     },
     "node_modules/terser-webpack-plugin": {
-      "version": "5.3.9",
-      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz",
-      "integrity": "sha512-ZuXsqE07EcggTWQjXUj+Aot/OMcD0bMKGgF63f7UxYcu5/AJF53aIpK1YoP5xR9l6s/Hy2b+t1AM0bLNPRuhwA==",
+      "version": "5.3.10",
+      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
+      "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
       "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.17",
+        "@jridgewell/trace-mapping": "^0.3.20",
         "jest-worker": "^27.4.5",
         "schema-utils": "^3.1.1",
         "serialize-javascript": "^6.0.1",
-        "terser": "^5.16.8"
+        "terser": "^5.26.0"
       },
       "engines": {
         "node": ">= 10.13.0"
@@ -17755,9 +17864,9 @@
       }
     },
     "node_modules/terser/node_modules/acorn": {
-      "version": "8.7.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
-      "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ==",
+      "version": "8.12.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -18508,9 +18617,9 @@
       }
     },
     "node_modules/watchpack": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
-      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
+      "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
       "dependencies": {
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.1.2"
@@ -18542,33 +18651,32 @@
       "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
     },
     "node_modules/webpack": {
-      "version": "5.89.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.89.0.tgz",
-      "integrity": "sha512-qyfIC10pOr70V+jkmud8tMfajraGCZMBWJtrmuBymQKCrLTRejBI8STDp1MCyZu/QTdZSeacCQYpYNQVOzX5kw==",
-      "dependencies": {
-        "@types/eslint-scope": "^3.7.3",
-        "@types/estree": "^1.0.0",
-        "@webassemblyjs/ast": "^1.11.5",
-        "@webassemblyjs/wasm-edit": "^1.11.5",
-        "@webassemblyjs/wasm-parser": "^1.11.5",
+      "version": "5.94.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
+      "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
+      "dependencies": {
+        "@types/estree": "^1.0.5",
+        "@webassemblyjs/ast": "^1.12.1",
+        "@webassemblyjs/wasm-edit": "^1.12.1",
+        "@webassemblyjs/wasm-parser": "^1.12.1",
         "acorn": "^8.7.1",
-        "acorn-import-assertions": "^1.9.0",
-        "browserslist": "^4.14.5",
+        "acorn-import-attributes": "^1.9.5",
+        "browserslist": "^4.21.10",
         "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.15.0",
+        "enhanced-resolve": "^5.17.1",
         "es-module-lexer": "^1.2.1",
         "eslint-scope": "5.1.1",
         "events": "^3.2.0",
         "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.2.9",
+        "graceful-fs": "^4.2.11",
         "json-parse-even-better-errors": "^2.3.1",
         "loader-runner": "^4.2.0",
         "mime-types": "^2.1.27",
         "neo-async": "^2.6.2",
         "schema-utils": "^3.2.0",
         "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.7",
-        "watchpack": "^2.4.0",
+        "terser-webpack-plugin": "^5.3.10",
+        "watchpack": "^2.4.1",
         "webpack-sources": "^3.2.3"
       },
       "bin": {
@@ -18784,9 +18892,9 @@
       }
     },
     "node_modules/webpack/node_modules/acorn": {
-      "version": "8.9.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.9.0.tgz",
-      "integrity": "sha512-jaVNAFBHNLXspO543WnNNPZFRtavh3skAkITqD0/2aeMkKZTN+254PyhwxFYrk3vQ1xfY+2wbesJMs/JC8/PwQ==",
+      "version": "8.12.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -18794,14 +18902,19 @@
         "node": ">=0.4.0"
       }
     },
-    "node_modules/webpack/node_modules/acorn-import-assertions": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz",
-      "integrity": "sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==",
+    "node_modules/webpack/node_modules/acorn-import-attributes": {
+      "version": "1.9.5",
+      "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
+      "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
       "peerDependencies": {
         "acorn": "^8"
       }
     },
+    "node_modules/webpack/node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
+    },
     "node_modules/webpack/node_modules/mime-db": {
       "version": "1.51.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.51.0.tgz",
@@ -22070,12 +22183,12 @@
       "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
     },
     "@jridgewell/trace-mapping": {
-      "version": "0.3.18",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz",
-      "integrity": "sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==",
+      "version": "0.3.25",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
       "requires": {
-        "@jridgewell/resolve-uri": "3.1.0",
-        "@jridgewell/sourcemap-codec": "1.4.14"
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
     "@leichtgewicht/ip-codec": {
@@ -22543,28 +22656,10 @@
         "@types/ms": "*"
       }
     },
-    "@types/eslint": {
-      "version": "8.4.1",
-      "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.1.tgz",
-      "integrity": "sha512-GE44+DNEyxxh2Kc6ro/VkIj+9ma0pO0bwv9+uHSyBrikYOHr8zYcdPvnBOp1aw8s+CjRvuSx7CyWqRrNFQ59mA==",
-      "requires": {
-        "@types/estree": "*",
-        "@types/json-schema": "*"
-      }
-    },
-    "@types/eslint-scope": {
-      "version": "3.7.3",
-      "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.3.tgz",
-      "integrity": "sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==",
-      "requires": {
-        "@types/eslint": "*",
-        "@types/estree": "*"
-      }
-    },
     "@types/estree": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.1.tgz",
-      "integrity": "sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA=="
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+      "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw=="
     },
     "@types/estree-jsx": {
       "version": "1.0.3",
@@ -22845,9 +22940,9 @@
       "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
     },
     "@webassemblyjs/ast": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.6.tgz",
-      "integrity": "sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
+      "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
       "requires": {
         "@webassemblyjs/helper-numbers": "1.11.6",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
@@ -22864,9 +22959,9 @@
       "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q=="
     },
     "@webassemblyjs/helper-buffer": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz",
-      "integrity": "sha512-z3nFzdcp1mb8nEOFFk8DrYLpHvhKC3grJD2ardfKOzmbmJvEf/tPIqCY+sNcwZIY8ZD7IkB2l7/pqhUhqm7hLA=="
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
+      "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw=="
     },
     "@webassemblyjs/helper-numbers": {
       "version": "1.11.6",
@@ -22884,14 +22979,14 @@
       "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA=="
     },
     "@webassemblyjs/helper-wasm-section": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz",
-      "integrity": "sha512-LPpZbSOwTpEC2cgn4hTydySy1Ke+XEu+ETXuoyvuyezHO3Kjdu90KK95Sh9xTbmjrCsUwvWwCOQQNta37VrS9g==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
+      "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6"
+        "@webassemblyjs/wasm-gen": "1.12.1"
       }
     },
     "@webassemblyjs/ieee754": {
@@ -22916,26 +23011,26 @@
       "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA=="
     },
     "@webassemblyjs/wasm-edit": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz",
-      "integrity": "sha512-Ybn2I6fnfIGuCR+Faaz7YcvtBKxvoLV3Lebn1tM4o/IAJzmi9AWYIPWpyBfU8cC+JxAO57bk4+zdsTjJR+VTOw==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
+      "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-opt": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6",
-        "@webassemblyjs/wast-printer": "1.11.6"
+        "@webassemblyjs/helper-wasm-section": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-opt": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1",
+        "@webassemblyjs/wast-printer": "1.12.1"
       }
     },
     "@webassemblyjs/wasm-gen": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz",
-      "integrity": "sha512-3XOqkZP/y6B4F0PBAXvI1/bky7GryoogUtfwExeP/v7Nzwo1QLcq5oQmpKlftZLbT+ERUOAZVQjuNVak6UXjPA==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
+      "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
         "@webassemblyjs/ieee754": "1.11.6",
         "@webassemblyjs/leb128": "1.11.6",
@@ -22943,22 +23038,22 @@
       }
     },
     "@webassemblyjs/wasm-opt": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz",
-      "integrity": "sha512-cOrKuLRE7PCe6AsOVl7WasYf3wbSo4CeOk6PkrjS7g57MFfVUF9u6ysQBBODX0LdgSvQqRiGz3CXvIDKcPNy4g==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
+      "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
-        "@webassemblyjs/helper-buffer": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.11.6",
-        "@webassemblyjs/wasm-parser": "1.11.6"
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1"
       }
     },
     "@webassemblyjs/wasm-parser": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz",
-      "integrity": "sha512-6ZwPeGzMJM3Dqp3hCsLgESxBGtT/OeCvCZ4TA1JUPYgmhAx38tTPR9JaKy0S5H3evQpO/h2uWs2j6Yc/fjkpTQ==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
+      "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@webassemblyjs/helper-api-error": "1.11.6",
         "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
         "@webassemblyjs/ieee754": "1.11.6",
@@ -22967,11 +23062,11 @@
       }
     },
     "@webassemblyjs/wast-printer": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz",
-      "integrity": "sha512-JM7AhRcE+yW2GWYaKeHL5vt4xqee5N2WcezptmgyhNS+ScggqcT1OtXykhAb13Sn5Yas0j2uv9tHgrjwvzAP4A==",
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
+      "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
       "requires": {
-        "@webassemblyjs/ast": "1.11.6",
+        "@webassemblyjs/ast": "1.12.1",
         "@xtuc/long": "4.2.2"
       }
     },
@@ -23253,11 +23348,11 @@
       }
     },
     "axios": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.2.tgz",
-      "integrity": "sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==",
+      "version": "1.7.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.4.tgz",
+      "integrity": "sha512-DukmaFRnY6AzAALSH4J2M3k6PkaC+MfaAGdEERRWcC9q3/TWQwLpHR8ZRLKTdQ3aBDL64EdluRDjJqKw+BPZEw==",
       "requires": {
-        "follow-redirects": "^1.15.0",
+        "follow-redirects": "^1.15.6",
         "form-data": "^4.0.0",
         "proxy-from-env": "^1.1.0"
       }
@@ -23349,9 +23444,9 @@
       "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA=="
     },
     "body-parser": {
-      "version": "1.20.2",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.2.tgz",
-      "integrity": "sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==",
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
       "requires": {
         "bytes": "3.1.2",
         "content-type": "~1.0.5",
@@ -23361,7 +23456,7 @@
         "http-errors": "2.0.0",
         "iconv-lite": "0.4.24",
         "on-finished": "2.4.1",
-        "qs": "6.11.0",
+        "qs": "6.13.0",
         "raw-body": "2.5.2",
         "type-is": "~1.6.18",
         "unpipe": "1.0.0"
@@ -23528,12 +23623,15 @@
       }
     },
     "call-bind": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
-      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
+      "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
       "requires": {
-        "function-bind": "^1.1.1",
-        "get-intrinsic": "^1.0.2"
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "set-function-length": "^1.2.1"
       }
     },
     "callsites": {
@@ -23968,9 +24066,9 @@
       "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="
     },
     "cookie": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
-      "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw=="
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w=="
     },
     "cookie-signature": {
       "version": "1.0.6",
@@ -24071,9 +24169,9 @@
       }
     },
     "cross-spawn": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.5.tgz",
+      "integrity": "sha512-ZVJrKKYunU38/76t0RMOulHOnUcbU9GbpWKAOZ0mhjr7CX6FVrH+4FrAapSOekrgFQ3f/8gwMEuIft0aKq6Hug==",
       "requires": {
         "path-key": "^3.1.0",
         "shebang-command": "^2.0.0",
@@ -24333,6 +24431,16 @@
       "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
       "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg=="
     },
+    "define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "requires": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      }
+    },
     "define-lazy-prop": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
@@ -24599,14 +24707,14 @@
       "integrity": "sha512-dqx7eA9YaqyvYtUhJwT4rC1HIp82j5ybS1/vQ42ur+jBe17dJMwZE4+gvL1XadSFfxaPFFGt3Xsw+Y8akThDlw=="
     },
     "encodeurl": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="
     },
     "enhanced-resolve": {
-      "version": "5.15.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.15.0.tgz",
-      "integrity": "sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==",
+      "version": "5.17.1",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
+      "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
       "requires": {
         "graceful-fs": "^4.2.4",
         "tapable": "^2.2.0"
@@ -24660,6 +24768,19 @@
         "unbox-primitive": "^1.0.1"
       }
     },
+    "es-define-property": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
+      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "requires": {
+        "get-intrinsic": "^1.2.4"
+      }
+    },
+    "es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
+    },
     "es-module-lexer": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.3.0.tgz",
@@ -25055,36 +25176,36 @@
       }
     },
     "express": {
-      "version": "4.19.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.19.2.tgz",
-      "integrity": "sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==",
+      "version": "4.21.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.1.tgz",
+      "integrity": "sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==",
       "requires": {
         "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "1.20.2",
+        "body-parser": "1.20.3",
         "content-disposition": "0.5.4",
         "content-type": "~1.0.4",
-        "cookie": "0.6.0",
+        "cookie": "0.7.1",
         "cookie-signature": "1.0.6",
         "debug": "2.6.9",
         "depd": "2.0.0",
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "etag": "~1.8.1",
-        "finalhandler": "1.2.0",
+        "finalhandler": "1.3.1",
         "fresh": "0.5.2",
         "http-errors": "2.0.0",
-        "merge-descriptors": "1.0.1",
+        "merge-descriptors": "1.0.3",
         "methods": "~1.1.2",
         "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
-        "path-to-regexp": "0.1.7",
+        "path-to-regexp": "0.1.10",
         "proxy-addr": "~2.0.7",
-        "qs": "6.11.0",
+        "qs": "6.13.0",
         "range-parser": "~1.2.1",
         "safe-buffer": "5.2.1",
-        "send": "0.18.0",
-        "serve-static": "1.15.0",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
         "setprototypeof": "1.2.0",
         "statuses": "2.0.1",
         "type-is": "~1.6.18",
@@ -25119,9 +25240,9 @@
           "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
         },
         "path-to-regexp": {
-          "version": "0.1.7",
-          "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
-          "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
+          "version": "0.1.10",
+          "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.10.tgz",
+          "integrity": "sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w=="
         },
         "range-parser": {
           "version": "1.2.1",
@@ -25285,12 +25406,12 @@
       }
     },
     "finalhandler": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
-      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
       "requires": {
         "debug": "2.6.9",
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "on-finished": "2.4.1",
         "parseurl": "~1.3.3",
@@ -25527,9 +25648,9 @@
       "optional": true
     },
     "function-bind": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="
     },
     "functional-red-black-tree": {
       "version": "1.0.1",
@@ -25558,13 +25679,15 @@
       "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="
     },
     "get-intrinsic": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
-      "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
+      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
       "requires": {
-        "function-bind": "^1.1.1",
-        "has": "^1.0.3",
-        "has-symbols": "^1.0.1"
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3",
+        "hasown": "^2.0.0"
       }
     },
     "get-own-enumerable-property-symbols": {
@@ -25685,6 +25808,14 @@
         }
       }
     },
+    "gopd": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
+      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "requires": {
+        "get-intrinsic": "^1.1.3"
+      }
+    },
     "got": {
       "version": "12.6.1",
       "resolved": "https://registry.npmjs.org/got/-/got-12.6.1.tgz",
@@ -25750,10 +25881,23 @@
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
       "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0="
     },
-    "has-symbols": {
+    "has-property-descriptors": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
-      "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw=="
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "requires": {
+        "es-define-property": "^1.0.0"
+      }
+    },
+    "has-proto": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
+      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q=="
+    },
+    "has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A=="
     },
     "has-tostringtag": {
       "version": "1.0.0",
@@ -25773,6 +25917,14 @@
       "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz",
       "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA=="
     },
+    "hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "requires": {
+        "function-bind": "^1.1.2"
+      }
+    },
     "hast-util-from-parse5": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz",
@@ -26401,9 +26553,9 @@
       }
     },
     "http-proxy-middleware": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz",
-      "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==",
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz",
+      "integrity": "sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==",
       "requires": {
         "@types/http-proxy": "^1.17.8",
         "http-proxy": "^1.18.1",
@@ -27658,9 +27810,9 @@
       }
     },
     "merge-descriptors": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
-      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w=="
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ=="
     },
     "merge-stream": {
       "version": "2.0.0",
@@ -28646,11 +28798,11 @@
       "integrity": "sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w=="
     },
     "micromatch": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz",
-      "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==",
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "requires": {
-        "braces": "^3.0.2",
+        "braces": "^3.0.3",
         "picomatch": "^2.3.1"
       }
     },
@@ -28733,9 +28885,9 @@
       }
     },
     "nanoid": {
-      "version": "3.3.6",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz",
-      "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA=="
+      "version": "3.3.8",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
+      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w=="
     },
     "natural-compare": {
       "version": "1.4.0",
@@ -28852,9 +29004,9 @@
       "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM="
     },
     "object-inspect": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.0.tgz",
-      "integrity": "sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g=="
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz",
+      "integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g=="
     },
     "object-keys": {
       "version": "1.1.1",
@@ -29729,11 +29881,11 @@
       "integrity": "sha512-QFADYnsVoBMw1srW7OVKEYjG+MbIa49s54w1MA1EDY6r2r/sTcKKYqRX1f4GYvnXP7eN/Pe9HFcX+hwzmrXRHA=="
     },
     "qs": {
-      "version": "6.11.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
-      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
       "requires": {
-        "side-channel": "^1.0.4"
+        "side-channel": "^1.0.6"
       }
     },
     "queue": {
@@ -30993,9 +31145,9 @@
       }
     },
     "send": {
-      "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
-      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
       "requires": {
         "debug": "2.6.9",
         "depd": "2.0.0",
@@ -31027,6 +31179,11 @@
             }
           }
         },
+        "encodeurl": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+          "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="
+        },
         "ms": {
           "version": "2.1.3",
           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -31123,14 +31280,27 @@
       }
     },
     "serve-static": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
-      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
       "requires": {
-        "encodeurl": "~1.0.2",
+        "encodeurl": "~2.0.0",
         "escape-html": "~1.0.3",
         "parseurl": "~1.3.3",
-        "send": "0.18.0"
+        "send": "0.19.0"
+      }
+    },
+    "set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "requires": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
       }
     },
     "setimmediate": {
@@ -31185,13 +31355,14 @@
       }
     },
     "side-channel": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
-      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
+      "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
       "requires": {
-        "call-bind": "^1.0.0",
-        "get-intrinsic": "^1.0.2",
-        "object-inspect": "^1.9.0"
+        "call-bind": "^1.0.7",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.4",
+        "object-inspect": "^1.13.1"
       }
     },
     "signal-exit": {
@@ -31559,20 +31730,20 @@
       "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ=="
     },
     "terser": {
-      "version": "5.17.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.17.1.tgz",
-      "integrity": "sha512-hVl35zClmpisy6oaoKALOpS0rDYLxRFLHhRuDlEGTKey9qHjS1w9GMORjuwIMt70Wan4lwsLYyWDVnWgF+KUEw==",
+      "version": "5.31.6",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz",
+      "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==",
       "requires": {
-        "@jridgewell/source-map": "^0.3.2",
-        "acorn": "^8.5.0",
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.8.2",
         "commander": "^2.20.0",
         "source-map-support": "~0.5.20"
       },
       "dependencies": {
         "acorn": {
-          "version": "8.7.0",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
-          "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ=="
+          "version": "8.12.1",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+          "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg=="
         },
         "commander": {
           "version": "2.20.3",
@@ -31582,15 +31753,15 @@
       }
     },
     "terser-webpack-plugin": {
-      "version": "5.3.9",
-      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz",
-      "integrity": "sha512-ZuXsqE07EcggTWQjXUj+Aot/OMcD0bMKGgF63f7UxYcu5/AJF53aIpK1YoP5xR9l6s/Hy2b+t1AM0bLNPRuhwA==",
+      "version": "5.3.10",
+      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
+      "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
       "requires": {
-        "@jridgewell/trace-mapping": "^0.3.17",
+        "@jridgewell/trace-mapping": "^0.3.20",
         "jest-worker": "^27.4.5",
         "schema-utils": "^3.1.1",
         "serialize-javascript": "^6.0.1",
-        "terser": "^5.16.8"
+        "terser": "^5.26.0"
       },
       "dependencies": {
         "schema-utils": {
@@ -32102,9 +32273,9 @@
       }
     },
     "watchpack": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
-      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
+      "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
       "requires": {
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.1.2"
@@ -32129,47 +32300,51 @@
       "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
     },
     "webpack": {
-      "version": "5.89.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.89.0.tgz",
-      "integrity": "sha512-qyfIC10pOr70V+jkmud8tMfajraGCZMBWJtrmuBymQKCrLTRejBI8STDp1MCyZu/QTdZSeacCQYpYNQVOzX5kw==",
-      "requires": {
-        "@types/eslint-scope": "^3.7.3",
-        "@types/estree": "^1.0.0",
-        "@webassemblyjs/ast": "^1.11.5",
-        "@webassemblyjs/wasm-edit": "^1.11.5",
-        "@webassemblyjs/wasm-parser": "^1.11.5",
+      "version": "5.94.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
+      "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
+      "requires": {
+        "@types/estree": "^1.0.5",
+        "@webassemblyjs/ast": "^1.12.1",
+        "@webassemblyjs/wasm-edit": "^1.12.1",
+        "@webassemblyjs/wasm-parser": "^1.12.1",
         "acorn": "^8.7.1",
-        "acorn-import-assertions": "^1.9.0",
-        "browserslist": "^4.14.5",
+        "acorn-import-attributes": "^1.9.5",
+        "browserslist": "^4.21.10",
         "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.15.0",
+        "enhanced-resolve": "^5.17.1",
         "es-module-lexer": "^1.2.1",
         "eslint-scope": "5.1.1",
         "events": "^3.2.0",
         "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.2.9",
+        "graceful-fs": "^4.2.11",
         "json-parse-even-better-errors": "^2.3.1",
         "loader-runner": "^4.2.0",
         "mime-types": "^2.1.27",
         "neo-async": "^2.6.2",
         "schema-utils": "^3.2.0",
         "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.7",
-        "watchpack": "^2.4.0",
+        "terser-webpack-plugin": "^5.3.10",
+        "watchpack": "^2.4.1",
         "webpack-sources": "^3.2.3"
       },
       "dependencies": {
         "acorn": {
-          "version": "8.9.0",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.9.0.tgz",
-          "integrity": "sha512-jaVNAFBHNLXspO543WnNNPZFRtavh3skAkITqD0/2aeMkKZTN+254PyhwxFYrk3vQ1xfY+2wbesJMs/JC8/PwQ=="
-        },
-        "acorn-import-assertions": {
-          "version": "1.9.0",
-          "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz",
-          "integrity": "sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==",
+          "version": "8.12.1",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+          "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg=="
+        },
+        "acorn-import-attributes": {
+          "version": "1.9.5",
+          "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
+          "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
           "requires": {}
         },
+        "graceful-fs": {
+          "version": "4.2.11",
+          "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+          "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
+        },
         "mime-db": {
           "version": "1.51.0",
           "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.51.0.tgz",
diff --git a/docs/src/account-compression/usage.md b/docs/src/account-compression/usage.md
index c91046b2eb5..31bd53e6b0c 100644
--- a/docs/src/account-compression/usage.md
+++ b/docs/src/account-compression/usage.md
@@ -7,13 +7,13 @@ title: Example usage of the TS SDK
 ## Install
 
 ```shell
-npm install --save @solana/spl-account-compression @solana/web3.js
+npm install --save @solana/spl-account-compression @solana/web3.js@1
 ```
 
 __OR__
 
 ```shell
-yarn add @solana/spl-account-compression @solana/web3.js
+yarn add @solana/spl-account-compression @solana/web3.js@1
 ```
 
 ### Examples
diff --git a/docs/src/associated-token-account.md b/docs/src/associated-token-account.md
index 0fefb54858c..ff23010aa7c 100644
--- a/docs/src/associated-token-account.md
+++ b/docs/src/associated-token-account.md
@@ -38,10 +38,10 @@ document are available at:
 ## Source
 
 The Associated Token Account Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library).
-
+[GitHub](https://github.com/solana-program/associated-token-account).
 
 ## Interface
+
 The Associated Token Account Program is written in Rust and available on
 [crates.io](https://crates.io/crates/spl-associated-token-account) and
 [docs.rs](https://docs.rs/spl-associated-token-account).
diff --git a/docs/src/feature-proposal.md b/docs/src/feature-proposal.md
index ec560b2378e..705d991ad0c 100644
--- a/docs/src/feature-proposal.md
+++ b/docs/src/feature-proposal.md
@@ -35,7 +35,7 @@ when appropriate.
 
 ## Source
 The Feature Proposal Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library)
+[GitHub](https://github.com/solana-program/feature-proposal).
 
 ## Interface
 The Feature Proposal Program is written in Rust and available on [crates.io](https://crates.io/crates/spl-feature-proposal) and [docs.rs](https://docs.rs/spl-feature-proposal).
@@ -58,7 +58,7 @@ This section describes the life cycle of a feature proposal.
 
 ### Implement the Feature
 The first step is to conceive of the new feature and realize it in the
-Solana code base, working with the core Solana developers at https://github.com/solana-labs/solana.
+Solana code base, working with the core Solana developers at https://github.com/anza-xyz/agave
 
 During the implementation, a *feature id* will be required to identify the new
 feature in the code base to avoid the new functionality until its activation.
diff --git a/docs/src/memo.md b/docs/src/memo.md
index 00748522573..95bbd49d881 100644
--- a/docs/src/memo.md
+++ b/docs/src/memo.md
@@ -20,7 +20,7 @@ document are available at:
 ## Source
 
 The Memo Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library)
+[GitHub](https://github.com/solana-program/memo)
 
 ## Interface
 
diff --git a/docs/src/single-pool.mdx b/docs/src/single-pool.mdx
index be12aaa7b05..357a025d296 100644
--- a/docs/src/single-pool.mdx
+++ b/docs/src/single-pool.mdx
@@ -24,7 +24,7 @@ The program is a stripped-down adaptation of the existing multi-validator stake
 ## Source
 
 The Single Pool Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library/tree/master/single-pool/program).
+[GitHub](https://github.com/solana-program/single-pool).
 
 ## Security Audits
 
@@ -32,13 +32,13 @@ The Single Pool Program has received three audits to ensure total safety of fund
 
 * Zellic (2024-01-02)
     - Review commit hash [`ef44df9`](https://github.com/solana-labs/solana-program-library/commit/ef44df985e76a697ee9a8aabb3a223610e4cf1dc)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/ZellicSinglePoolAudit-2024-01-02.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/ZellicSinglePoolAudit-2024-01-02.pdf
 * Neodyme (2023-08-08)
     - Review commit hash [`735d729`](https://github.com/solana-labs/solana-program-library/commit/735d7292e35d35101750a4452d2647bdbf848e8b)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/NeodymeSinglePoolAudit-2023-08-08.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/NeodymeSinglePoolAudit-2023-08-08.pdf
 * Zellic (2023-06-21)
     - Review commit hash [`9dbdc3b`](https://github.com/solana-labs/solana-program-library/commit/9dbdc3bdae31dda1dcb35346aab2d879deecf194)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/ZellicSinglePoolAudit-2023-06-21.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/ZellicSinglePoolAudit-2023-06-21.pdf
 
 ## Interface
 
@@ -129,7 +129,7 @@ const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
 ```
 
 ### Keypair
-You can either get your keypair using [`Keypair`](https://solana-labs.github.io/solana-web3.js/classes/Keypair.html) from `@solana/web3.js`, or let the user's wallet handle the keypair and use `sendTransaction` from [`wallet-adapter`](https://github.com/solana-labs/wallet-adapter)
+You can either get your keypair using [`Keypair`](https://solana-labs.github.io/solana-web3.js/v1.x/classes/Keypair.html) from `@solana/web3.js`, or let the user's wallet handle the keypair and use `sendTransaction` from [`wallet-adapter`](https://github.com/solana-labs/wallet-adapter)
 
   </TabItem>
   <TabItem value="jsn" label="WEB3.JS NEXT">
diff --git a/docs/src/stake-pool.md b/docs/src/stake-pool.md
index 92b8c17af74..637b32c33e8 100644
--- a/docs/src/stake-pool.md
+++ b/docs/src/stake-pool.md
@@ -10,6 +10,10 @@ to maximize censorship resistance and rewards.
 | --- | --- |
 | Stake Pool Program | `SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy` |
 
+NOTE: The devnet deployment of the program still uses v0.6.4, and is not suitable
+for testing. For testing, it is recommended to use testnet, a local test validator,
+or deploy your own version for devnet.
+
 ## Getting Started
 
 To get started with stake pools:
@@ -23,7 +27,7 @@ To get started with stake pools:
 ## Source
 
 The Stake Pool Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library/tree/master/stake-pool).
+[GitHub](https://github.com/solana-program/stake-pool).
 
 For information about the types and instructions, the Stake Pool Rust docs are
 available at [docs.rs](https://docs.rs/spl-stake-pool/latest/spl_stake_pool/index.html).
@@ -37,28 +41,28 @@ chronological order, and the commit hash that each was reviewed at:
 * Quantstamp
     - Initial review commit hash [`99914c9`](https://github.com/solana-labs/solana-program-library/tree/99914c9fc7246b22ef04416586ab1722c89576de)
     - Re-review commit hash [`3b48fa0`](https://github.com/solana-labs/solana-program-library/tree/3b48fa09d38d1b66ffb4fef186b606f1bc4fdb31)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/QuantstampStakePoolAudit-2021-10-22.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/QuantstampStakePoolAudit-2021-10-22.pdf
 * Neodyme
     - Review commit hash [`0a85a9a`](https://github.com/solana-labs/solana-program-library/tree/0a85a9a533795b6338ea144e433893c6c0056210)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/NeodymeStakePoolAudit-2021-10-16.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/NeodymeStakePoolAudit-2021-10-16.pdf
 * Kudelski
     - Review commit hash [`3dd6767`](https://github.com/solana-labs/solana-program-library/tree/3dd67672974f92d3b648bb50ee74f4747a5f8973)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/KudelskiStakePoolAudit-2021-07-07.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/KudelskiStakePoolAudit-2021-07-07.pdf
 * Neodyme Second Audit
     - Review commit hash [`fd92ccf`](https://github.com/solana-labs/solana-program-library/tree/fd92ccf9e9308508b719d6e5f36474f57023b0b2)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/NeodymeStakePoolAudit-2022-12-10.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/NeodymeStakePoolAudit-2022-12-10.pdf
 * OtterSec
     - Review commit hash [`eba709b`](https://github.com/solana-labs/solana-program-library/tree/eba709b9317f8c7b8b197045161cb744241f0bff)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecStakePoolAudit-2023-01-20.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/OtterSecStakePoolAudit-2023-01-20.pdf
 * Neodyme Third Audit
     - Review commit hash [`b341022`](https://github.com/solana-labs/solana-program-library/tree/b34102211f2a5ea6b83f3ee22f045fb115d87813)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/NeodymeStakePoolAudit-2023-01-31.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/NeodymeStakePoolAudit-2023-01-31.pdf
 * Halborn
     - Review commit hash [`eba709b`](https://github.com/solana-labs/solana-program-library/tree/eba709b9317f8c7b8b197045161cb744241f0bff)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-01-25.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-01-25.pdf
 * Neodyme Fourth Audit
     - Review commit hash [`6ed7254`](https://github.com/solana-labs/solana-program-library/tree/6ed7254d1a578ffbc2b091d28cb92b25e7cc511d)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/NeodymeStakePoolAudit-2023-11-14.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/NeodymeStakePoolAudit-2023-11-14.pdf
 * Halborn Second Audit
     - Review commit hash [`a17fffe`](https://github.com/solana-labs/solana-program-library/tree/a17fffe70d6cc13742abfbc4a4a375b087580bc1)
-    - Report https://github.com/solana-labs/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-12-31.pdf
+    - Report https://github.com/anza-xyz/security-audits/blob/master/spl/HalbornStakePoolAudit-2023-12-31.pdf
diff --git a/docs/src/token-2022.md b/docs/src/token-2022.md
index fee446e6be0..c4aa63f2055 100644
--- a/docs/src/token-2022.md
+++ b/docs/src/token-2022.md
@@ -43,13 +43,14 @@ Token-2022 are a strict superset of Token.
 ### Instructions
 
 Token-2022 supports the exact same instruction layouts as Token, byte for
-byte. For example, if you want to transfer 100 tokens on a mint with 2 decimals,
-you create a `TransferChecked` instruction, with this byte-represented data:
+byte. For example, if you want to transfer 0.75 tokens in UI amount, on a mint with 2 decimals,
+then the transfer amount is 75 tokens. You create a `TransferChecked` instruction, with
+this byte-represented data:
 
 ```
-[12, 100, 0, 0, 0, 0, 0, 0, 0, 2]
+[12, 75, 0, 0, 0, 0, 0, 0, 0, 2]
  ^^ TransferChecked enum
-     ^^^^^^^^^^^^^^^^^^^^^^^^ 100, as a little-endian 64-bit unsigned integer
+     ^^^^^^^^^^^^^^^^^^^^^^^^ 75, as a little-endian 64-bit unsigned integer
                                ^ 2, as a byte
 ```
 
@@ -81,7 +82,7 @@ is written after the end of the `Account` in Token, which is the byte at index
 `165`.  This means it is always possible to differentiate mints and accounts.
 
 You can read more about how this is done at the
-[source code](https://github.com/solana-labs/solana-program-library/blob/master/token/program-2022/src/extension/mod.rs).
+[source code](https://github.com/solana-program/token-2022/blob/main/program/src/extension/mod.rs).
 
 Mint extensions currently include:
 
@@ -127,7 +128,7 @@ The Token functionality will always apply to Token-2022.
 ## Source
 
 The Token-2022 Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library/tree/master/token/program-2022).
+[GitHub](https://github.com/solana-program/token-2022).
 
 For information about the types and instructions, the Rust docs are available at
 [docs.rs](https://docs.rs/spl-token-2022/latest/spl_token_2022/).
@@ -141,19 +142,19 @@ Here are the completed audits as of 13 December 2023:
 
 * Halborn
     - Review commit hash [`c3137a`](https://github.com/solana-labs/solana-program-library/tree/c3137af9dfa2cc0873cc84c4418dea88ac542965/token/program-2022)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/HalbornToken2022Audit-2022-07-27.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/HalbornToken2022Audit-2022-07-27.pdf
 * Zellic
     - Review commit hash [`54695b`](https://github.com/solana-labs/solana-program-library/tree/54695b233484722458b18c0e26ebb8334f98422c/token/program-2022)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/ZellicToken2022Audit-2022-12-05.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/ZellicToken2022Audit-2022-12-05.pdf
 * Trail of Bits
     - Review commit hash [`50abad`](https://github.com/solana-labs/solana-program-library/tree/50abadd819df2e406567d6eca31c213264c1c7cd/token/program-2022)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/TrailOfBitsToken2022Audit-2023-02-10.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/TrailOfBitsToken2022Audit-2023-02-10.pdf
 * NCC Group
     - Review commit hash [`4e43aa`](https://github.com/solana-labs/solana/tree/4e43aa6c18e6bb4d98559f80eb004de18bc6b418/zk-token-sdk)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/NCCToken2022Audit-2023-04-05.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/NCCToken2022Audit-2023-04-05.pdf
 * OtterSec
     - Review commit hash [`e92413`](https://github.com/solana-labs/solana-program-library/tree/e924132d65ba0896249fb4983f6f97caff15721a)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecToken2022Audit-2023-11-03.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/OtterSecToken2022Audit-2023-11-03.pdf
 * OtterSec (ZK Token SDK)
     - Review commit hash [`9e703f8`](https://github.com/solana-labs/solana/tree/9e703f8/zk-token-sdk)
-    - Final report https://github.com/solana-labs/security-audits/blob/master/spl/OtterSecZkTokenSdkAudit-2023-11-04.pdf
+    - Final report https://github.com/anza-xyz/security-audits/blob/master/spl/OtterSecZkTokenSdkAudit-2023-11-04.pdf
diff --git a/docs/src/token-2022/extensions.mdx b/docs/src/token-2022/extensions.mdx
index d19c15de383..4fd48665e1f 100644
--- a/docs/src/token-2022/extensions.mdx
+++ b/docs/src/token-2022/extensions.mdx
@@ -22,7 +22,7 @@ See the [Token Setup Guide](../token#setup) to install the client utilities.
 Token-2022 shares the same CLI and NPM packages for maximal compatibility.
 
 All JS examples are adapted from the tests, and available in full at the
-[Token JS examples](https://github.com/solana-labs/solana-program-library/tree/master/token/js/examples).
+[Token JS examples](https://github.com/solana-program/token-2022/tree/main/clients/js-legacy/examples).
 
 ## Extensions
 
@@ -165,7 +165,7 @@ tokens.
   <TabItem value="cli" label="CLI" default>
 
 ```console
-$ spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token --transfer-fee 50 5000
+$ spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token --transfer-fee-basis-points 50 --transfer-fee-maximum-fee 5000
 Creating token Dg3i18BN7vzsbAZDnDv3H8nQQjSaPUTqhwX41J7NZb5H under program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
 
 Address:  Dg3i18BN7vzsbAZDnDv3H8nQQjSaPUTqhwX41J7NZb5H
@@ -1528,29 +1528,29 @@ explained in detail in many of the linked `README` files below under
 #### Resources
 
 The interface description and structs exist at
-[spl-transfer-hook-interface](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface),
+[spl-transfer-hook-interface](https://github.com/solana-program/transfer-hook/tree/main/interface),
 along with a sample minimal program implementation. You can find detailed
 instructions on how to implement this interface for an on-chain program or
 interact with a program that implements transfer-hook in the repository's
-[README](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface/README.md).
+[README](https://github.com/solana-program/transfer-hook/tree/main/interface/README.md).
 
 The `spl-transfer-hook-interface` library provides offchain and onchain helpers
 for resolving the additional accounts required. See
-[invoke.rs](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface/src/invoke.rs)
+[onchain.rs](https://github.com/solana-program/transfer-hook/blob/main/interface/src/onchain.rs)
 for usage on-chain, and
-[offchain.rs](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface/src/offchain.rs)
+[offchain.rs](https://github.com/solana-program/transfer-hook/blob/main/interface/src/offchain.rs)
 for fetching the additional required account metas with any async off-chain client
 like `BanksClient` or `RpcClient`.
 
 A usable example program exists at
-[spl-transfer-hook-example](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/example).
+[spl-transfer-hook-example](https://github.com/solana-program/transfer-hook/tree/main/program).
 Token-2022 uses this example program in tests to ensure that it properly uses
 the transfer hook interface.
 
 The example program and the interface are powered by the
-[spl-tlv-account-resolution](https://github.com/solana-labs/solana-program-library/tree/master/libraries/tlv-account-resolution)
+[spl-tlv-account-resolution](https://github.com/solana-program/libraries/tree/main/tlv-account-resolution)
 library, which is explained in detail in the repository's 
-[README](https://github.com/solana-labs/solana-program-library/tree/master/libraries/tlv-account-resolution/README.md)
+[README](https://github.com/solana-program/libraries/tree/main/tlv-account-resolution/README.md)
 
 #### Example: Create a mint with a transfer hook
 
@@ -1660,7 +1660,7 @@ await updateTransferHook(
 #### Example: Manage a transfer-hook program
 
 A sample CLI for managing a transfer-hook program exists at
-[spl-transfer-hook-cli](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/cli).
+[spl-transfer-hook-cli](https://github.com/solana-program/transfer-hook/tree/main/clients/cli).
 A mint manager can fork the tool for their own program.
 
 It only contains a command to create the required transfer-hook account for the
@@ -1720,7 +1720,7 @@ To facilitate token-metadata usage, Token-2022 allows a mint creator to include
 their token's metadata directly in the mint account.
 
 Token-2022 implements all of the instructions from the
-[spl-token-metadata-interface](https://github.com/solana-labs/solana-program-library/tree/master/token-metadata/interface).
+[spl-token-metadata-interface](https://github.com/solana-program/token-metadata/tree/main/interface).
 
 The metadata extension should work directly with the metadata-pointer extension.
 During mint creation, you should also add the metadata-pointer extension, pointed
@@ -1966,7 +1966,7 @@ configurations for a group, which describe things like the update authority
 and the group's maximum size, can be stored directly in the mint itself.
 
 Token-2022 implements all of the instructions from the
-[spl-token-group-interface](https://github.com/solana-labs/solana-program-library/tree/master/token-group/interface).
+[spl-token-group-interface](https://github.com/solana-program/token-group/tree/main/interface).
 
 The group extension works directly with the group-pointer extension.
 To initialize group configurations within a mint, you must add the group-pointer
diff --git a/docs/src/token-2022/presentation.md b/docs/src/token-2022/presentation.md
index 44d5c73272e..cfd072dcc50 100644
--- a/docs/src/token-2022/presentation.md
+++ b/docs/src/token-2022/presentation.md
@@ -25,7 +25,7 @@ title: Presentation
 
 ---
 
-### Are you aware that it's 2023?
+### Are you aware that it's not 2022?
 
 Yes.
 
diff --git a/docs/src/token-2022/status.md b/docs/src/token-2022/status.md
index 8ce6e2a1e9d..dcc414e3ad5 100644
--- a/docs/src/token-2022/status.md
+++ b/docs/src/token-2022/status.md
@@ -6,7 +6,7 @@ All clusters have the latest program deployed **without confidential transfer
 functionality**.
 
 The program with confidential transfer functionality will be deployed once
-Solana v1.17 reaches mainnet-beta with the appropriate syscalls enabled.
+Agave v2.0 reaches mainnet-beta with the appropriate cluster features enabled.
 
 ## Timeline
 
@@ -15,34 +15,23 @@ Here is the general program timeline and rough ETAs:
 | Issue                       | ETA                            |
 | --------------------------- | ------------------------------ |
 | Mainnet recommendation      | Winter 2024 (depends on v1.17) |
-| More ZK features            | Spring 2024 (depends on v1.18) |
-| Freeze program              | 2024                           |
+| Token group extension       | Summer 2024                    |
+| Confidential transfers      | Autumn 2024 (depends on v2.0)  |
+| Freeze program              | 2025                           |
 
 More information: https://github.com/orgs/solana-labs/projects/34
 
 ## Remaining items
 
-### v1.17 with curve syscalls
+### v2.0 with ZK ElGamal Proof Program
 
-In order to use confidential tokens, the cluster must run at least version 1.17
-with the elliptic curve operations syscalls enabled.
+In order to use confidential tokens, the cluster must run at least version 2.0
+with the ZK ElGamal Proof Program enabled.
 
-More information: https://github.com/solana-labs/solana/issues/29612
-
-### Zero-knowledge proof split
-
-In order to use confidential tokens, the cluster must run at least version 1.17
-with the ZK Token proof program enabled.
-
-More information: https://github.com/solana-labs/solana/pull/32613
+More information: https://github.com/anza-xyz/agave/issues/1966
 
 ## Future work
 
-### Confidential transfers with fee
-
-Due to the transaction size limit, it is not possible to do confidential transfers
-with a fee. We plan to include that capability with Solana 1.18.
-
 ### Wallets
 
 To start, wallets need to properly handle the Token-2022 program and its accounts,
diff --git a/docs/src/token.mdx b/docs/src/token.mdx
index 270bb96ec68..cb68488ce67 100644
--- a/docs/src/token.mdx
+++ b/docs/src/token.mdx
@@ -22,17 +22,17 @@ document are available at:
 ## Source
 
 The Token Program's source is available on
-[GitHub](https://github.com/solana-labs/solana-program-library)
+[GitHub](https://github.com/solana-program/token).
 
 ## Interface
 
 The Token Program is written in Rust and available on [crates.io](https://crates.io/crates/spl-token) and [docs.rs](https://docs.rs/spl-token).
 
 Auto-generated C bindings are also available
-[here](https://github.com/solana-labs/solana-program-library/blob/master/token/program/inc/token.h)
+[here](https://github.com/solana-program/token/blob/main/program/inc/token.h)
 
 [JavaScript
-bindings](https://github.com/solana-labs/solana-program-library/tree/master/token/js)
+bindings](https://github.com/solana-program/token-2022/tree/main/clients/js-legacy)
 are available that support loading the Token Program on to a chain and issue
 instructions.
 
@@ -113,7 +113,7 @@ const web3 = require('@solana/web3.js');
 const connection = new web3.Connection(web3.clusterApiUrl('devnet'), 'confirmed');
 ```
 ### Keypair
-You can either get your keypair using [`Keypair`](https://solana-labs.github.io/solana-web3.js/classes/Keypair.html) from `@solana/web3.js`, or let the user's wallet handle the keypair and use `sendTransaction` from [`wallet-adapter`](https://github.com/solana-labs/wallet-adapter)
+You can either get your keypair using [`Keypair`](https://solana-labs.github.io/solana-web3.js/v1.x/classes/Keypair.html) from `@solana/web3.js`, or let the user's wallet handle the keypair and use `sendTransaction` from [`wallet-adapter`](https://github.com/solana-labs/wallet-adapter)
 
   </TabItem>
 </Tabs>
@@ -1677,6 +1677,11 @@ require the Solana account being initialized also be a signer. The
 instruction that creates the Solana account by including both instructions in
 the same transaction.
 
+Also, multisignatures allow for duplicate accounts in the signer sets, for very
+simple weighting systems. For example, a 2 of 4 multisig can be constructed with
+3 unique pubkeys, and one pubkey specified twice to give that pubkey double
+voting power.
+
 ### Freezing accounts
 
 The Mint may also contain a `freeze_authority` which can be used to issue
@@ -1874,7 +1879,7 @@ Unlocking works by pushing a permissionless crank on the contract that moves the
 - Audit: The audit was conducted by Kudelski, the report can be found [here](https://github.com/Bonfida/token-vesting/blob/master/audit/Bonfida_SecurityAssessment_Vesting_Final050521.pdf)
 
 #### 2) Streamflow Timelock
-Enables creation, withdrawal, cancelation and transfer of token vesting contracts using time-based lock and escrow accounts.
+Enables creation, withdrawal, cancellation and transfer of token vesting contracts using time-based lock and escrow accounts.
 Contracts are by default cancelable by the creator and transferable by the recipient.
 
 Vesting contract creator chooses various options upon creation, such as:
diff --git a/docs/src/transfer-hook-interface.md b/docs/src/transfer-hook-interface.md
index a39f36adf87..b7d12bdc4c4 100644
--- a/docs/src/transfer-hook-interface.md
+++ b/docs/src/transfer-hook-interface.md
@@ -9,7 +9,7 @@ During transfers, Token-2022 calls a mint's configured transfer hook program
 using this interface, as described in the
 [Transfer Hook Extension Guide](../../token-2022/extensions#transfer-hook).
 Additionally, a
-[reference implementation](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/example)
+[reference implementation](https://github.com/solana-program/transfer-hook/tree/main/program)
 can be found in the SPL GitHub repository, detailing
 how one might implement this interface in their own program.
 
diff --git a/docs/src/transfer-hook-interface/configuring-extra-accounts.md b/docs/src/transfer-hook-interface/configuring-extra-accounts.md
index 7de29932ccb..2587b69929d 100644
--- a/docs/src/transfer-hook-interface/configuring-extra-accounts.md
+++ b/docs/src/transfer-hook-interface/configuring-extra-accounts.md
@@ -43,7 +43,7 @@ of entries.
 
 This custom slice structure is called a `PodSlice` and is part of the Solana
 Program Library's
-[Pod](https://github.com/solana-labs/solana-program-library/tree/master/libraries/pod)
+[Pod](https://github.com/solana-program/libraries/tree/main/pod)
 library. The Pod library provides a handful of fixed-length types that
 implement the `bytemuck`
 [`Pod`](https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html) trait, as well
@@ -51,7 +51,7 @@ as the `PodSlice`.
 
 Another SPL library
 useful for Type-Length-Value encoded data is
-[Type-Length-Value](https://github.com/solana-labs/solana-program-library/tree/master/libraries/type-length-value)
+[Type-Length-Value](https://github.com/solana-program/libraries/tree/main/type-length-value)
 which is used extensively to manage TLV-encoded data structures.
 
 ### Dynamic Account Resolution
@@ -62,7 +62,7 @@ required accounts you've specified in the validation account.
 
 These additional accounts must be _resolved_, and another library used to pull off
 the resolution of additional accounts for transfer hooks is
-[TLV Account Resolution](https://github.com/solana-labs/solana-program-library/tree/master/libraries/tlv-account-resolution).
+[TLV Account Resolution](https://github.com/solana-program/libraries/tree/main/tlv-account-resolution).
 
 Using the TLV Account Resolution library, transfer hook programs can empower
 **dynamic account resolution** of additional required accounts. This means that
@@ -72,9 +72,9 @@ validation account's data.
 
 In fact, the Transfer Hook interface offers helpers that perform this account
 resolution in the
-[onchain](https://github.com/solana-labs/solana-program-library/blob/master/token/transfer-hook/interface/src/onchain.rs)
+[onchain](https://github.com/solana-program/transfer-hook/blob/main/interface/src/onchain.rs)
 and
-[offchain](https://github.com/solana-labs/solana-program-library/blob/master/token/transfer-hook/interface/src/offchain.rs)
+[offchain](https://github.com/solana-program/transfer-hook/blob/main/interface/src/offchain.rs)
 modules of the Transfer Hook interface crate.
 
 The account resolution is powered by the way configurations for additional
@@ -84,7 +84,7 @@ and roles (signer, writeable, etc.) for accounts.
 ### The `ExtraAccountMeta` Struct
 
 A member of the TLV Account Resolution library, the
-[`ExtraAccountMeta`](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/libraries/tlv-account-resolution/src/account.rs#L75)
+[`ExtraAccountMeta`](https://github.com/solana-program/libraries/blob/c5cc979f188ddc136de2ff556173a6f655322915/tlv-account-resolution/src/account.rs#L123)
 struct allows account configurations to be serialized into a fixed-length data
 format of length 35 bytes.
 
@@ -130,7 +130,7 @@ Well, you don't. Instead, you tell the account resolution functionality _where_
 to find the seeds you need.
 
 To do this, the transfer hook program can use the
-[`Seed`](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/libraries/tlv-account-resolution/src/seeds.rs#L38)
+[`Seed`](https://github.com/solana-program/libraries/blob/c5cc979f188ddc136de2ff556173a6f655322915/tlv-account-resolution/src/seeds.rs#L38)
 enum to describe their seeds and where to find them. With the exception of
 literals, these seed configurations comprise only a small handful of bytes.
 
diff --git a/docs/src/transfer-hook-interface/examples.md b/docs/src/transfer-hook-interface/examples.md
index 7cc01943081..7a4fc1ed0b8 100644
--- a/docs/src/transfer-hook-interface/examples.md
+++ b/docs/src/transfer-hook-interface/examples.md
@@ -3,14 +3,14 @@ title: Examples
 ---
 
 More examples can be found in the
-[Transfer Hook example tests](https://github.com/solana-labs/solana-program-library/blob/master/token/transfer-hook/example/tests/functional.rs),
+[Transfer Hook example tests](https://github.com/solana-program/transfer-hook/blob/main/program/tests/functional.rs),
 as well as the
-[TLV Account Resolution tests](https://github.com/solana-labs/solana-program-library/blob/master/libraries/tlv-account-resolution/src/state.rs).
+[TLV Account Resolution tests](https://github.com/solana-program/libraries/blob/main/tlv-account-resolution/src/state.rs).
 
 ### Initializing Extra Account Metas On-Chain
 
 The
-[`ExtraAccountMetaList`](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/libraries/tlv-account-resolution/src/state.rs#L167)
+[`ExtraAccountMetaList`](https://github.com/solana-program/libraries/blob/c5cc979f188ddc136de2ff556173a6f655322915/tlv-account-resolution/src/state.rs#L164)
 struct is designed to make working with extra account
 configurations as seamless as possible.
 
@@ -19,12 +19,12 @@ serialized `ExtraAccountMeta` configurations by simply providing a mutable
 reference to the buffer and a slice of `ExtraAccountMeta`. The generic `T` is
 the instruction whose discriminator the extra account configurations should be
 assigned to. In our case, this will be
-[`spl_transfer_hook_interface::instruction::ExecuteInstruction`](https://github.com/solana-labs/solana-program-library/blob/eb32c5e72c6d917e732bded9863db7657b23e428/token/transfer-hook/interface/src/instruction.rs#L68)
+[`spl_transfer_hook_interface::instruction::ExecuteInstruction`](https://github.com/solana-program/transfer-hook/blob/e00f3b5c591fd55b4aed6a1e9b1ccc502cb6da05/interface/src/instruction.rs#L67)
 from the Transfer Hook interface.
 
 > Note: All instructions from the SPL Transfer Hook interface implement the
 > trait
-> [`SplDiscriminate`](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/libraries/discriminator/src/discriminator.rs#L9),
+> [`SplDiscriminate`](https://github.com/solana-program/libraries/blob/c5cc979f188ddc136de2ff556173a6f655322915/discriminator/src/discriminator.rs#L10),
 > which provides a constant 8-byte discriminator that
 > can be used to create a TLV data entry.
 
@@ -83,7 +83,7 @@ program directly or for a program that will CPI to your transfer hook program,
 you must include all required accounts - including the extra accounts.
 
 Below is an example of the logic contained in the Transfer Hook interface's
-[offchain helper](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/token/transfer-hook/interface/src/offchain.rs#L50).
+[offchain helper](https://github.com/solana-program/transfer-hook/blob/e00f3b5c591fd55b4aed6a1e9b1ccc502cb6da05/interface/src/offchain.rs#L48).
 
 ```rust
 // You'll need to provide an "account data function", which is a function that
@@ -151,7 +151,7 @@ offchain account resolution, the executing program has to know how to build a
 CPI instruction with the proper accounts as well!
 
 Below is an example of the logic contained in the Transfer Hook interface's
-[onchain helper](https://github.com/solana-labs/solana-program-library/blob/65a92e6e0a4346920582d9b3893cacafd85bb017/token/transfer-hook/interface/src/onchain.rs#L67).
+[onchain helper](https://github.com/solana-program/transfer-hook/blob/e00f3b5c591fd55b4aed6a1e9b1ccc502cb6da05/interface/src/onchain.rs#L15).
 
 ```rust
 // Find the validation account from the list of `AccountInfo`s and load its
diff --git a/docs/src/transfer-hook-interface/specification.md b/docs/src/transfer-hook-interface/specification.md
index 723920e01b5..47570f4694f 100644
--- a/docs/src/transfer-hook-interface/specification.md
+++ b/docs/src/transfer-hook-interface/specification.md
@@ -36,7 +36,7 @@ The next two instructions of the interface deal with these configurations.
 
 ### (Optional) Instruction: `InitializeExtraAccountMetaList`
 
-This instruction does exactly what the name implies: it intializes the
+This instruction does exactly what the name implies: it initializes the
 validation account to store a list of extra required
 [`AccountMeta`](https://docs.rs/solana-program/latest/solana_program/instruction/struct.AccountMeta.html)
 configurations for the `Execute` instruction.
diff --git a/examples/rust/cross-program-invocation/Cargo.toml b/examples/rust/cross-program-invocation/Cargo.toml
index ecc179644a3..ca6cf3a81d4 100644
--- a/examples/rust/cross-program-invocation/Cargo.toml
+++ b/examples/rust/cross-program-invocation/Cargo.toml
@@ -13,11 +13,11 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/examples/rust/cross-program-invocation/tests/functional.rs b/examples/rust/cross-program-invocation/tests/functional.rs
index ebf253cd989..e0c924abac3 100644
--- a/examples/rust/cross-program-invocation/tests/functional.rs
+++ b/examples/rust/cross-program-invocation/tests/functional.rs
@@ -33,7 +33,7 @@ async fn test_cross_program_invocation() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
+    let (banks_client, payer, recent_blockhash) = program_test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[Instruction::new_with_bincode(
diff --git a/examples/rust/custom-heap/Cargo.toml b/examples/rust/custom-heap/Cargo.toml
index d91eb9d3e63..93eaca3022e 100644
--- a/examples/rust/custom-heap/Cargo.toml
+++ b/examples/rust/custom-heap/Cargo.toml
@@ -15,14 +15,17 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[lints]
+workspace = true
diff --git a/examples/rust/custom-heap/src/entrypoint.rs b/examples/rust/custom-heap/src/entrypoint.rs
index ba448c3f579..16232528e38 100644
--- a/examples/rust/custom-heap/src/entrypoint.rs
+++ b/examples/rust/custom-heap/src/entrypoint.rs
@@ -2,19 +2,19 @@
 
 #![cfg(not(feature = "no-entrypoint"))]
 
+use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
+#[cfg(target_os = "solana")]
 use {
-    solana_program::{
-        account_info::AccountInfo,
-        entrypoint::{ProgramResult, HEAP_LENGTH, HEAP_START_ADDRESS},
-        pubkey::Pubkey,
-    },
+    solana_program::entrypoint::{HEAP_LENGTH, HEAP_START_ADDRESS},
     std::{alloc::Layout, mem::size_of, ptr::null_mut, usize},
 };
 
 /// Developers can implement their own heap by defining their own
 /// `#[global_allocator]`.  The following implements a dummy for test purposes
 /// but can be flushed out with whatever the developer sees fit.
+#[cfg(target_os = "solana")]
 struct BumpAllocator;
+#[cfg(target_os = "solana")]
 unsafe impl std::alloc::GlobalAlloc for BumpAllocator {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
diff --git a/examples/rust/custom-heap/tests/functional.rs b/examples/rust/custom-heap/tests/functional.rs
index 98a3585ca37..a4575e0532b 100644
--- a/examples/rust/custom-heap/tests/functional.rs
+++ b/examples/rust/custom-heap/tests/functional.rs
@@ -9,7 +9,7 @@ use {
 #[tokio::test]
 async fn test_custom_heap() {
     let program_id = Pubkey::from_str("CustomHeap111111111111111111111111111111111").unwrap();
-    let (mut banks_client, payer, recent_blockhash) = ProgramTest::new(
+    let (banks_client, payer, recent_blockhash) = ProgramTest::new(
         "spl_example_custom_heap",
         program_id,
         processor!(process_instruction),
diff --git a/examples/rust/logging/Cargo.toml b/examples/rust/logging/Cargo.toml
index 390e4024489..70312922678 100644
--- a/examples/rust/logging/Cargo.toml
+++ b/examples/rust/logging/Cargo.toml
@@ -13,11 +13,11 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/examples/rust/logging/tests/functional.rs b/examples/rust/logging/tests/functional.rs
index a36a02931d3..e822cb1e9d1 100644
--- a/examples/rust/logging/tests/functional.rs
+++ b/examples/rust/logging/tests/functional.rs
@@ -12,7 +12,7 @@ use {
 #[tokio::test]
 async fn test_logging() {
     let program_id = Pubkey::from_str("Logging111111111111111111111111111111111111").unwrap();
-    let (mut banks_client, payer, recent_blockhash) = ProgramTest::new(
+    let (banks_client, payer, recent_blockhash) = ProgramTest::new(
         "spl_example_logging",
         program_id,
         processor!(process_instruction),
diff --git a/examples/rust/sysvar/Cargo.toml b/examples/rust/sysvar/Cargo.toml
index 0b483b91c16..ec5b7c62a39 100644
--- a/examples/rust/sysvar/Cargo.toml
+++ b/examples/rust/sysvar/Cargo.toml
@@ -13,11 +13,11 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/examples/rust/sysvar/tests/functional.rs b/examples/rust/sysvar/tests/functional.rs
index e67c980e0f1..171d2c0078d 100644
--- a/examples/rust/sysvar/tests/functional.rs
+++ b/examples/rust/sysvar/tests/functional.rs
@@ -13,7 +13,7 @@ use {
 #[tokio::test]
 async fn test_sysvar() {
     let program_id = Pubkey::from_str("Sysvar1111111111111111111111111111111111111").unwrap();
-    let (mut banks_client, payer, recent_blockhash) = ProgramTest::new(
+    let (banks_client, payer, recent_blockhash) = ProgramTest::new(
         "spl_example_sysvar",
         program_id,
         processor!(process_instruction),
diff --git a/examples/rust/transfer-lamports/Cargo.toml b/examples/rust/transfer-lamports/Cargo.toml
index 37f5ddc8c95..d571eab3641 100644
--- a/examples/rust/transfer-lamports/Cargo.toml
+++ b/examples/rust/transfer-lamports/Cargo.toml
@@ -12,11 +12,11 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/examples/rust/transfer-lamports/tests/functional.rs b/examples/rust/transfer-lamports/tests/functional.rs
index d373859224c..0dcd1c9e7f3 100644
--- a/examples/rust/transfer-lamports/tests/functional.rs
+++ b/examples/rust/transfer-lamports/tests/functional.rs
@@ -34,7 +34,7 @@ async fn test_lamport_transfer() {
             ..Account::default()
         },
     );
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
+    let (banks_client, payer, recent_blockhash) = program_test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[Instruction::new_with_bincode(
diff --git a/examples/rust/transfer-tokens/Cargo.toml b/examples/rust/transfer-tokens/Cargo.toml
index 3d05c19a203..52f0e02c6e1 100644
--- a/examples/rust/transfer-tokens/Cargo.toml
+++ b/examples/rust/transfer-tokens/Cargo.toml
@@ -12,12 +12,12 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../../token/program", features = [ "no-entrypoint" ] }
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [ "no-entrypoint" ] }
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/examples/rust/transfer-tokens/tests/functional.rs b/examples/rust/transfer-tokens/tests/functional.rs
index ef5a0ef2332..b03f82b5433 100644
--- a/examples/rust/transfer-tokens/tests/functional.rs
+++ b/examples/rust/transfer-tokens/tests/functional.rs
@@ -33,7 +33,7 @@ async fn success() {
     let rent = Rent::default();
 
     // Start the program test
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
+    let (banks_client, payer, recent_blockhash) = program_test.start().await;
 
     // Setup the mint, used in `spl_token::instruction::transfer_checked`
     let transaction = Transaction::new_signed_with_payer(
diff --git a/feature-proposal/README.md b/feature-proposal/README.md
new file mode 100644
index 00000000000..b5637f9a4a5
--- /dev/null
+++ b/feature-proposal/README.md
@@ -0,0 +1,2 @@
+NOTE: The feature-proposal program and clients are now maintained at
+[solana-program/feature-proposal](https://github.com/solana-program/feature-proposal).
diff --git a/feature-proposal/cli/Cargo.toml b/feature-proposal/cli/Cargo.toml
deleted file mode 100644
index 563489d8e36..00000000000
--- a/feature-proposal/cli/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[package]
-name = "spl-feature-proposal-cli"
-version = "1.2.0"
-description = "SPL Feature Proposal Command-line Utility"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-chrono = "0.4.38"
-clap = "2.33.3"
-solana-clap-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-feature-proposal = { version = "1.0", path = "../program", features = ["no-entrypoint"] }
-
-[[bin]]
-name = "spl-feature-proposal"
-path = "src/main.rs"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/feature-proposal/cli/src/main.rs b/feature-proposal/cli/src/main.rs
deleted file mode 100644
index e3a40fee622..00000000000
--- a/feature-proposal/cli/src/main.rs
+++ /dev/null
@@ -1,486 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-use {
-    chrono::{DateTime, SecondsFormat, Utc},
-    clap::{
-        crate_description, crate_name, crate_version, value_t_or_exit, App, AppSettings, Arg,
-        SubCommand,
-    },
-    solana_clap_utils::{
-        input_parsers::{keypair_of, pubkey_of},
-        input_validators::{is_keypair, is_url, is_valid_percentage, is_valid_pubkey},
-    },
-    solana_client::rpc_client::RpcClient,
-    solana_sdk::{
-        clock::UnixTimestamp,
-        commitment_config::CommitmentConfig,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{read_keypair_file, Keypair, Signer},
-        transaction::Transaction,
-    },
-    spl_feature_proposal::state::{AcceptanceCriteria, FeatureProposal},
-    std::{
-        collections::HashMap,
-        fs::File,
-        io::Write,
-        time::{Duration, SystemTime, UNIX_EPOCH},
-    },
-};
-
-struct Config {
-    keypair: Keypair,
-    json_rpc_url: String,
-    verbose: bool,
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let app_matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(crate_version!())
-        .setting(AppSettings::SubcommandRequiredElseHelp)
-        .arg({
-            let arg = Arg::with_name("config_file")
-                .short("C")
-                .long("config")
-                .value_name("PATH")
-                .takes_value(true)
-                .global(true)
-                .help("Configuration file to use");
-            if let Some(ref config_file) = *solana_cli_config::CONFIG_FILE {
-                arg.default_value(config_file)
-            } else {
-                arg
-            }
-        })
-        .arg(
-            Arg::with_name("keypair")
-                .long("keypair")
-                .value_name("KEYPAIR")
-                .validator(is_keypair)
-                .takes_value(true)
-                .global(true)
-                .help("Filepath or URL to a keypair [default: client keypair]"),
-        )
-        .arg(
-            Arg::with_name("verbose")
-                .long("verbose")
-                .short("v")
-                .takes_value(false)
-                .global(true)
-                .help("Show additional information"),
-        )
-        .arg(
-            Arg::with_name("json_rpc_url")
-                .long("url")
-                .value_name("URL")
-                .takes_value(true)
-                .global(true)
-                .validator(is_url)
-                .help("JSON RPC URL for the cluster [default: value from configuration file]"),
-        )
-        .subcommand(
-            SubCommand::with_name("address")
-                .about("Display address information for the feature proposal")
-                .arg(
-                    Arg::with_name("feature_proposal")
-                        .value_name("FEATURE_PROPOSAL_ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the feature proposal"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("propose")
-                .about("Initiate a feature proposal")
-                .arg(
-                    Arg::with_name("feature_proposal")
-                        .value_name("FEATURE_PROPOSAL_KEYPAIR")
-                        .validator(is_keypair)
-                        .index(1)
-                        .required(true)
-                        .help("The keypair of the feature proposal"),
-                )
-                .arg(
-                    Arg::with_name("percent_stake_required")
-                        .long("percent-stake-required")
-                        .value_name("PERCENTAGE")
-                        .validator(is_valid_percentage)
-                        .required(true)
-                        .default_value("67")
-                        .help("Percentage of the active stake required for the proposal to pass"),
-                )
-                .arg(
-                    Arg::with_name("distribution_file")
-                        .long("distribution-file")
-                        .value_name("FILENAME")
-                        .required(true)
-                        .default_value("feature-proposal.csv")
-                        .help("Allocations CSV file for use with solana-tokens"),
-                )
-                .arg(
-                    Arg::with_name("confirm")
-                        .long("confirm")
-                        .help("Confirm that the feature proposal should actually be initiated"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name("tally")
-                .about("Tally the current results for a proposed feature")
-                .arg(
-                    Arg::with_name("feature_proposal")
-                        .value_name("FEATURE_PROPOSAL_ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the feature proposal"),
-                ),
-        )
-        .get_matches();
-
-    let (sub_command, sub_matches) = app_matches.subcommand();
-    let matches = sub_matches.unwrap();
-
-    let config = {
-        let cli_config = if let Some(config_file) = matches.value_of("config_file") {
-            solana_cli_config::Config::load(config_file).unwrap_or_default()
-        } else {
-            solana_cli_config::Config::default()
-        };
-
-        Config {
-            json_rpc_url: matches
-                .value_of("json_rpc_url")
-                .unwrap_or(&cli_config.json_rpc_url)
-                .to_string(),
-            keypair: read_keypair_file(
-                matches
-                    .value_of("keypair")
-                    .unwrap_or(&cli_config.keypair_path),
-            )?,
-            verbose: matches.is_present("verbose"),
-        }
-    };
-    solana_logger::setup_with_default("solana=info");
-    let rpc_client =
-        RpcClient::new_with_commitment(config.json_rpc_url.clone(), CommitmentConfig::confirmed());
-
-    match (sub_command, sub_matches) {
-        ("address", Some(arg_matches)) => {
-            let feature_proposal_address = pubkey_of(arg_matches, "feature_proposal").unwrap();
-
-            println!(
-                "Feature Id: {}",
-                spl_feature_proposal::get_feature_id_address(&feature_proposal_address)
-            );
-            println!(
-                "Token Mint Address: {}",
-                spl_feature_proposal::get_mint_address(&feature_proposal_address)
-            );
-            println!(
-                "Acceptance Token Address: {}",
-                spl_feature_proposal::get_acceptance_token_address(&feature_proposal_address)
-            );
-
-            Ok(())
-        }
-        ("propose", Some(arg_matches)) => {
-            let feature_proposal_keypair = keypair_of(arg_matches, "feature_proposal").unwrap();
-            let distribution_file = value_t_or_exit!(arg_matches, "distribution_file", String);
-            let percent_stake_required =
-                value_t_or_exit!(arg_matches, "percent_stake_required", u8);
-
-            // Hard code deadline for now...
-            let fortnight = Duration::from_secs(60 * 60 * 24 * 14);
-            let deadline = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .checked_add(fortnight)
-                .unwrap()
-                .as_secs() as UnixTimestamp;
-
-            process_propose(
-                &rpc_client,
-                &config,
-                &feature_proposal_keypair,
-                distribution_file,
-                percent_stake_required,
-                deadline,
-                arg_matches.is_present("confirm"),
-            )
-        }
-        ("tally", Some(arg_matches)) => {
-            if config.verbose {
-                println!("JSON RPC URL: {}", config.json_rpc_url);
-            }
-
-            let feature_proposal_address = pubkey_of(arg_matches, "feature_proposal").unwrap();
-            process_tally(&rpc_client, &config, &feature_proposal_address)
-        }
-        _ => unreachable!(),
-    }
-}
-
-fn get_feature_proposal(
-    rpc_client: &RpcClient,
-    feature_proposal_address: &Pubkey,
-) -> Result<FeatureProposal, String> {
-    let account = rpc_client
-        .get_multiple_accounts(&[*feature_proposal_address])
-        .map_err(|err| err.to_string())?
-        .into_iter()
-        .next()
-        .unwrap();
-
-    match account {
-        None => Err(format!(
-            "Feature proposal {} does not exist",
-            feature_proposal_address
-        )),
-        Some(account) => FeatureProposal::unpack_from_slice(&account.data).map_err(|err| {
-            format!(
-                "Failed to deserialize feature proposal {}: {}",
-                feature_proposal_address, err
-            )
-        }),
-    }
-}
-
-fn unix_timestamp_to_string(unix_timestamp: UnixTimestamp) -> String {
-    format!(
-        "{} (UnixTimestamp: {})",
-        DateTime::<Utc>::from_timestamp(unix_timestamp, 0)
-            .map(|x| x.to_rfc3339_opts(SecondsFormat::Secs, true))
-            .unwrap_or("unknown".to_string()),
-        unix_timestamp,
-    )
-}
-
-fn process_propose(
-    rpc_client: &RpcClient,
-    config: &Config,
-    feature_proposal_keypair: &Keypair,
-    distribution_file: String,
-    percent_stake_required: u8,
-    deadline: UnixTimestamp,
-    confirm: bool,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let distributor_token_address =
-        spl_feature_proposal::get_distributor_token_address(&feature_proposal_keypair.pubkey());
-    let feature_id_address =
-        spl_feature_proposal::get_feature_id_address(&feature_proposal_keypair.pubkey());
-    let acceptance_token_address =
-        spl_feature_proposal::get_acceptance_token_address(&feature_proposal_keypair.pubkey());
-    let mint_address = spl_feature_proposal::get_mint_address(&feature_proposal_keypair.pubkey());
-
-    println!("Feature Id: {}", feature_id_address);
-    println!("Token Mint Address: {}", mint_address);
-    println!("Distributor Token Address: {}", distributor_token_address);
-    println!("Acceptance Token Address: {}", acceptance_token_address);
-
-    let vote_accounts = rpc_client.get_vote_accounts()?;
-    let mut distribution = HashMap::new();
-    for (pubkey, activated_stake) in vote_accounts
-        .current
-        .into_iter()
-        .chain(vote_accounts.delinquent)
-        .map(|vote_account| (vote_account.node_pubkey, vote_account.activated_stake))
-    {
-        distribution
-            .entry(pubkey)
-            .and_modify(|e| *e += activated_stake)
-            .or_insert(activated_stake);
-    }
-
-    let tokens_to_mint: u64 = distribution.iter().map(|x| x.1).sum();
-    let tokens_required = tokens_to_mint * percent_stake_required as u64 / 100;
-
-    println!("Number of validators: {}", distribution.len());
-    println!(
-        "Tokens to be minted: {}",
-        spl_feature_proposal::amount_to_ui_amount(tokens_to_mint)
-    );
-    println!(
-        "Tokens required for acceptance: {} ({}%)",
-        spl_feature_proposal::amount_to_ui_amount(tokens_required),
-        percent_stake_required
-    );
-
-    println!("Token distribution file: {}", distribution_file);
-    {
-        let mut file = File::create(&distribution_file)?;
-        file.write_all(b"recipient,amount\n")?;
-        for (node_address, activated_stake) in distribution.iter() {
-            file.write_all(format!("{},{}\n", node_address, activated_stake).as_bytes())?;
-        }
-    }
-
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_feature_proposal::instruction::propose(
-            &config.keypair.pubkey(),
-            &feature_proposal_keypair.pubkey(),
-            tokens_to_mint,
-            AcceptanceCriteria {
-                tokens_required,
-                deadline,
-            },
-        )],
-        Some(&config.keypair.pubkey()),
-    );
-    let blockhash = rpc_client.get_latest_blockhash()?;
-    transaction.try_sign(&[&config.keypair, feature_proposal_keypair], blockhash)?;
-
-    println!("JSON RPC URL: {}", config.json_rpc_url);
-
-    println!();
-    println!("Distribute the proposal tokens to all validators by running:");
-    println!(
-        "    $ solana-tokens distribute-spl-tokens \
-                  --from {} \
-                  --input-csv {} \
-                  --db-path db.{} \
-                  --fee-payer ~/.config/solana/id.json \
-                  --owner <FEATURE_PROPOSAL_KEYPAIR>",
-        distributor_token_address,
-        distribution_file,
-        &feature_proposal_keypair.pubkey().to_string()[..8]
-    );
-    println!(
-        "    $ solana-tokens spl-token-balances \
-                 --mint {} --input-csv {}",
-        mint_address, distribution_file
-    );
-    println!();
-
-    println!(
-        "Once the distribution is complete, request validators vote for \
-        the proposal by first looking up their token account address:"
-    );
-    println!(
-        "    $ spl-token accounts --owner ~/validator-keypair.json {}",
-        mint_address
-    );
-    println!("and then submit their vote by running:");
-    println!(
-        "    $ spl-token transfer --owner ~/validator-keypair.json <TOKEN_ACCOUNT_ADDRESS> ALL {}",
-        acceptance_token_address
-    );
-    println!();
-    println!("Periodically the votes must be tallied by running:");
-    println!(
-        "  $ spl-feature-proposal tally {}",
-        feature_proposal_keypair.pubkey()
-    );
-    println!("Tallying is permissionless and may be run by anybody.");
-    println!("Once this feature proposal is accepted, the {} feature will be activated at the next epoch.", feature_id_address);
-
-    println!();
-    println!(
-        "Proposal will expire at {}",
-        unix_timestamp_to_string(deadline)
-    );
-    println!();
-    if !confirm {
-        println!("Add --confirm flag to initiate the feature proposal");
-        return Ok(());
-    }
-    rpc_client.send_and_confirm_transaction_with_spinner(&transaction)?;
-
-    println!();
-    println!("Feature proposal created!");
-    Ok(())
-}
-
-fn process_tally(
-    rpc_client: &RpcClient,
-    config: &Config,
-    feature_proposal_address: &Pubkey,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let feature_proposal = get_feature_proposal(rpc_client, feature_proposal_address)?;
-
-    let feature_id_address = spl_feature_proposal::get_feature_id_address(feature_proposal_address);
-    let acceptance_token_address =
-        spl_feature_proposal::get_acceptance_token_address(feature_proposal_address);
-
-    println!("Feature Id: {}", feature_id_address);
-    println!("Acceptance Token Address: {}", acceptance_token_address);
-
-    match feature_proposal {
-        FeatureProposal::Uninitialized => {
-            return Err("Feature proposal is uninitialized".into());
-        }
-        FeatureProposal::Pending(acceptance_criteria) => {
-            let acceptance_token_address =
-                spl_feature_proposal::get_acceptance_token_address(feature_proposal_address);
-            let acceptance_token_balance = rpc_client
-                .get_token_account_balance(&acceptance_token_address)?
-                .amount
-                .parse::<u64>()
-                .unwrap_or(0);
-
-            println!();
-            println!(
-                "{} tokens required to accept the proposal",
-                spl_feature_proposal::amount_to_ui_amount(acceptance_criteria.tokens_required)
-            );
-            println!(
-                "{} tokens have been received",
-                spl_feature_proposal::amount_to_ui_amount(acceptance_token_balance)
-            );
-            println!(
-                "Proposal will expire at {}",
-                unix_timestamp_to_string(acceptance_criteria.deadline)
-            );
-            println!();
-
-            // Don't bother issuing a transaction if it's clear the Tally won't succeed
-            if acceptance_token_balance < acceptance_criteria.tokens_required
-                && (SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .unwrap()
-                    .as_secs() as UnixTimestamp)
-                    < acceptance_criteria.deadline
-            {
-                println!("Feature proposal pending");
-                return Ok(());
-            }
-        }
-        FeatureProposal::Accepted { .. } => {
-            println!("Feature proposal accepted");
-            return Ok(());
-        }
-        FeatureProposal::Expired => {
-            println!("Feature proposal expired");
-            return Ok(());
-        }
-    }
-
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_feature_proposal::instruction::tally(
-            feature_proposal_address,
-        )],
-        Some(&config.keypair.pubkey()),
-    );
-    let blockhash = rpc_client.get_latest_blockhash()?;
-    transaction.try_sign(&[&config.keypair], blockhash)?;
-
-    rpc_client.send_and_confirm_transaction_with_spinner(&transaction)?;
-
-    // Check the status of the proposal after the tally completes
-    let feature_proposal = get_feature_proposal(rpc_client, feature_proposal_address)?;
-    match feature_proposal {
-        FeatureProposal::Uninitialized => Err("Feature proposal is uninitialized".into()),
-        FeatureProposal::Pending { .. } => {
-            println!("Feature proposal pending");
-            Ok(())
-        }
-        FeatureProposal::Accepted { .. } => {
-            println!("Feature proposal accepted");
-            Ok(())
-        }
-        FeatureProposal::Expired => {
-            println!("Feature proposal expired");
-            Ok(())
-        }
-    }
-}
diff --git a/feature-proposal/program/Cargo.toml b/feature-proposal/program/Cargo.toml
deleted file mode 100644
index 2f6b2835fc3..00000000000
--- a/feature-proposal/program/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-name = "spl-feature-proposal"
-version = "1.0.0"
-description = "Solana Program Library Feature Proposal Program"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-borsh = "1.5.1"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/feature-proposal/program/Xargo.toml b/feature-proposal/program/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/feature-proposal/program/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/feature-proposal/program/program-id.md b/feature-proposal/program/program-id.md
deleted file mode 100644
index f1475c155c4..00000000000
--- a/feature-proposal/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-Feat1YXHhH6t1juaWF74WLcfv4XoNocjXA6sPWHNgAse
diff --git a/feature-proposal/program/run-tests.sh b/feature-proposal/program/run-tests.sh
deleted file mode 100755
index 7ee90bf4b3e..00000000000
--- a/feature-proposal/program/run-tests.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-cd "$(dirname "$0")"
-cargo fmt -- --check
-cargo clippy
-cargo build
-cargo build-sbf
-
-if [[ $1 = -v ]]; then
-  export RUST_LOG=solana=debug
-fi
-
-cargo test
-cargo test-sbf
diff --git a/feature-proposal/program/src/entrypoint.rs b/feature-proposal/program/src/entrypoint.rs
deleted file mode 100644
index 62a02f2a465..00000000000
--- a/feature-proposal/program/src/entrypoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Program entrypoint
-
-#![cfg(all(target_os = "solana", not(feature = "no-entrypoint")))]
-
-use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    crate::processor::process_instruction(program_id, accounts, instruction_data)
-}
diff --git a/feature-proposal/program/src/instruction.rs b/feature-proposal/program/src/instruction.rs
deleted file mode 100644
index ea8238e4149..00000000000
--- a/feature-proposal/program/src/instruction.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-//! Program instructions
-
-use {
-    crate::{state::AcceptanceCriteria, *},
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        msg,
-        program_error::ProgramError,
-        program_pack::{Pack, Sealed},
-        pubkey::Pubkey,
-        sysvar,
-    },
-};
-
-/// Instructions supported by the Feature Proposal program
-#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, BorshSchema, PartialEq)]
-pub enum FeatureProposalInstruction {
-    /// Propose a new feature.
-    ///
-    /// This instruction will create a variety of accounts to support the
-    /// feature proposal, all funded by account 0:
-    /// * A new token mint with a supply of `tokens_to_mint`, owned by the
-    ///   program and never modified again
-    /// * A new "distributor" token account that holds the total supply, owned
-    ///   by account 0.
-    /// * A new "acceptance" token account that holds 0 tokens, owned by the
-    ///   program.  Tokens transfers to this address are irrevocable and
-    ///   permanent.
-    /// * A new feature id account that has been funded and allocated (as
-    ///   described in `solana_program::feature`)
-    ///
-    /// On successful execution of the instruction, the feature proposer is
-    /// expected to distribute the tokens in the distributor token account
-    /// out to all participating parties.
-    ///
-    /// Based on the provided acceptance criteria, if
-    /// `AcceptanceCriteria::tokens_required` tokens are transferred into
-    /// the acceptance token account before `AcceptanceCriteria::deadline`
-    /// then the proposal is eligible to be accepted.
-    ///
-    /// The `FeatureProposalInstruction::Tally` instruction must be executed, by
-    /// any party, to complete the feature acceptance process.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writeable,signer]` Funding account (must be a system account)
-    /// 1. `[writeable,signer]` Unallocated feature proposal account to create
-    /// 2. `[writeable]` Token mint address from `get_mint_address`
-    /// 3. `[writeable]` Distributor token account address from
-    ///    `get_distributor_token_address`
-    /// 4. `[writeable]` Acceptance token account address from
-    ///    `get_acceptance_token_address`
-    /// 5. `[writeable]` Feature id account address from
-    ///    `get_feature_id_address`
-    /// 6. `[]` System program
-    /// 7. `[]` SPL Token program
-    /// 8. `[]` Rent sysvar
-    Propose {
-        /// Total number of tokens to mint for this proposal
-        #[allow(dead_code)] // not dead code..
-        tokens_to_mint: u64,
-
-        /// Criteria for how this proposal may be activated
-        #[allow(dead_code)] // not dead code..
-        acceptance_criteria: AcceptanceCriteria,
-    },
-
-    /// `Tally` is a permission-less instruction to check the acceptance
-    /// criteria for the feature proposal, which may result in:
-    /// * No action
-    /// * Feature proposal acceptance
-    /// * Feature proposal expiration
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writeable]` Feature proposal account
-    /// 1. `[]` Acceptance token account address from
-    ///    `get_acceptance_token_address`
-    /// 2. `[writeable]` Derived feature id account address from
-    ///    `get_feature_id_address`
-    /// 3. `[]` System program
-    /// 4. `[]` Clock sysvar
-    Tally,
-}
-
-impl Sealed for FeatureProposalInstruction {}
-impl Pack for FeatureProposalInstruction {
-    const LEN: usize = 25; // see `test_get_packed_len()` for justification of "18"
-
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let data = self.pack_into_vec();
-        dst[..data.len()].copy_from_slice(&data);
-    }
-
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let mut mut_src: &[u8] = src;
-        Self::deserialize(&mut mut_src).map_err(|err| {
-            msg!(
-                "Error: failed to deserialize feature proposal instruction: {}",
-                err
-            );
-            ProgramError::InvalidInstructionData
-        })
-    }
-}
-
-impl FeatureProposalInstruction {
-    fn pack_into_vec(&self) -> Vec<u8> {
-        borsh::to_vec(self).expect("try_to_vec")
-    }
-}
-
-/// Create a `FeatureProposalInstruction::Propose` instruction
-pub fn propose(
-    funding_address: &Pubkey,
-    feature_proposal_address: &Pubkey,
-    tokens_to_mint: u64,
-    acceptance_criteria: AcceptanceCriteria,
-) -> Instruction {
-    let mint_address = get_mint_address(feature_proposal_address);
-    let distributor_token_address = get_distributor_token_address(feature_proposal_address);
-    let acceptance_token_address = get_acceptance_token_address(feature_proposal_address);
-    let feature_id_address = get_feature_id_address(feature_proposal_address);
-
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*funding_address, true),
-            AccountMeta::new(*feature_proposal_address, true),
-            AccountMeta::new(mint_address, false),
-            AccountMeta::new(distributor_token_address, false),
-            AccountMeta::new(acceptance_token_address, false),
-            AccountMeta::new(feature_id_address, false),
-            AccountMeta::new_readonly(solana_program::system_program::id(), false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(sysvar::rent::id(), false),
-        ],
-        data: FeatureProposalInstruction::Propose {
-            tokens_to_mint,
-            acceptance_criteria,
-        }
-        .pack_into_vec(),
-    }
-}
-
-/// Create a `FeatureProposalInstruction::Tally` instruction
-pub fn tally(feature_proposal_address: &Pubkey) -> Instruction {
-    let acceptance_token_address = get_acceptance_token_address(feature_proposal_address);
-    let feature_id_address = get_feature_id_address(feature_proposal_address);
-
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*feature_proposal_address, false),
-            AccountMeta::new_readonly(acceptance_token_address, false),
-            AccountMeta::new(feature_id_address, false),
-            AccountMeta::new_readonly(solana_program::system_program::id(), false),
-            AccountMeta::new_readonly(sysvar::clock::id(), false),
-        ],
-        data: FeatureProposalInstruction::Tally.pack_into_vec(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_packed_len() {
-        assert_eq!(
-            FeatureProposalInstruction::get_packed_len(),
-            solana_program::borsh1::get_packed_len::<FeatureProposalInstruction>()
-        )
-    }
-
-    #[test]
-    fn test_serialize_bytes() {
-        assert_eq!(
-            borsh::to_vec(&FeatureProposalInstruction::Tally).unwrap(),
-            vec![1]
-        );
-
-        assert_eq!(
-            borsh::to_vec(&FeatureProposalInstruction::Propose {
-                tokens_to_mint: 42,
-                acceptance_criteria: AcceptanceCriteria {
-                    tokens_required: 0xdeadbeefdeadbeef,
-                    deadline: -1,
-                }
-            })
-            .unwrap(),
-            vec![
-                0, 42, 0, 0, 0, 0, 0, 0, 0, 239, 190, 173, 222, 239, 190, 173, 222, 255, 255, 255,
-                255, 255, 255, 255, 255
-            ]
-        );
-    }
-
-    #[test]
-    fn test_serialize_large_slice() {
-        let mut dst = vec![0xff; 4];
-        FeatureProposalInstruction::Tally.pack_into_slice(&mut dst);
-
-        // Extra bytes (0xff) ignored
-        assert_eq!(dst, vec![1, 0xff, 0xff, 0xff]);
-    }
-
-    #[test]
-    fn state_deserialize_invalid() {
-        assert_eq!(
-            FeatureProposalInstruction::unpack_from_slice(&[1]),
-            Ok(FeatureProposalInstruction::Tally),
-        );
-
-        // Extra bytes (0xff) ignored...
-        assert_eq!(
-            FeatureProposalInstruction::unpack_from_slice(&[1, 0xff, 0xff, 0xff]),
-            Ok(FeatureProposalInstruction::Tally),
-        );
-
-        assert_eq!(
-            FeatureProposalInstruction::unpack_from_slice(&[2]),
-            Err(ProgramError::InvalidInstructionData),
-        );
-    }
-}
diff --git a/feature-proposal/program/src/lib.rs b/feature-proposal/program/src/lib.rs
deleted file mode 100644
index 52b44bb0bc4..00000000000
--- a/feature-proposal/program/src/lib.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-//! Feature Proposal program
-#![deny(missing_docs)]
-#![forbid(unsafe_code)]
-
-mod entrypoint;
-pub mod instruction;
-pub mod processor;
-pub mod state;
-
-// Export current SDK types for downstream users building with a different SDK
-// version
-pub use solana_program;
-use solana_program::{program_pack::Pack, pubkey::Pubkey};
-
-solana_program::declare_id!("Feat1YXHhH6t1juaWF74WLcfv4XoNocjXA6sPWHNgAse");
-
-pub(crate) fn get_mint_address_with_seed(feature_proposal_address: &Pubkey) -> (Pubkey, u8) {
-    Pubkey::find_program_address(&[&feature_proposal_address.to_bytes(), br"mint"], &id())
-}
-
-pub(crate) fn get_distributor_token_address_with_seed(
-    feature_proposal_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[&feature_proposal_address.to_bytes(), br"distributor"],
-        &id(),
-    )
-}
-
-pub(crate) fn get_acceptance_token_address_with_seed(
-    feature_proposal_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[&feature_proposal_address.to_bytes(), br"acceptance"],
-        &id(),
-    )
-}
-
-pub(crate) fn get_feature_id_address_with_seed(feature_proposal_address: &Pubkey) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[&feature_proposal_address.to_bytes(), br"feature-id"],
-        &id(),
-    )
-}
-
-/// Derive the SPL Token mint address associated with a feature proposal
-pub fn get_mint_address(feature_proposal_address: &Pubkey) -> Pubkey {
-    get_mint_address_with_seed(feature_proposal_address).0
-}
-
-/// Derive the SPL Token token address associated with a feature proposal that
-/// receives the initial minted tokens
-pub fn get_distributor_token_address(feature_proposal_address: &Pubkey) -> Pubkey {
-    get_distributor_token_address_with_seed(feature_proposal_address).0
-}
-
-/// Derive the SPL Token token address associated with a feature proposal that
-/// users send their tokens to accept the proposal
-pub fn get_acceptance_token_address(feature_proposal_address: &Pubkey) -> Pubkey {
-    get_acceptance_token_address_with_seed(feature_proposal_address).0
-}
-
-/// Derive the feature id address associated with the feature proposal
-pub fn get_feature_id_address(feature_proposal_address: &Pubkey) -> Pubkey {
-    get_feature_id_address_with_seed(feature_proposal_address).0
-}
-
-/// Convert the UI representation of a token amount (using the decimals field
-/// defined in its mint) to the raw amount
-pub fn ui_amount_to_amount(ui_amount: f64) -> u64 {
-    (ui_amount * 10_usize.pow(spl_token::native_mint::DECIMALS as u32) as f64) as u64
-}
-
-/// Convert a raw amount to its UI representation (using the decimals field
-/// defined in its mint)
-pub fn amount_to_ui_amount(amount: u64) -> f64 {
-    amount as f64 / 10_usize.pow(spl_token::native_mint::DECIMALS as u32) as f64
-}
diff --git a/feature-proposal/program/src/processor.rs b/feature-proposal/program/src/processor.rs
deleted file mode 100644
index 6aa00a610f8..00000000000
--- a/feature-proposal/program/src/processor.rs
+++ /dev/null
@@ -1,371 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{instruction::*, state::*, *},
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        clock::Clock,
-        entrypoint::ProgramResult,
-        feature::{self, Feature},
-        msg,
-        program::{invoke, invoke_signed},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        rent::Rent,
-        system_instruction,
-        sysvar::Sysvar,
-    },
-};
-
-/// Instruction processor
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let instruction = FeatureProposalInstruction::unpack_from_slice(input)?;
-    let account_info_iter = &mut accounts.iter();
-
-    match instruction {
-        FeatureProposalInstruction::Propose {
-            tokens_to_mint,
-            acceptance_criteria,
-        } => {
-            msg!("FeatureProposalInstruction::Propose");
-
-            let funder_info = next_account_info(account_info_iter)?;
-            let feature_proposal_info = next_account_info(account_info_iter)?;
-            let mint_info = next_account_info(account_info_iter)?;
-            let distributor_token_info = next_account_info(account_info_iter)?;
-            let acceptance_token_info = next_account_info(account_info_iter)?;
-            let feature_id_info = next_account_info(account_info_iter)?;
-            let system_program_info = next_account_info(account_info_iter)?;
-            let spl_token_program_info = next_account_info(account_info_iter)?;
-            let rent_sysvar_info = next_account_info(account_info_iter)?;
-            let rent = &Rent::from_account_info(rent_sysvar_info)?;
-
-            let (mint_address, mint_bump_seed) =
-                get_mint_address_with_seed(feature_proposal_info.key);
-            if mint_address != *mint_info.key {
-                msg!("Error: mint address derivation mismatch");
-                return Err(ProgramError::InvalidArgument);
-            }
-
-            let (distributor_token_address, distributor_token_bump_seed) =
-                get_distributor_token_address_with_seed(feature_proposal_info.key);
-            if distributor_token_address != *distributor_token_info.key {
-                msg!("Error: distributor token address derivation mismatch");
-                return Err(ProgramError::InvalidArgument);
-            }
-
-            let (acceptance_token_address, acceptance_token_bump_seed) =
-                get_acceptance_token_address_with_seed(feature_proposal_info.key);
-            if acceptance_token_address != *acceptance_token_info.key {
-                msg!("Error: acceptance token address derivation mismatch");
-                return Err(ProgramError::InvalidArgument);
-            }
-
-            let (feature_id_address, feature_id_bump_seed) =
-                get_feature_id_address_with_seed(feature_proposal_info.key);
-            if feature_id_address != *feature_id_info.key {
-                msg!("Error: feature-id address derivation mismatch");
-                return Err(ProgramError::InvalidArgument);
-            }
-
-            let mint_signer_seeds: &[&[_]] = &[
-                &feature_proposal_info.key.to_bytes(),
-                br"mint",
-                &[mint_bump_seed],
-            ];
-
-            let distributor_token_signer_seeds: &[&[_]] = &[
-                &feature_proposal_info.key.to_bytes(),
-                br"distributor",
-                &[distributor_token_bump_seed],
-            ];
-
-            let acceptance_token_signer_seeds: &[&[_]] = &[
-                &feature_proposal_info.key.to_bytes(),
-                br"acceptance",
-                &[acceptance_token_bump_seed],
-            ];
-
-            let feature_id_signer_seeds: &[&[_]] = &[
-                &feature_proposal_info.key.to_bytes(),
-                br"feature-id",
-                &[feature_id_bump_seed],
-            ];
-
-            msg!("Creating feature proposal account");
-            invoke(
-                &system_instruction::create_account(
-                    funder_info.key,
-                    feature_proposal_info.key,
-                    1.max(rent.minimum_balance(FeatureProposal::get_packed_len())),
-                    FeatureProposal::get_packed_len() as u64,
-                    program_id,
-                ),
-                &[
-                    funder_info.clone(),
-                    feature_proposal_info.clone(),
-                    system_program_info.clone(),
-                ],
-            )?;
-            FeatureProposal::Pending(acceptance_criteria)
-                .pack_into_slice(&mut feature_proposal_info.data.borrow_mut());
-
-            msg!("Creating mint");
-            invoke_signed(
-                &system_instruction::create_account(
-                    funder_info.key,
-                    mint_info.key,
-                    1.max(rent.minimum_balance(spl_token::state::Mint::get_packed_len())),
-                    spl_token::state::Mint::get_packed_len() as u64,
-                    &spl_token::id(),
-                ),
-                &[
-                    funder_info.clone(),
-                    mint_info.clone(),
-                    system_program_info.clone(),
-                ],
-                &[mint_signer_seeds],
-            )?;
-
-            msg!("Initializing mint");
-            invoke(
-                &spl_token::instruction::initialize_mint(
-                    &spl_token::id(),
-                    mint_info.key,
-                    mint_info.key,
-                    None,
-                    spl_token::native_mint::DECIMALS,
-                )?,
-                &[
-                    mint_info.clone(),
-                    spl_token_program_info.clone(),
-                    rent_sysvar_info.clone(),
-                ],
-            )?;
-
-            msg!("Creating distributor token account");
-            invoke_signed(
-                &system_instruction::create_account(
-                    funder_info.key,
-                    distributor_token_info.key,
-                    1.max(rent.minimum_balance(spl_token::state::Account::get_packed_len())),
-                    spl_token::state::Account::get_packed_len() as u64,
-                    &spl_token::id(),
-                ),
-                &[
-                    funder_info.clone(),
-                    distributor_token_info.clone(),
-                    system_program_info.clone(),
-                ],
-                &[distributor_token_signer_seeds],
-            )?;
-
-            msg!("Initializing distributor token account");
-            invoke(
-                &spl_token::instruction::initialize_account(
-                    &spl_token::id(),
-                    distributor_token_info.key,
-                    mint_info.key,
-                    feature_proposal_info.key,
-                )?,
-                &[
-                    distributor_token_info.clone(),
-                    spl_token_program_info.clone(),
-                    rent_sysvar_info.clone(),
-                    feature_proposal_info.clone(),
-                    mint_info.clone(),
-                ],
-            )?;
-
-            msg!("Creating acceptance token account");
-            invoke_signed(
-                &system_instruction::create_account(
-                    funder_info.key,
-                    acceptance_token_info.key,
-                    1.max(rent.minimum_balance(spl_token::state::Account::get_packed_len())),
-                    spl_token::state::Account::get_packed_len() as u64,
-                    &spl_token::id(),
-                ),
-                &[
-                    funder_info.clone(),
-                    acceptance_token_info.clone(),
-                    system_program_info.clone(),
-                ],
-                &[acceptance_token_signer_seeds],
-            )?;
-
-            msg!("Initializing acceptance token account");
-            invoke(
-                &spl_token::instruction::initialize_account(
-                    &spl_token::id(),
-                    acceptance_token_info.key,
-                    mint_info.key,
-                    feature_proposal_info.key,
-                )?,
-                &[
-                    acceptance_token_info.clone(),
-                    spl_token_program_info.clone(),
-                    rent_sysvar_info.clone(),
-                    feature_proposal_info.clone(),
-                    mint_info.clone(),
-                ],
-            )?;
-            invoke(
-                &spl_token::instruction::set_authority(
-                    &spl_token::id(),
-                    acceptance_token_info.key,
-                    Some(feature_proposal_info.key),
-                    spl_token::instruction::AuthorityType::CloseAccount,
-                    feature_proposal_info.key,
-                    &[],
-                )?,
-                &[
-                    spl_token_program_info.clone(),
-                    acceptance_token_info.clone(),
-                    feature_proposal_info.clone(),
-                ],
-            )?;
-            invoke(
-                &spl_token::instruction::set_authority(
-                    &spl_token::id(),
-                    acceptance_token_info.key,
-                    Some(program_id),
-                    spl_token::instruction::AuthorityType::AccountOwner,
-                    feature_proposal_info.key,
-                    &[],
-                )?,
-                &[
-                    spl_token_program_info.clone(),
-                    acceptance_token_info.clone(),
-                    feature_proposal_info.clone(),
-                ],
-            )?;
-
-            // Mint `tokens_to_mint` tokens into `distributor_token_account` owned by
-            // `feature_proposal`
-            msg!("Minting {} tokens", tokens_to_mint);
-            invoke_signed(
-                &spl_token::instruction::mint_to(
-                    &spl_token::id(),
-                    mint_info.key,
-                    distributor_token_info.key,
-                    mint_info.key,
-                    &[],
-                    tokens_to_mint,
-                )?,
-                &[
-                    mint_info.clone(),
-                    distributor_token_info.clone(),
-                    spl_token_program_info.clone(),
-                ],
-                &[mint_signer_seeds],
-            )?;
-
-            // Fully fund the feature id account so the `Tally` instruction will not require
-            // any lamports from the caller
-            msg!("Funding feature id account");
-            invoke(
-                &system_instruction::transfer(
-                    funder_info.key,
-                    feature_id_info.key,
-                    1.max(rent.minimum_balance(Feature::size_of())),
-                ),
-                &[
-                    funder_info.clone(),
-                    feature_id_info.clone(),
-                    system_program_info.clone(),
-                ],
-            )?;
-
-            msg!("Allocating feature id account");
-            invoke_signed(
-                &system_instruction::allocate(feature_id_info.key, Feature::size_of() as u64),
-                &[feature_id_info.clone(), system_program_info.clone()],
-                &[feature_id_signer_seeds],
-            )?;
-        }
-
-        FeatureProposalInstruction::Tally => {
-            msg!("FeatureProposalInstruction::Tally");
-
-            let feature_proposal_info = next_account_info(account_info_iter)?;
-            let feature_proposal_state =
-                FeatureProposal::unpack_from_slice(&feature_proposal_info.data.borrow())?;
-
-            match feature_proposal_state {
-                FeatureProposal::Pending(acceptance_criteria) => {
-                    let acceptance_token_info = next_account_info(account_info_iter)?;
-                    let feature_id_info = next_account_info(account_info_iter)?;
-                    let system_program_info = next_account_info(account_info_iter)?;
-                    let clock_sysvar_info = next_account_info(account_info_iter)?;
-                    let clock = &Clock::from_account_info(clock_sysvar_info)?;
-
-                    // Re-derive the acceptance token and feature id program addresses to confirm
-                    // the caller provided the correct addresses
-                    let acceptance_token_address =
-                        get_acceptance_token_address(feature_proposal_info.key);
-                    if acceptance_token_address != *acceptance_token_info.key {
-                        msg!("Error: acceptance token address derivation mismatch");
-                        return Err(ProgramError::InvalidArgument);
-                    }
-
-                    let (feature_id_address, feature_id_bump_seed) =
-                        get_feature_id_address_with_seed(feature_proposal_info.key);
-                    if feature_id_address != *feature_id_info.key {
-                        msg!("Error: feature-id address derivation mismatch");
-                        return Err(ProgramError::InvalidArgument);
-                    }
-
-                    let feature_id_signer_seeds: &[&[_]] = &[
-                        &feature_proposal_info.key.to_bytes(),
-                        br"feature-id",
-                        &[feature_id_bump_seed],
-                    ];
-
-                    if clock.unix_timestamp >= acceptance_criteria.deadline {
-                        msg!("Feature proposal expired");
-                        FeatureProposal::Expired
-                            .pack_into_slice(&mut feature_proposal_info.data.borrow_mut());
-                        return Ok(());
-                    }
-
-                    msg!("Unpacking acceptance token account");
-                    let acceptance_token =
-                        spl_token::state::Account::unpack(&acceptance_token_info.data.borrow())?;
-
-                    msg!(
-                            "Feature proposal has received {} tokens, and {} tokens required for acceptance",
-                            acceptance_token.amount, acceptance_criteria.tokens_required
-                        );
-                    if acceptance_token.amount < acceptance_criteria.tokens_required {
-                        msg!("Activation threshold has not been reached");
-                        return Ok(());
-                    }
-
-                    msg!("Assigning feature id account");
-                    invoke_signed(
-                        &system_instruction::assign(feature_id_info.key, &feature::id()),
-                        &[feature_id_info.clone(), system_program_info.clone()],
-                        &[feature_id_signer_seeds],
-                    )?;
-
-                    msg!("Feature proposal accepted");
-                    FeatureProposal::Accepted {
-                        tokens_upon_acceptance: acceptance_token.amount,
-                    }
-                    .pack_into_slice(&mut feature_proposal_info.data.borrow_mut());
-                }
-                _ => {
-                    msg!("Error: feature proposal account not in the pending state");
-                    return Err(ProgramError::InvalidAccountData);
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
diff --git a/feature-proposal/program/src/state.rs b/feature-proposal/program/src/state.rs
deleted file mode 100644
index 81d86f2da7a..00000000000
--- a/feature-proposal/program/src/state.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//! Program state
-use {
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        clock::UnixTimestamp,
-        msg,
-        program_error::ProgramError,
-        program_pack::{Pack, Sealed},
-    },
-};
-
-/// Criteria for accepting a feature proposal
-#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, BorshSchema, PartialEq)]
-pub struct AcceptanceCriteria {
-    /// The balance of the feature proposal's token account must be greater than
-    /// this amount, and tallied before the deadline for the feature to be
-    /// accepted.
-    pub tokens_required: u64,
-
-    /// If the required tokens are not tallied by this deadline then the
-    /// proposal will expire.
-    pub deadline: UnixTimestamp,
-}
-
-/// Contents of a Feature Proposal account
-#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, BorshSchema, PartialEq)]
-pub enum FeatureProposal {
-    /// Default account state after creating it
-    Uninitialized,
-    /// Feature proposal is now pending
-    Pending(AcceptanceCriteria),
-    /// Feature proposal was accepted and the feature is now active
-    Accepted {
-        /// The balance of the feature proposal's token account at the time of
-        /// activation.
-        #[allow(dead_code)] // not dead code..
-        tokens_upon_acceptance: u64,
-    },
-    /// Feature proposal was not accepted before the deadline
-    Expired,
-}
-impl Sealed for FeatureProposal {}
-
-impl Pack for FeatureProposal {
-    const LEN: usize = 17; // see `test_get_packed_len()` for justification of "18"
-
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let data = borsh::to_vec(self).unwrap();
-        dst[..data.len()].copy_from_slice(&data);
-    }
-
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let mut mut_src: &[u8] = src;
-        Self::deserialize(&mut mut_src).map_err(|err| {
-            msg!(
-                "Error: failed to deserialize feature proposal account: {}",
-                err
-            );
-            ProgramError::InvalidAccountData
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_packed_len() {
-        assert_eq!(
-            FeatureProposal::get_packed_len(),
-            solana_program::borsh1::get_packed_len::<FeatureProposal>()
-        );
-    }
-
-    #[test]
-    fn test_serialize_bytes() {
-        assert_eq!(borsh::to_vec(&FeatureProposal::Expired).unwrap(), vec![3]);
-
-        assert_eq!(
-            borsh::to_vec(&FeatureProposal::Pending(AcceptanceCriteria {
-                tokens_required: 0xdeadbeefdeadbeef,
-                deadline: -1,
-            }))
-            .unwrap(),
-            vec![1, 239, 190, 173, 222, 239, 190, 173, 222, 255, 255, 255, 255, 255, 255, 255, 255],
-        );
-    }
-
-    #[test]
-    fn test_serialize_large_slice() {
-        let mut dst = vec![0xff; 4];
-        FeatureProposal::Expired.pack_into_slice(&mut dst);
-
-        // Extra bytes (0xff) ignored
-        assert_eq!(dst, vec![3, 0xff, 0xff, 0xff]);
-    }
-
-    #[test]
-    fn state_deserialize_invalid() {
-        assert_eq!(
-            FeatureProposal::unpack_from_slice(&[3]),
-            Ok(FeatureProposal::Expired),
-        );
-
-        // Extra bytes (0xff) ignored...
-        assert_eq!(
-            FeatureProposal::unpack_from_slice(&[3, 0xff, 0xff, 0xff]),
-            Ok(FeatureProposal::Expired),
-        );
-
-        assert_eq!(
-            FeatureProposal::unpack_from_slice(&[4]),
-            Err(ProgramError::InvalidAccountData),
-        );
-    }
-}
diff --git a/feature-proposal/program/tests/functional.rs b/feature-proposal/program/tests/functional.rs
deleted file mode 100644
index a8101d9b63f..00000000000
--- a/feature-proposal/program/tests/functional.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-// Mark this test as BPF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program::{
-        feature::{self, Feature},
-        program_option::COption,
-        system_program,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
-    spl_feature_proposal::{instruction::*, state::*, *},
-};
-
-fn program_test() -> ProgramTest {
-    ProgramTest::new(
-        "spl_feature_proposal",
-        id(),
-        processor!(processor::process_instruction),
-    )
-}
-
-#[tokio::test]
-async fn test_basic() {
-    let feature_proposal = Keypair::new();
-
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-
-    let feature_id_address = get_feature_id_address(&feature_proposal.pubkey());
-    let mint_address = get_mint_address(&feature_proposal.pubkey());
-    let distributor_token_address = get_distributor_token_address(&feature_proposal.pubkey());
-    let acceptance_token_address = get_acceptance_token_address(&feature_proposal.pubkey());
-
-    // Create a new feature proposal
-    let mut transaction = Transaction::new_with_payer(
-        &[propose(
-            &payer.pubkey(),
-            &feature_proposal.pubkey(),
-            42,
-            AcceptanceCriteria {
-                tokens_required: 42,
-                deadline: i64::MAX,
-            },
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &feature_proposal], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Confirm feature id account is now funded and allocated, but not assigned
-    let feature_id_account = banks_client
-        .get_account(feature_id_address)
-        .await
-        .expect("success")
-        .expect("some account");
-    assert_eq!(feature_id_account.owner, system_program::id());
-    assert_eq!(feature_id_account.data.len(), Feature::size_of());
-
-    // Confirm mint account state
-    let mint = banks_client
-        .get_packed_account_data::<spl_token::state::Mint>(mint_address)
-        .await
-        .unwrap();
-    assert_eq!(mint.supply, 42);
-    assert_eq!(mint.decimals, 9);
-    assert!(mint.freeze_authority.is_none());
-    assert_eq!(mint.mint_authority, COption::Some(mint_address));
-
-    // Confirm distributor token account state
-    let distributor_token = banks_client
-        .get_packed_account_data::<spl_token::state::Account>(distributor_token_address)
-        .await
-        .unwrap();
-    assert_eq!(distributor_token.amount, 42);
-    assert_eq!(distributor_token.mint, mint_address);
-    assert_eq!(distributor_token.owner, feature_proposal.pubkey());
-    assert!(distributor_token.close_authority.is_none());
-
-    // Confirm acceptance token account state
-    let acceptance_token = banks_client
-        .get_packed_account_data::<spl_token::state::Account>(acceptance_token_address)
-        .await
-        .unwrap();
-    assert_eq!(acceptance_token.amount, 0);
-    assert_eq!(acceptance_token.mint, mint_address);
-    assert_eq!(acceptance_token.owner, id());
-    assert_eq!(
-        acceptance_token.close_authority,
-        COption::Some(feature_proposal.pubkey())
-    );
-
-    // Tally #1: Does nothing because the acceptance criteria has not been met
-    let mut transaction =
-        Transaction::new_with_payer(&[tally(&feature_proposal.pubkey())], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Confirm feature id account is not yet assigned
-    let feature_id_account = banks_client
-        .get_account(feature_id_address)
-        .await
-        .expect("success")
-        .expect("some account");
-    assert_eq!(feature_id_account.owner, system_program::id());
-
-    assert!(matches!(
-        banks_client
-            .get_packed_account_data::<FeatureProposal>(feature_proposal.pubkey())
-            .await,
-        Ok(FeatureProposal::Pending(_))
-    ));
-
-    // Transfer tokens to the acceptance account
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_token::instruction::transfer(
-            &spl_token::id(),
-            &distributor_token_address,
-            &acceptance_token_address,
-            &feature_proposal.pubkey(),
-            &[],
-            42,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &feature_proposal], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Fetch a new blockhash to avoid the second Tally transaction having the same
-    // signature as the first Tally transaction
-    let recent_blockhash = banks_client
-        .get_new_latest_blockhash(&recent_blockhash)
-        .await
-        .unwrap();
-
-    // Tally #2: the acceptance criteria is now met
-    let mut transaction =
-        Transaction::new_with_payer(&[tally(&feature_proposal.pubkey())], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Confirm feature id account is now assigned
-    let feature_id_account = banks_client
-        .get_account(feature_id_address)
-        .await
-        .expect("success")
-        .expect("some account");
-    assert_eq!(feature_id_account.owner, feature::id());
-
-    // Confirm feature proposal account state
-    assert!(matches!(
-        banks_client
-            .get_packed_account_data::<FeatureProposal>(feature_proposal.pubkey())
-            .await,
-        Ok(FeatureProposal::Accepted {
-            tokens_upon_acceptance: 42
-        })
-    ));
-}
-
-#[tokio::test]
-async fn test_expired() {
-    let feature_proposal = Keypair::new();
-
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-
-    // Create a new feature proposal
-    let mut transaction = Transaction::new_with_payer(
-        &[propose(
-            &payer.pubkey(),
-            &feature_proposal.pubkey(),
-            42,
-            AcceptanceCriteria {
-                tokens_required: 42,
-                deadline: 0, // <=== Already expired
-            },
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &feature_proposal], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert!(matches!(
-        banks_client
-            .get_packed_account_data::<FeatureProposal>(feature_proposal.pubkey())
-            .await,
-        Ok(FeatureProposal::Pending(_))
-    ));
-
-    // Tally will cause the proposal to expire
-    let mut transaction =
-        Transaction::new_with_payer(&[tally(&feature_proposal.pubkey())], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    assert!(matches!(
-        banks_client
-            .get_packed_account_data::<FeatureProposal>(feature_proposal.pubkey())
-            .await,
-        Ok(FeatureProposal::Expired)
-    ));
-}
diff --git a/governance/README.md b/governance/README.md
index 98336cf87b0..aa5be9df83b 100644
--- a/governance/README.md
+++ b/governance/README.md
@@ -1,3 +1,5 @@
+> This repo still exists in archived form, but the maintained version has now relocated to: https://github.com/Mythic-Project/solana-program-library/tree/master/governance
+
 # SPL Governance
 
 SPL Governance is a program the chief purpose of which is to provide core building blocks and primitives to create
diff --git a/governance/addin-api/Cargo.toml b/governance/addin-api/Cargo.toml
index 1c2de7958b1..e2b0b318a72 100644
--- a/governance/addin-api/Cargo.toml
+++ b/governance/addin-api/Cargo.toml
@@ -8,6 +8,6 @@ license = "Apache-2.0"
 edition = "2021"
 
 [dependencies]
-borsh = "1.5.1"
+borsh = "1.5.3"
 spl-governance-tools = { version = "0.1.4", path = "../tools" }
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
diff --git a/governance/addin-mock/program/Cargo.toml b/governance/addin-mock/program/Cargo.toml
index 6c12038831c..575cd75f2c8 100644
--- a/governance/addin-mock/program/Cargo.toml
+++ b/governance/addin-mock/program/Cargo.toml
@@ -12,29 +12,32 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 bincode = "1.3.2"
-borsh = "1.5.1"
+borsh = "1.5.3"
 num-derive = "0.4"
 num-traits = "0.2"
-serde = "1.0.203"
+serde = "1.0.217"
 serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../../token/program", features = [
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
 spl-governance-addin-api = { version = "0.1.4", path = "../../addin-api" }
 spl-governance-tools = { version = "0.1.4", path = "../../tools" }
-thiserror = "1.0"
+thiserror = "2.0"
 
 
 [dev-dependencies]
 assert_matches = "1.5.0"
-proptest = "1.4"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+proptest = "1.6"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 spl-governance-test-sdk = { version = "0.1.4", path = "../../test-sdk" }
 
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/governance/chat/program/Cargo.toml b/governance/chat/program/Cargo.toml
index ff723a6a441..a6315129bf8 100644
--- a/governance/chat/program/Cargo.toml
+++ b/governance/chat/program/Cargo.toml
@@ -12,15 +12,15 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 bincode = "1.3.2"
-borsh = "1.5.1"
+borsh = "1.5.3"
 num-derive = "0.4"
 num-traits = "0.2"
-serde = "1.0.203"
+serde = "1.0.217"
 serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../../token/program", features = [
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
 spl-governance = { version = "4.0.0", path = "../../program", features = [
@@ -28,17 +28,20 @@ spl-governance = { version = "4.0.0", path = "../../program", features = [
 ] }
 spl-governance-tools = { version = "0.1.4", path = "../../tools" }
 spl-governance-addin-api = { version = "0.1.4", path = "../../addin-api" }
-thiserror = "1.0"
+thiserror = "2.0"
 
 
 [dev-dependencies]
 assert_matches = "1.5.0"
-proptest = "1.4"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+proptest = "1.6"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 spl-governance-test-sdk = { version = "0.1.4", path = "../../test-sdk" }
 spl-governance-addin-mock = { version = "0.1.4", path = "../../addin-mock/program" }
 
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/governance/program/Cargo.toml b/governance/program/Cargo.toml
index b34feff9dd3..fd553380c3d 100644
--- a/governance/program/Cargo.toml
+++ b/governance/program/Cargo.toml
@@ -12,30 +12,33 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 bincode = "1.3.2"
-borsh = "1.5.1"
+borsh = "1.5.3"
 num-derive = "0.4"
 num-traits = "0.2"
-serde = "1.0.203"
+serde = "1.0.217"
 serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
 spl-governance-tools = { version = "0.1.4", path = "../tools" }
 spl-governance-addin-api = { version = "0.1.4", path = "../addin-api" }
-thiserror = "1.0"
+thiserror = "2.0"
 
 [dev-dependencies]
 assert_matches = "1.5.0"
 base64 = "0.22"
-proptest = "1.4"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+proptest = "1.6"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 spl-governance-test-sdk = { version = "0.1.4", path = "../test-sdk" }
 spl-governance-addin-mock = { version = "0.1.4", path = "../addin-mock/program" }
 
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/governance/program/src/lib.rs b/governance/program/src/lib.rs
index 7fd08c7b074..91c6ee6bef6 100644
--- a/governance/program/src/lib.rs
+++ b/governance/program/src/lib.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::arithmetic_side_effects)]
+#![allow(clippy::doc_lazy_continuation)]
 #![deny(missing_docs)]
 //! A Governance program for the Solana blockchain.
 
diff --git a/governance/program/tests/program_test/cookies.rs b/governance/program/tests/program_test/cookies.rs
index 2b477de00ce..4965acbc830 100644
--- a/governance/program/tests/program_test/cookies.rs
+++ b/governance/program/tests/program_test/cookies.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use {
     solana_program::{clock::UnixTimestamp, instruction::Instruction, pubkey::Pubkey},
     solana_sdk::signature::Keypair,
@@ -72,7 +73,6 @@ impl TokenOwnerRecordCookie {
             .unwrap_or(&self.token_owner)
     }
 
-    #[allow(dead_code)]
     pub fn clone_governance_delegate(&self) -> Keypair {
         clone_keypair(&self.governance_delegate)
     }
diff --git a/governance/test-sdk/Cargo.toml b/governance/test-sdk/Cargo.toml
index 4f62abd5552..dd27a6fcf46 100644
--- a/governance/test-sdk/Cargo.toml
+++ b/governance/test-sdk/Cargo.toml
@@ -8,18 +8,18 @@ license = "Apache-2.0"
 edition = "2021"
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 bincode = "1.3.2"
-borsh = "1.5.1"
-lazy_static = "1.4.0"
+borsh = "1.5.3"
+lazy_static = "1.5.0"
 num-derive = "0.4"
 num-traits = "0.2"
-serde = "1.0.203"
+serde = "1.0.217"
 serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+solana-program = "2.1.0"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-thiserror = "1.0"
+thiserror = "2.0"
diff --git a/governance/test-sdk/src/lib.rs b/governance/test-sdk/src/lib.rs
index b225178a341..8086306c24a 100644
--- a/governance/test-sdk/src/lib.rs
+++ b/governance/test-sdk/src/lib.rs
@@ -38,7 +38,7 @@ impl ProgramTestBench {
     /// Create new bench given a ProgramTest instance populated with all of the
     /// desired programs.
     pub async fn start_new(program_test: ProgramTest) -> Self {
-        let mut context = program_test.start_with_context().await;
+        let context = program_test.start_with_context().await;
         let rent = context.banks_client.get_rent().await.unwrap();
 
         let payer = clone_keypair(&context.payer);
diff --git a/governance/tools/Cargo.toml b/governance/tools/Cargo.toml
index 49c268aacd5..766bab14b7c 100644
--- a/governance/tools/Cargo.toml
+++ b/governance/tools/Cargo.toml
@@ -8,15 +8,15 @@ license = "Apache-2.0"
 edition = "2021"
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 bincode = "1.3.2"
-borsh = "1.5.1"
+borsh = "1.5.3"
 num-derive = "0.4"
 num-traits = "0.2"
-serde = "1.0.203"
+serde = "1.0.217"
 serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-thiserror = "1.0"
+thiserror = "2.0"
diff --git a/instruction-padding/README.md b/instruction-padding/README.md
new file mode 100644
index 00000000000..fd71f7e7125
--- /dev/null
+++ b/instruction-padding/README.md
@@ -0,0 +1,2 @@
+NOTE: The instruction-padding program and clients are now maintained at
+[solana-program/instruction-padding](https://github.com/solana-program/instruction-padding).
diff --git a/instruction-padding/program/README.md b/instruction-padding/program/README.md
deleted file mode 100644
index 5fe411f9c4c..00000000000
--- a/instruction-padding/program/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Instruction Pad Program
-
-A program for padding instructions with additional data or accounts, to be used
-for testing larger transactions, either more instruction data, or more accounts.
-
-The main use-case is with solana-bench-tps, where we can see the impact of larger
-transactions through TPS numbers. With that data, we can develop a fair fee model
-for large transactions.
-
-It operates with two instructions: no-op and wrap.
-
-* No-op: simply an instruction with as much data and as many accounts as desired,
-of which none will be used for processing.
-* Wrap: before the padding data and accounts, accepts a real instruction and
-required accounts, and performs a CPI into the program specified by the instruction
-
-Both of these modes add the general overhead of calling a BPF program, and
-the wrap mode adds the CPI overhead.
-
-Because of the overhead, it's best to use the instruction padding program with
-all large transaction tests, and comparing TPS numbers between:
-
-* using the program with no padding
-* using the program with data and account padding
-
-## Audit
-
-The repository [README](https://github.com/solana-labs/solana-program-library#audits)
-contains information about program audits.
diff --git a/instruction-padding/program/src/entrypoint.rs b/instruction-padding/program/src/entrypoint.rs
deleted file mode 100644
index bb9a931af22..00000000000
--- a/instruction-padding/program/src/entrypoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Program entrypoint
-
-#![cfg(not(feature = "no-entrypoint"))]
-
-use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    crate::processor::process(program_id, accounts, instruction_data)
-}
diff --git a/instruction-padding/program/src/instruction.rs b/instruction-padding/program/src/instruction.rs
deleted file mode 100644
index 0c666509206..00000000000
--- a/instruction-padding/program/src/instruction.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-//! Instruction creators for large instructions
-
-use {
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        syscalls::{MAX_CPI_ACCOUNT_INFOS, MAX_CPI_INSTRUCTION_DATA_LEN},
-    },
-    std::{convert::TryInto, mem::size_of},
-};
-
-/// Instructions supported by the padding program, which takes in additional
-/// account data or accounts and does nothing with them. It's meant for testing
-/// larger transactions with bench-tps.
-#[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
-#[repr(u8)]
-pub enum PadInstruction {
-    /// Does no work, but accepts a large amount of data and accounts
-    Noop,
-    /// Wraps the provided instruction, calling the provided program via CPI
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// * All accounts required for the inner instruction
-    /// * The program invoked by the inner instruction
-    /// * Additional padding accounts
-    ///
-    /// Data expected by this instruction:
-    /// * WrapData
-    Wrap,
-}
-
-/// Data wrapping any inner instruction
-pub struct WrapData<'a> {
-    /// Number of accounts required by the inner instruction
-    pub num_accounts: u32,
-    /// the size of the inner instruction data
-    pub instruction_size: u32,
-    /// actual inner instruction data
-    pub instruction_data: &'a [u8],
-    // additional padding bytes come after, not captured in this struct
-}
-
-const U32_BYTES: usize = 4;
-fn unpack_u32(input: &[u8]) -> Result<(u32, &[u8]), ProgramError> {
-    let value = input
-        .get(..U32_BYTES)
-        .and_then(|slice| slice.try_into().ok())
-        .map(u32::from_le_bytes)
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    Ok((value, &input[U32_BYTES..]))
-}
-
-impl<'a> WrapData<'a> {
-    /// Unpacks instruction data
-    pub fn unpack(data: &'a [u8]) -> Result<Self, ProgramError> {
-        let (num_accounts, rest) = unpack_u32(data)?;
-        let (instruction_size, rest) = unpack_u32(rest)?;
-
-        let (instruction_data, _rest) = rest.split_at(instruction_size as usize);
-        Ok(Self {
-            num_accounts,
-            instruction_size,
-            instruction_data,
-        })
-    }
-}
-
-pub fn noop(
-    program_id: Pubkey,
-    padding_accounts: Vec<AccountMeta>,
-    padding_data: u32,
-) -> Result<Instruction, ProgramError> {
-    let total_data_size = size_of::<u8>().saturating_add(padding_data as usize);
-    // crude, but can find a potential issue right away
-    if total_data_size > MAX_CPI_INSTRUCTION_DATA_LEN as usize {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let mut data = Vec::with_capacity(total_data_size);
-    data.push(PadInstruction::Noop.into());
-    for i in 0..padding_data {
-        data.push(i.checked_rem(u8::MAX as u32).unwrap() as u8);
-    }
-
-    let num_accounts = padding_accounts.len().saturating_add(1);
-    if num_accounts > MAX_CPI_ACCOUNT_INFOS {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    let mut accounts = Vec::with_capacity(num_accounts);
-    accounts.extend(padding_accounts);
-
-    Ok(Instruction {
-        program_id,
-        accounts,
-        data,
-    })
-}
-
-pub fn wrap_instruction(
-    program_id: Pubkey,
-    instruction: Instruction,
-    padding_accounts: Vec<AccountMeta>,
-    padding_data: u32,
-) -> Result<Instruction, ProgramError> {
-    let total_data_size = size_of::<u8>()
-        .saturating_add(size_of::<u32>())
-        .saturating_add(size_of::<u32>())
-        .saturating_add(instruction.data.len())
-        .saturating_add(padding_data as usize);
-    // crude, but can find a potential issue right away
-    if total_data_size > MAX_CPI_INSTRUCTION_DATA_LEN as usize {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let mut data = Vec::with_capacity(total_data_size);
-    data.push(PadInstruction::Wrap.into());
-    let num_accounts: u32 = instruction
-        .accounts
-        .len()
-        .try_into()
-        .map_err(|_| ProgramError::InvalidInstructionData)?;
-    data.extend(num_accounts.to_le_bytes().iter());
-
-    let data_size: u32 = instruction
-        .data
-        .len()
-        .try_into()
-        .map_err(|_| ProgramError::InvalidInstructionData)?;
-    data.extend(data_size.to_le_bytes().iter());
-    data.extend(instruction.data);
-    for i in 0..padding_data {
-        data.push(i.checked_rem(u8::MAX as u32).unwrap() as u8);
-    }
-
-    // The format for account data goes:
-    // * accounts required for the CPI
-    // * program account to call into
-    // * additional accounts may be included as padding or to test loading / locks
-    let num_accounts = instruction
-        .accounts
-        .len()
-        .saturating_add(1)
-        .saturating_add(padding_accounts.len());
-    if num_accounts > MAX_CPI_ACCOUNT_INFOS {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    let mut accounts = Vec::with_capacity(num_accounts);
-    accounts.extend(instruction.accounts);
-    accounts.push(AccountMeta::new_readonly(instruction.program_id, false));
-    accounts.extend(padding_accounts);
-
-    Ok(Instruction {
-        program_id,
-        accounts,
-        data,
-    })
-}
diff --git a/instruction-padding/program/src/lib.rs b/instruction-padding/program/src/lib.rs
deleted file mode 100644
index 8d9ac1615fd..00000000000
--- a/instruction-padding/program/src/lib.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-mod entrypoint;
-pub mod instruction;
-pub mod processor;
-
-pub use solana_program;
-solana_program::declare_id!("iXpADd6AW1k5FaaXum5qHbSqyd7TtoN6AD7suVa83MF");
diff --git a/instruction-padding/program/src/processor.rs b/instruction-padding/program/src/processor.rs
deleted file mode 100644
index 15190622547..00000000000
--- a/instruction-padding/program/src/processor.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use {
-    crate::instruction::{PadInstruction, WrapData},
-    solana_program::{
-        account_info::AccountInfo,
-        entrypoint::ProgramResult,
-        instruction::{AccountMeta, Instruction},
-        program::invoke,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    std::convert::TryInto,
-};
-
-pub fn process(
-    _program_id: &Pubkey,
-    account_infos: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    let (tag, rest) = instruction_data
-        .split_first()
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    match (*tag)
-        .try_into()
-        .map_err(|_| ProgramError::InvalidInstructionData)?
-    {
-        PadInstruction::Noop => Ok(()),
-        PadInstruction::Wrap => {
-            let WrapData {
-                num_accounts,
-                instruction_size,
-                instruction_data,
-            } = WrapData::unpack(rest)?;
-            let mut data = Vec::with_capacity(instruction_size as usize);
-            data.extend_from_slice(instruction_data);
-
-            let program_id = *account_infos[num_accounts as usize].key;
-
-            let accounts = account_infos
-                .iter()
-                .take(num_accounts as usize)
-                .map(|a| AccountMeta {
-                    pubkey: *a.key,
-                    is_signer: a.is_signer,
-                    is_writable: a.is_writable,
-                })
-                .collect::<Vec<_>>();
-
-            let instruction = Instruction {
-                program_id,
-                accounts,
-                data,
-            };
-
-            invoke(&instruction, &account_infos[..num_accounts as usize])
-        }
-    }
-}
diff --git a/instruction-padding/program/tests/noop.rs b/instruction-padding/program/tests/noop.rs
deleted file mode 100644
index 1d206b2e521..00000000000
--- a/instruction-padding/program/tests/noop.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::AccountMeta, pubkey::Pubkey, signature::Signer, transaction::Transaction,
-    },
-    spl_instruction_padding::{instruction::noop, processor::process},
-};
-
-#[tokio::test]
-async fn success_with_noop() {
-    let program_id = Pubkey::new_unique();
-    let program_test = ProgramTest::new("spl_instruction_padding", program_id, processor!(process));
-
-    let mut context = program_test.start_with_context().await;
-
-    let padding_accounts = vec![
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-    ];
-
-    let padding_data = 800;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[noop(program_id, padding_accounts, padding_data).unwrap()],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
diff --git a/instruction-padding/program/tests/system.rs b/instruction-padding/program/tests/system.rs
deleted file mode 100644
index e8784252fa2..00000000000
--- a/instruction-padding/program/tests/system.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::AccountMeta, native_token::LAMPORTS_PER_SOL, pubkey::Pubkey,
-        signature::Signer, system_instruction, transaction::Transaction,
-    },
-    spl_instruction_padding::{instruction::wrap_instruction, processor::process},
-};
-
-#[tokio::test]
-async fn success_with_padded_transfer_data() {
-    let program_id = Pubkey::new_unique();
-    let program_test = ProgramTest::new("spl_instruction_padding", program_id, processor!(process));
-
-    let mut context = program_test.start_with_context().await;
-    let to = Pubkey::new_unique();
-
-    let transfer_amount = LAMPORTS_PER_SOL;
-    let transfer_instruction =
-        system_instruction::transfer(&context.payer.pubkey(), &to, transfer_amount);
-
-    let padding_accounts = vec![
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-        AccountMeta::new_readonly(Pubkey::new_unique(), false),
-    ];
-
-    let padding_data = 800;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[wrap_instruction(
-            program_id,
-            transfer_instruction,
-            padding_accounts,
-            padding_data,
-        )
-        .unwrap()],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // make sure the transfer went through
-    assert_eq!(
-        transfer_amount,
-        context
-            .banks_client
-            .get_account(to)
-            .await
-            .unwrap()
-            .unwrap()
-            .lamports
-    );
-}
diff --git a/libraries/README.md b/libraries/README.md
new file mode 100644
index 00000000000..7f619ec7993
--- /dev/null
+++ b/libraries/README.md
@@ -0,0 +1,13 @@
+NOTE: The actively maintained libraries now live at
+[solana-program/libraries](https://github.com/solana-program/libraries).
+
+The other repo includes:
+
+* discriminator
+* pod
+* program-error
+* tlv-account-resolution
+* type-length-value
+* type-length-value-derive-test
+
+Unmaintained libraries still live here and can still be forked.
diff --git a/libraries/concurrent-merkle-tree/Cargo.toml b/libraries/concurrent-merkle-tree/Cargo.toml
index 52527a8c6fe..a94f5e5323b 100644
--- a/libraries/concurrent-merkle-tree/Cargo.toml
+++ b/libraries/concurrent-merkle-tree/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "spl-concurrent-merkle-tree"
-version = "0.2.0"
+version = "0.4.0"
 description = "Solana Program Library Concurrent Merkle Tree"
 authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
 repository = "https://github.com/solana-labs/solana-program-library"
@@ -9,18 +9,18 @@ edition = "2021"
 
 [features]
 log = []
-sol-log = [ "log" ]
+sol-log = ["log"]
 
 [dependencies]
-solana-program = "1.16"
-bytemuck = "1.16"
-thiserror = "1.0.61"
+solana-program = ">=1.18.11,<=2"
+bytemuck = "1.21"
+thiserror = "2.0.9"
 
 [dev-dependencies]
 rand_distr = "0.4.3"
 rand = "0.8"
 spl-merkle-tree-reference = { version = "0.1.0", path = "../merkle-tree-reference" }
-tokio = { version = "1.38", features = ["full"] }
+tokio = { version = "1.42", features = ["full"] }
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/libraries/concurrent-merkle-tree/src/concurrent_merkle_tree.rs b/libraries/concurrent-merkle-tree/src/concurrent_merkle_tree.rs
index 811e4f25d1c..c0dc495dc6a 100644
--- a/libraries/concurrent-merkle-tree/src/concurrent_merkle_tree.rs
+++ b/libraries/concurrent-merkle-tree/src/concurrent_merkle_tree.rs
@@ -51,6 +51,15 @@ fn check_leaf_index(leaf_index: u32, max_depth: usize) -> Result<(), ConcurrentM
 /// [append](ConcurrentMerkleTree::append) operations, which do not require any
 /// proofs to be passed. This is accomplished by keeping track of the
 /// proof to the rightmost leaf in the tree (`rightmost_proof`).
+///
+/// The `ConcurrentMerkleTree` is a generic struct that may be interacted with
+/// using macros. Those macros may wrap up the construction and both mutable and
+/// immutable calls to the `ConcurrentMerkleTree` struct. If the macro contains
+/// a big match statement over different sizes of a tree and buffer, it might
+/// create a huge stack footprint. This in turn might lead to a stack overflow
+/// given the max stack offset of just 4kb. In order to minimize the stack frame
+/// size, the arguments for the `ConcurrentMerkleTree` methods that contain the
+/// proofs are passed as references to structs.
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct ConcurrentMerkleTree<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize> {
@@ -87,6 +96,40 @@ impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize> Default
     }
 }
 
+/// Arguments structure for initializing a tree with a root.
+pub struct InitializeWithRootArgs {
+    pub root: Node,
+    pub rightmost_leaf: Node,
+    pub proof_vec: Vec<Node>,
+    pub index: u32,
+}
+
+/// Arguments structure for setting a leaf in the tree.
+pub struct SetLeafArgs {
+    pub current_root: Node,
+    pub previous_leaf: Node,
+    pub new_leaf: Node,
+    pub proof_vec: Vec<Node>,
+    pub index: u32,
+}
+
+/// Arguments structure for filling an empty leaf or appending a new leaf to the
+/// tree.
+pub struct FillEmptyOrAppendArgs {
+    pub current_root: Node,
+    pub leaf: Node,
+    pub proof_vec: Vec<Node>,
+    pub index: u32,
+}
+
+/// Arguments structure for proving a leaf in the tree.
+pub struct ProveLeafArgs {
+    pub current_root: Node,
+    pub leaf: Node,
+    pub proof_vec: Vec<Node>,
+    pub index: u32,
+}
+
 impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize>
     ConcurrentMerkleTree<MAX_DEPTH, MAX_BUFFER_SIZE>
 {
@@ -132,35 +175,32 @@ impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize>
     /// other applications from indexing the leaf data stored in this tree.
     pub fn initialize_with_root(
         &mut self,
-        root: Node,
-        rightmost_leaf: Node,
-        proof_vec: &[Node],
-        index: u32,
+        args: &InitializeWithRootArgs,
     ) -> Result<Node, ConcurrentMerkleTreeError> {
         check_bounds(MAX_DEPTH, MAX_BUFFER_SIZE);
-        check_leaf_index(index, MAX_DEPTH)?;
+        check_leaf_index(args.index, MAX_DEPTH)?;
 
         if self.is_initialized() {
             return Err(ConcurrentMerkleTreeError::TreeAlreadyInitialized);
         }
         let mut proof: [Node; MAX_DEPTH] = [Node::default(); MAX_DEPTH];
-        proof.copy_from_slice(proof_vec);
+        proof.copy_from_slice(&args.proof_vec);
         let rightmost_proof = Path {
             proof,
-            index: index + 1,
-            leaf: rightmost_leaf,
+            index: args.index + 1,
+            leaf: args.rightmost_leaf,
             _padding: 0,
         };
-        self.change_logs[0].root = root;
+        self.change_logs[0].root = args.root;
         self.sequence_number = 1;
         self.active_index = 0;
         self.buffer_size = 1;
         self.rightmost_proof = rightmost_proof;
-        if root != recompute(rightmost_leaf, &proof, index) {
+        if args.root != recompute(args.rightmost_leaf, &proof, args.index) {
             solana_logging!("Proof failed to verify");
             return Err(ConcurrentMerkleTreeError::InvalidProof);
         }
-        Ok(root)
+        Ok(args.root)
     }
 
     /// Errors if one of the leaves of the current merkle tree is non-EMPTY
@@ -200,31 +240,25 @@ impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize>
     /// Note: this is *not* the same as verifying that a (proof, leaf)
     /// combination is valid for the given root. That functionality
     /// is provided by `check_valid_proof`.
-    pub fn prove_leaf(
-        &self,
-        current_root: Node,
-        leaf: Node,
-        proof_vec: &[Node],
-        leaf_index: u32,
-    ) -> Result<(), ConcurrentMerkleTreeError> {
+    pub fn prove_leaf(&self, args: &ProveLeafArgs) -> Result<(), ConcurrentMerkleTreeError> {
         check_bounds(MAX_DEPTH, MAX_BUFFER_SIZE);
-        check_leaf_index(leaf_index, MAX_DEPTH)?;
+        check_leaf_index(args.index, MAX_DEPTH)?;
         if !self.is_initialized() {
             return Err(ConcurrentMerkleTreeError::TreeNotInitialized);
         }
 
-        if leaf_index > self.rightmost_proof.index {
+        if args.index > self.rightmost_proof.index {
             solana_logging!(
                 "Received an index larger than the rightmost index {} > {}",
-                leaf_index,
+                args.index,
                 self.rightmost_proof.index
             );
             Err(ConcurrentMerkleTreeError::LeafIndexOutOfBounds)
         } else {
             let mut proof: [Node; MAX_DEPTH] = [Node::default(); MAX_DEPTH];
-            fill_in_proof::<MAX_DEPTH>(proof_vec, &mut proof);
+            fill_in_proof::<MAX_DEPTH>(&args.proof_vec, &mut proof);
             let valid_root =
-                self.check_valid_leaf(current_root, leaf, &mut proof, leaf_index, true)?;
+                self.check_valid_leaf(args.current_root, args.leaf, &mut proof, args.index, true)?;
             if !valid_root {
                 solana_logging!("Proof failed to verify");
                 return Err(ConcurrentMerkleTreeError::InvalidProof);
@@ -313,25 +347,29 @@ impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize>
     /// otherwise it will `append` the new leaf.
     pub fn fill_empty_or_append(
         &mut self,
-        current_root: Node,
-        leaf: Node,
-        proof_vec: &[Node],
-        index: u32,
+        args: &FillEmptyOrAppendArgs,
     ) -> Result<Node, ConcurrentMerkleTreeError> {
         check_bounds(MAX_DEPTH, MAX_BUFFER_SIZE);
-        check_leaf_index(index, MAX_DEPTH)?;
+        check_leaf_index(args.index, MAX_DEPTH)?;
         if !self.is_initialized() {
             return Err(ConcurrentMerkleTreeError::TreeNotInitialized);
         }
 
         let mut proof: [Node; MAX_DEPTH] = [Node::default(); MAX_DEPTH];
-        fill_in_proof::<MAX_DEPTH>(proof_vec, &mut proof);
+        fill_in_proof::<MAX_DEPTH>(&args.proof_vec, &mut proof);
 
         log_compute!();
-        match self.try_apply_proof(current_root, EMPTY, leaf, &mut proof, index, false) {
+        match self.try_apply_proof(
+            args.current_root,
+            EMPTY,
+            args.leaf,
+            &mut proof,
+            args.index,
+            false,
+        ) {
             Ok(new_root) => Ok(new_root),
             Err(error) => match error {
-                ConcurrentMerkleTreeError::LeafContentsModified => self.append(leaf),
+                ConcurrentMerkleTreeError::LeafContentsModified => self.append(args.leaf),
                 _ => Err(error),
             },
         }
@@ -340,33 +378,26 @@ impl<const MAX_DEPTH: usize, const MAX_BUFFER_SIZE: usize>
     /// This method will update the leaf at `index`.
     ///
     /// However if the proof cannot be verified, this method will fail.
-    pub fn set_leaf(
-        &mut self,
-        current_root: Node,
-        previous_leaf: Node,
-        new_leaf: Node,
-        proof_vec: &[Node],
-        index: u32,
-    ) -> Result<Node, ConcurrentMerkleTreeError> {
+    pub fn set_leaf(&mut self, args: &SetLeafArgs) -> Result<Node, ConcurrentMerkleTreeError> {
         check_bounds(MAX_DEPTH, MAX_BUFFER_SIZE);
-        check_leaf_index(index, MAX_DEPTH)?;
+        check_leaf_index(args.index, MAX_DEPTH)?;
         if !self.is_initialized() {
             return Err(ConcurrentMerkleTreeError::TreeNotInitialized);
         }
 
-        if index > self.rightmost_proof.index {
+        if args.index > self.rightmost_proof.index {
             Err(ConcurrentMerkleTreeError::LeafIndexOutOfBounds)
         } else {
             let mut proof: [Node; MAX_DEPTH] = [Node::default(); MAX_DEPTH];
-            fill_in_proof::<MAX_DEPTH>(proof_vec, &mut proof);
+            fill_in_proof::<MAX_DEPTH>(&args.proof_vec, &mut proof);
 
             log_compute!();
             self.try_apply_proof(
-                current_root,
-                previous_leaf,
-                new_leaf,
+                args.current_root,
+                args.previous_leaf,
+                args.new_leaf,
                 &mut proof,
-                index,
+                args.index,
                 true,
             )
         }
diff --git a/libraries/concurrent-merkle-tree/src/node.rs b/libraries/concurrent-merkle-tree/src/node.rs
index 876ce61f095..e04613a4f6b 100644
--- a/libraries/concurrent-merkle-tree/src/node.rs
+++ b/libraries/concurrent-merkle-tree/src/node.rs
@@ -11,7 +11,7 @@ pub fn empty_node(level: u32) -> Node {
     empty_node_cached::<0>(level, &[])
 }
 
-/// Calculates and caches the hash of empty nodes up to level i
+/// Calculates the hash of empty nodes up to level i using an existing cache
 pub fn empty_node_cached<const N: usize>(level: u32, cache: &[Node; N]) -> Node {
     let mut data = EMPTY;
     if level != 0 {
@@ -26,3 +26,20 @@ pub fn empty_node_cached<const N: usize>(level: u32, cache: &[Node; N]) -> Node
     }
     data
 }
+
+/// Calculates and caches the hash of empty nodes up to level i
+pub fn empty_node_cached_mut<const N: usize>(level: u32, cache: &mut [Node; N]) -> Node {
+    let mut data = EMPTY;
+    if level != 0 {
+        let target = (level - 1) as usize;
+        let lower_empty = if target < cache.len() && cache[target] != EMPTY {
+            cache[target]
+        } else {
+            empty_node(target as u32)
+        };
+        let hash = hashv(&[lower_empty.as_ref(), lower_empty.as_ref()]);
+        data.copy_from_slice(hash.as_ref());
+    }
+    cache[level as usize] = data;
+    data
+}
diff --git a/libraries/concurrent-merkle-tree/tests/tests.rs b/libraries/concurrent-merkle-tree/tests/tests.rs
index 1c887add5c5..240770d61cf 100644
--- a/libraries/concurrent-merkle-tree/tests/tests.rs
+++ b/libraries/concurrent-merkle-tree/tests/tests.rs
@@ -2,7 +2,10 @@
 use {
     rand::{self, thread_rng, Rng},
     spl_concurrent_merkle_tree::{
-        concurrent_merkle_tree::ConcurrentMerkleTree,
+        concurrent_merkle_tree::{
+            ConcurrentMerkleTree, FillEmptyOrAppendArgs, InitializeWithRootArgs, ProveLeafArgs,
+            SetLeafArgs,
+        },
         error::ConcurrentMerkleTreeError,
         node::{Node, EMPTY},
     },
@@ -56,25 +59,25 @@ async fn test_bypass_initialize() {
 
     assert_eq!(
         ConcurrentMerkleTreeError::TreeNotInitialized,
-        cmt.set_leaf(
-            off_chain_tree.get_root(),
-            [0; 32],
-            leaf,
-            &off_chain_tree.get_proof_of_leaf(0),
-            0
-        )
-        .unwrap_err(),
+        cmt.set_leaf(&SetLeafArgs {
+            current_root: off_chain_tree.get_root(),
+            previous_leaf: [0; 32],
+            new_leaf: leaf,
+            proof_vec: off_chain_tree.get_proof_of_leaf(0),
+            index: 0
+        },)
+            .unwrap_err(),
         "Expected TreeNotInitialized error when setting a leaf on an uninitialized tree"
     );
 
     assert_eq!(
         ConcurrentMerkleTreeError::TreeNotInitialized,
-        cmt.prove_leaf(
-            off_chain_tree.get_root(),
+        cmt.prove_leaf(&ProveLeafArgs {
+            current_root: off_chain_tree.get_root(),
             leaf,
-            &off_chain_tree.get_proof_of_leaf(0),
-            0,
-        )
+            proof_vec: off_chain_tree.get_proof_of_leaf(0),
+            index: 0
+        })
         .unwrap_err(),
         "Expected TreeNotInitialized error when proving a leaf exists on an uninitialized tree"
     );
@@ -82,10 +85,7 @@ async fn test_bypass_initialize() {
     assert_eq!(
         ConcurrentMerkleTreeError::TreeNotInitialized,
         cmt.fill_empty_or_append(
-            off_chain_tree.get_root(),
-            leaf,
-            &off_chain_tree.get_proof_of_leaf(0),
-            0,
+            &FillEmptyOrAppendArgs { current_root: off_chain_tree.get_root(), leaf, proof_vec: off_chain_tree.get_proof_of_leaf(0), index: 0 }
         )
         .unwrap_err(),
         "Expected TreeNotInitialized error when filling an empty leaf or appending to uninitialized tree"
@@ -129,12 +129,12 @@ async fn test_prove_leaf() {
 
     // Test that all leaves can be verified
     for leaf_index in 0..(1 << DEPTH) {
-        cmt.prove_leaf(
-            off_chain_tree.get_root(),
-            off_chain_tree.get_leaf(leaf_index),
-            &off_chain_tree.get_proof_of_leaf(leaf_index),
-            leaf_index as u32,
-        )
+        cmt.prove_leaf(&ProveLeafArgs {
+            current_root: off_chain_tree.get_root(),
+            leaf: off_chain_tree.get_leaf(leaf_index),
+            proof_vec: off_chain_tree.get_proof_of_leaf(leaf_index),
+            index: leaf_index as u32,
+        })
         .unwrap();
     }
 
@@ -156,19 +156,24 @@ async fn test_prove_leaf() {
                 random_leaf_idx = rng.gen_range(0..1 << DEPTH);
             }
 
-            cmt.set_leaf(
-                off_chain_tree.get_root(),
-                off_chain_tree.get_leaf(random_leaf_idx),
+            cmt.set_leaf(&SetLeafArgs {
+                current_root: off_chain_tree.get_root(),
+                previous_leaf: off_chain_tree.get_leaf(random_leaf_idx),
                 new_leaf,
-                &off_chain_tree.get_proof_of_leaf(random_leaf_idx),
-                random_leaf_idx as u32,
-            )
+                proof_vec: off_chain_tree.get_proof_of_leaf(random_leaf_idx),
+                index: random_leaf_idx as u32,
+            })
             .unwrap();
             off_chain_tree.add_leaf(new_leaf, random_leaf_idx);
 
             // Assert that we can still prove existence of our mostly unused leaf
-            cmt.prove_leaf(root, leaf, &old_proof, leaf_idx as u32)
-                .unwrap();
+            cmt.prove_leaf(&ProveLeafArgs {
+                current_root: root,
+                leaf,
+                proof_vec: old_proof.clone(),
+                index: leaf_idx as u32,
+            })
+            .unwrap();
         }
     }
 }
@@ -183,12 +188,12 @@ async fn test_initialize_with_root() {
     }
 
     let last_leaf_idx = tree.leaf_nodes.len() - 1;
-    cmt.initialize_with_root(
-        tree.get_root(),
-        tree.get_leaf(last_leaf_idx),
-        &tree.get_proof_of_leaf(last_leaf_idx),
-        last_leaf_idx as u32,
-    )
+    cmt.initialize_with_root(&InitializeWithRootArgs {
+        root: tree.get_root(),
+        rightmost_leaf: tree.get_leaf(last_leaf_idx),
+        proof_vec: tree.get_proof_of_leaf(last_leaf_idx),
+        index: last_leaf_idx as u32,
+    })
     .unwrap();
 
     assert_eq!(
@@ -198,12 +203,14 @@ async fn test_initialize_with_root() {
     );
 
     // Check that reinitialization fails
-    if let Err(ConcurrentMerkleTreeError::TreeAlreadyInitialized) = cmt.initialize_with_root(
-        tree.get_root(),
-        tree.get_leaf(last_leaf_idx),
-        &tree.get_proof_of_leaf(last_leaf_idx),
-        last_leaf_idx as u32,
-    ) {
+    if let Err(ConcurrentMerkleTreeError::TreeAlreadyInitialized) =
+        cmt.initialize_with_root(&InitializeWithRootArgs {
+            root: tree.get_root(),
+            rightmost_leaf: tree.get_leaf(last_leaf_idx),
+            proof_vec: tree.get_proof_of_leaf(last_leaf_idx),
+            index: last_leaf_idx as u32,
+        })
+    {
         println!("Reinitialization with root successfully prevented");
     } else {
         panic!("Tree should not be able to be reinitialized");
@@ -228,12 +235,25 @@ async fn test_leaf_contents_modified() {
     // Update leaf to be something else
     let new_leaf_0 = rng.gen::<[u8; 32]>();
     tree.add_leaf(leaf, 0);
-    cmt.set_leaf(root, leaf, new_leaf_0, &proof, 0_u32).unwrap();
+    cmt.set_leaf(&SetLeafArgs {
+        current_root: root,
+        previous_leaf: leaf,
+        new_leaf: new_leaf_0,
+        proof_vec: proof.clone(),
+        index: 0_u32,
+    })
+    .unwrap();
 
     // Should fail to replace same leaf using outdated info
     let new_leaf_1 = rng.gen::<[u8; 32]>();
     tree.add_leaf(leaf, 0);
-    match cmt.set_leaf(root, leaf, new_leaf_1, &proof, 0_u32) {
+    match cmt.set_leaf(&SetLeafArgs {
+        current_root: root,
+        previous_leaf: leaf,
+        new_leaf: new_leaf_1,
+        proof_vec: proof,
+        index: 0u32,
+    }) {
         Ok(_) => {
             panic!("CMT should fail when replacing leafs with outdated leaf proofs")
         }
@@ -263,13 +283,13 @@ async fn test_replaces() {
     // Replace leaves in order
     for i in 0..(1 << DEPTH) {
         let leaf = rng.gen::<[u8; 32]>();
-        cmt.set_leaf(
-            tree.get_root(),
-            tree.get_leaf(i),
-            leaf,
-            &tree.get_proof_of_leaf(i),
-            i as u32,
-        )
+        cmt.set_leaf(&SetLeafArgs {
+            current_root: tree.get_root(),
+            previous_leaf: tree.get_leaf(i),
+            new_leaf: leaf,
+            proof_vec: tree.get_proof_of_leaf(i),
+            index: i as u32,
+        })
         .unwrap();
         tree.add_leaf(leaf, i);
         assert_eq!(cmt.get_change_log().root, tree.get_root());
@@ -280,13 +300,13 @@ async fn test_replaces() {
     for _ in 0..(test_capacity) {
         let index = rng.gen_range(0..test_capacity) % (1 << DEPTH);
         let leaf = rng.gen::<[u8; 32]>();
-        cmt.set_leaf(
-            tree.get_root(),
-            tree.get_leaf(index),
-            leaf,
-            &tree.get_proof_of_leaf(index),
-            index as u32,
-        )
+        cmt.set_leaf(&SetLeafArgs {
+            current_root: tree.get_root(),
+            previous_leaf: tree.get_leaf(index),
+            new_leaf: leaf,
+            proof_vec: tree.get_proof_of_leaf(index),
+            index: index as u32,
+        })
         .unwrap();
         tree.add_leaf(leaf, index);
         assert_eq!(cmt.get_change_log().root, tree.get_root());
@@ -332,13 +352,13 @@ async fn test_mixed() {
         } else {
             let index = rng.gen_range(0..tree_size) % (tree_size);
             println!("{} replace {}", tree_size, index);
-            cmt.set_leaf(
-                tree.get_root(),
-                tree.get_leaf(index),
-                leaf,
-                &tree.get_proof_of_leaf(index),
-                index as u32,
-            )
+            cmt.set_leaf(&SetLeafArgs {
+                current_root: tree.get_root(),
+                previous_leaf: tree.get_leaf(index),
+                new_leaf: leaf,
+                proof_vec: tree.get_proof_of_leaf(index),
+                index: index as u32,
+            })
             .unwrap();
             tree.add_leaf(leaf, index);
         }
@@ -373,13 +393,13 @@ async fn test_append_bug_repro_1() {
     // Replace the rightmost leaf
     let leaf_0 = rng.gen::<[u8; 32]>();
     let index = 9;
-    cmt.set_leaf(
-        tree.get_root(),
-        tree.get_leaf(index),
-        leaf_0,
-        &tree.get_proof_of_leaf(index),
-        index as u32,
-    )
+    cmt.set_leaf(&SetLeafArgs {
+        current_root: tree.get_root(),
+        previous_leaf: tree.get_leaf(index),
+        new_leaf: leaf_0,
+        proof_vec: tree.get_proof_of_leaf(index),
+        index: index as u32,
+    })
     .unwrap();
     tree.add_leaf(leaf_0, index);
 
@@ -417,13 +437,13 @@ async fn test_append_bug_repro_2() {
     // Replace the rightmost leaf
     let mut leaf = rng.gen::<[u8; 32]>();
     let index = 10;
-    cmt.set_leaf(
-        tree.get_root(),
-        tree.get_leaf(index),
-        leaf,
-        &tree.get_proof_of_leaf(index),
-        index as u32,
-    )
+    cmt.set_leaf(&SetLeafArgs {
+        current_root: tree.get_root(),
+        previous_leaf: tree.get_leaf(index),
+        new_leaf: leaf,
+        proof_vec: tree.get_proof_of_leaf(index),
+        index: index as u32,
+    })
     .unwrap();
     tree.add_leaf(leaf, index);
     tree_size += 1;
@@ -473,13 +493,13 @@ async fn test_prove_tree_empty_incremental() {
             },
         }
 
-        cmt.set_leaf(
-            tree.get_root(),
-            tree.get_leaf(i),
-            EMPTY,
-            &tree.get_proof_of_leaf(i),
-            i as u32,
-        )
+        cmt.set_leaf(&SetLeafArgs {
+            current_root: tree.get_root(),
+            previous_leaf: tree.get_leaf(i),
+            new_leaf: EMPTY,
+            proof_vec: tree.get_proof_of_leaf(i),
+            index: i as u32,
+        })
         .unwrap();
         tree.add_leaf(EMPTY, i);
 
@@ -519,13 +539,13 @@ async fn test_prove_tree_empty_batched() {
     }
     // Remove random leaves
     for i in 0..tree_size - 1 {
-        cmt.set_leaf(
-            tree.get_root(),
-            tree.get_leaf(i),
-            EMPTY,
-            &tree.get_proof_of_leaf(i),
-            i as u32,
-        )
+        cmt.set_leaf(&SetLeafArgs {
+            current_root: tree.get_root(),
+            previous_leaf: tree.get_leaf(i),
+            new_leaf: EMPTY,
+            proof_vec: tree.get_proof_of_leaf(i),
+            index: i as u32,
+        })
         .unwrap();
         tree.add_leaf(EMPTY, i);
 
@@ -541,13 +561,13 @@ async fn test_prove_tree_empty_batched() {
             },
         }
     }
-    cmt.set_leaf(
-        tree.get_root(),
-        tree.get_leaf(tree_size - 1),
-        EMPTY,
-        &tree.get_proof_of_leaf(tree_size - 1),
-        (tree_size - 1) as u32,
-    )
+    cmt.set_leaf(&SetLeafArgs {
+        current_root: tree.get_root(),
+        previous_leaf: tree.get_leaf(tree_size - 1),
+        new_leaf: EMPTY,
+        proof_vec: tree.get_proof_of_leaf(tree_size - 1),
+        index: (tree_size - 1) as u32,
+    })
     .unwrap();
     tree.add_leaf(EMPTY, tree_size - 1);
 
diff --git a/libraries/discriminator/Cargo.toml b/libraries/discriminator/Cargo.toml
deleted file mode 100644
index 0f3f003f9e5..00000000000
--- a/libraries/discriminator/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "spl-discriminator"
-version = "0.2.2"
-description = "Solana Program Library 8-Byte Discriminator Management"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-borsh = ["dep:borsh"]
-
-[dependencies]
-borsh = { version = "1", optional = true }
-bytemuck = { version = "1.16.0", features = ["derive"] }
-solana-program = ">=1.18.11,<=2"
-spl-discriminator-derive = { version = "0.2.0", path = "./derive" }
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/discriminator/README.md b/libraries/discriminator/README.md
deleted file mode 100644
index 8d31cc70667..00000000000
--- a/libraries/discriminator/README.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# SPL Discriminator
-
-This library allows for easy management of 8-byte discriminators.
-
-### The `ArrayDiscriminator` Struct
-
-With this crate, you can leverage the `ArrayDiscriminator` type to manage an 8-byte discriminator for generic purposes.
-
-```rust
-let my_discriminator = ArrayDiscriminator::new([8, 5, 1, 56, 10, 53, 9, 198]);
-```
-
-The `new(..)` function is also a **constant function**, so you can use `ArrayDiscriminator` in constants as well.
-
-```rust
-const MY_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([8, 5, 1, 56, 10, 53, 9, 198]);
-```
-
-The `ArrayDiscriminator` struct also offers another constant function `as_slice(&self)`, so you can use `as_slice()` in constants as well.
-
-```rust
-const MY_DISCRIMINATOR_SLICE: &[u8] = MY_DISCRIMINATOR.as_slice();
-```
-
-### The `SplDiscriminate` Trait
-
-A trait, `SplDiscriminate` is also available, which will give you the `ArrayDiscriminator` constant type and also a slice representation of the discriminator. This can be particularly handy with match statements.
-
-```rust
-/// A trait for managing 8-byte discriminators in a slab of bytes
-pub trait SplDiscriminate {
-    /// The 8-byte discriminator as a `[u8; 8]`
-    const SPL_DISCRIMINATOR: ArrayDiscriminator;
-    /// The 8-byte discriminator as a slice (`&[u8]`)
-    const SPL_DISCRIMINATOR_SLICE: &'static [u8] = Self::SPL_DISCRIMINATOR.as_slice();
-}
-```
-
-### The `SplDiscriminate` Derive Macro
-
-The `SplDiscriminate` derive macro is a particularly useful tool for those who wish to derive their 8-byte discriminator from a particular string literal. Typically, you would have to run a hash function against the string literal, then copy the first 8 bytes, and then hard-code those bytes into a statement like the one above.
-
-Instead, you can simply annotate a struct or enum with `SplDiscriminate` and provide a **hash input** via the `discriminator_hash_input` attribute, and the macro will automatically derive the 8-byte discriminator for you!
-
-```rust
-#[derive(SplDiscriminate)] // Implements `SplDiscriminate` for your struct/enum using your declared string literal hash_input
-#[discriminator_hash_input("some_discriminator_hash_input")]
-pub struct MyInstruction1 {
-    arg1: String,
-    arg2: u8,
-}
-
-let my_discriminator: ArrayDiscriminator = MyInstruction1::SPL_DISCRIMINATOR;
-let my_discriminator_slice: &[u8] = MyInstruction1::SPL_DISCRIMINATOR_SLICE;
-```
-
-Note: the 8-byte discriminator derived using the macro is always the **first 8 bytes** of the resulting hashed bytes.
diff --git a/libraries/discriminator/derive/Cargo.toml b/libraries/discriminator/derive/Cargo.toml
deleted file mode 100644
index 32ce6085708..00000000000
--- a/libraries/discriminator/derive/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "spl-discriminator-derive"
-version = "0.2.0"
-description = "Derive macro library for the `spl-discriminator` library"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-quote = "1.0"
-spl-discriminator-syn = { version = "0.2.0", path = "../syn" }
-syn = { version = "2.0", features = ["full"] }
-
-[lib]
-proc-macro = true
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/discriminator/derive/src/lib.rs b/libraries/discriminator/derive/src/lib.rs
deleted file mode 100644
index 6080b80b226..00000000000
--- a/libraries/discriminator/derive/src/lib.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! Derive macro library for the `spl-discriminator` library
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-extern crate proc_macro;
-
-use {
-    proc_macro::TokenStream, quote::ToTokens, spl_discriminator_syn::SplDiscriminateBuilder,
-    syn::parse_macro_input,
-};
-
-/// Derive macro library to implement the `SplDiscriminate` trait
-/// on an enum or struct
-#[proc_macro_derive(SplDiscriminate, attributes(discriminator_hash_input))]
-pub fn spl_discriminator(input: TokenStream) -> TokenStream {
-    parse_macro_input!(input as SplDiscriminateBuilder)
-        .to_token_stream()
-        .into()
-}
diff --git a/libraries/discriminator/src/discriminator.rs b/libraries/discriminator/src/discriminator.rs
deleted file mode 100644
index af5a4723f1d..00000000000
--- a/libraries/discriminator/src/discriminator.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//! The traits and types used to create a discriminator for a type
-
-use {
-    bytemuck::{Pod, Zeroable},
-    solana_program::{hash, program_error::ProgramError},
-};
-
-/// A trait for managing 8-byte discriminators in a slab of bytes
-pub trait SplDiscriminate {
-    /// The 8-byte discriminator as a `[u8; 8]`
-    const SPL_DISCRIMINATOR: ArrayDiscriminator;
-    /// The 8-byte discriminator as a slice (`&[u8]`)
-    const SPL_DISCRIMINATOR_SLICE: &'static [u8] = Self::SPL_DISCRIMINATOR.as_slice();
-}
-
-/// Array Discriminator type
-#[cfg_attr(
-    feature = "borsh",
-    derive(borsh::BorshSerialize, borsh::BorshDeserialize)
-)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct ArrayDiscriminator([u8; ArrayDiscriminator::LENGTH]);
-impl ArrayDiscriminator {
-    /// Size for discriminator in account data
-    pub const LENGTH: usize = 8;
-    /// Uninitialized variant of a discriminator
-    pub const UNINITIALIZED: Self = Self::new([0; Self::LENGTH]);
-    /// Creates a discriminator from an array
-    pub const fn new(value: [u8; Self::LENGTH]) -> Self {
-        Self(value)
-    }
-    /// Get the array as a const slice
-    pub const fn as_slice(&self) -> &[u8] {
-        self.0.as_slice()
-    }
-    /// Creates a new `ArrayDiscriminator` from some hash input string literal
-    pub fn new_with_hash_input(hash_input: &str) -> Self {
-        let hash_bytes = hash::hashv(&[hash_input.as_bytes()]).to_bytes();
-        let mut discriminator_bytes = [0u8; 8];
-        discriminator_bytes.copy_from_slice(&hash_bytes[..8]);
-        Self(discriminator_bytes)
-    }
-}
-impl AsRef<[u8]> for ArrayDiscriminator {
-    fn as_ref(&self) -> &[u8] {
-        &self.0[..]
-    }
-}
-impl AsRef<[u8; ArrayDiscriminator::LENGTH]> for ArrayDiscriminator {
-    fn as_ref(&self) -> &[u8; ArrayDiscriminator::LENGTH] {
-        &self.0
-    }
-}
-impl From<u64> for ArrayDiscriminator {
-    fn from(from: u64) -> Self {
-        Self(from.to_le_bytes())
-    }
-}
-impl From<[u8; Self::LENGTH]> for ArrayDiscriminator {
-    fn from(from: [u8; Self::LENGTH]) -> Self {
-        Self(from)
-    }
-}
-impl TryFrom<&[u8]> for ArrayDiscriminator {
-    type Error = ProgramError;
-    fn try_from(a: &[u8]) -> Result<Self, Self::Error> {
-        <[u8; Self::LENGTH]>::try_from(a)
-            .map(Self::from)
-            .map_err(|_| ProgramError::InvalidAccountData)
-    }
-}
-impl From<ArrayDiscriminator> for [u8; 8] {
-    fn from(from: ArrayDiscriminator) -> Self {
-        from.0
-    }
-}
-impl From<ArrayDiscriminator> for u64 {
-    fn from(from: ArrayDiscriminator) -> Self {
-        u64::from_le_bytes(from.0)
-    }
-}
diff --git a/libraries/discriminator/src/lib.rs b/libraries/discriminator/src/lib.rs
deleted file mode 100644
index c3ebbdaba43..00000000000
--- a/libraries/discriminator/src/lib.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-//! Crate defining a discriminator type, which creates a set of bytes
-//! meant to be unique for instructions or struct types
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-extern crate self as spl_discriminator;
-
-/// Exports the discriminator module
-pub mod discriminator;
-
-// Export for downstream
-pub use {
-    discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_discriminator_derive::SplDiscriminate,
-};
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::discriminator::ArrayDiscriminator};
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("my_first_instruction")]
-    pub struct MyInstruction1 {
-        arg1: String,
-        arg2: u8,
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("global:my_second_instruction")]
-    pub enum MyInstruction2 {
-        One,
-        Two,
-        Three,
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("global:my_instruction_with_lifetime")]
-    pub struct MyInstruction3<'a> {
-        data: &'a [u8],
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("global:my_instruction_with_one_generic")]
-    pub struct MyInstruction4<T> {
-        data: T,
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("global:my_instruction_with_one_generic_and_lifetime")]
-    pub struct MyInstruction5<'b, T> {
-        data: &'b [T],
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input("global:my_instruction_with_multiple_generics_and_lifetime")]
-    pub struct MyInstruction6<'c, U, V> {
-        data1: &'c [U],
-        data2: &'c [V],
-    }
-
-    #[allow(dead_code)]
-    #[derive(SplDiscriminate)]
-    #[discriminator_hash_input(
-        "global:my_instruction_with_multiple_generics_and_lifetime_and_where"
-    )]
-    pub struct MyInstruction7<'c, U, V>
-    where
-        U: Clone + Copy,
-        V: Clone + Copy,
-    {
-        data1: &'c [U],
-        data2: &'c [V],
-    }
-
-    fn assert_discriminator<T: spl_discriminator::discriminator::SplDiscriminate>(
-        hash_input: &str,
-    ) {
-        let discriminator = build_discriminator(hash_input);
-        assert_eq!(
-            T::SPL_DISCRIMINATOR,
-            discriminator,
-            "Discriminator mismatch: case: {}",
-            hash_input
-        );
-        assert_eq!(
-            T::SPL_DISCRIMINATOR_SLICE,
-            discriminator.as_slice(),
-            "Discriminator mismatch: case: {}",
-            hash_input
-        );
-    }
-
-    fn build_discriminator(hash_input: &str) -> ArrayDiscriminator {
-        let preimage = solana_program::hash::hashv(&[hash_input.as_bytes()]);
-        let mut bytes = [0u8; 8];
-        bytes.copy_from_slice(&preimage.to_bytes()[..8]);
-        ArrayDiscriminator::new(bytes)
-    }
-
-    #[test]
-    fn test_discrminators() {
-        let runtime_discrim = ArrayDiscriminator::new_with_hash_input("my_runtime_hash_input");
-        assert_eq!(
-            runtime_discrim,
-            build_discriminator("my_runtime_hash_input"),
-        );
-
-        assert_discriminator::<MyInstruction1>("my_first_instruction");
-        assert_discriminator::<MyInstruction2>("global:my_second_instruction");
-        assert_discriminator::<MyInstruction3<'_>>("global:my_instruction_with_lifetime");
-        assert_discriminator::<MyInstruction4<u8>>("global:my_instruction_with_one_generic");
-        assert_discriminator::<MyInstruction5<'_, u8>>(
-            "global:my_instruction_with_one_generic_and_lifetime",
-        );
-        assert_discriminator::<MyInstruction6<'_, u8, u8>>(
-            "global:my_instruction_with_multiple_generics_and_lifetime",
-        );
-        assert_discriminator::<MyInstruction7<'_, u8, u8>>(
-            "global:my_instruction_with_multiple_generics_and_lifetime_and_where",
-        );
-    }
-}
-
-#[cfg(all(test, feature = "borsh"))]
-mod borsh_test {
-    use super::*;
-
-    #[test]
-    fn borsh_test() {
-        let my_discrim = ArrayDiscriminator::new_with_hash_input("my_discrim");
-        let mut buffer = [0u8; 8];
-        my_discrim.serialize(&mut buffer[..]).unwrap();
-        let my_discrim_again = ArrayDiscriminator::try_from_slice(&buffer).unwrap();
-        assert_eq!(my_discrim, my_discrim_again);
-        assert_eq!(buf, my_discrim.into());
-    }
-}
diff --git a/libraries/discriminator/syn/Cargo.toml b/libraries/discriminator/syn/Cargo.toml
deleted file mode 100644
index 5bd4f59ca95..00000000000
--- a/libraries/discriminator/syn/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "spl-discriminator-syn"
-version = "0.2.0"
-description = "Token parsing and generating library for the `spl-discriminator` library"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-sha2 = "0.10"
-syn = { version = "2.0", features = ["full"] }
-thiserror = "1.0"
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/discriminator/syn/src/error.rs b/libraries/discriminator/syn/src/error.rs
deleted file mode 100644
index 5dd4c30d3c2..00000000000
--- a/libraries/discriminator/syn/src/error.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! Error types for the `hash_input` parser
-
-/// Error types for the `hash_input` parser
-#[derive(Clone, Debug, Eq, thiserror::Error, PartialEq)]
-pub enum SplDiscriminateError {
-    /// Discriminator hash_input attribute not provided
-    #[error("Discriminator `hash_input` attribute not provided")]
-    HashInputAttributeNotProvided,
-    /// Error parsing discriminator hash_input attribute
-    #[error("Error parsing discriminator `hash_input` attribute")]
-    HashInputAttributeParseError,
-}
diff --git a/libraries/discriminator/syn/src/lib.rs b/libraries/discriminator/syn/src/lib.rs
deleted file mode 100644
index db555916573..00000000000
--- a/libraries/discriminator/syn/src/lib.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-//! Token parsing and generating library for the `spl-discriminator` library
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-mod error;
-pub mod parser;
-
-use {
-    crate::{error::SplDiscriminateError, parser::parse_hash_input},
-    proc_macro2::{Span, TokenStream},
-    quote::{quote, ToTokens},
-    sha2::{Digest, Sha256},
-    syn::{parse::Parse, Generics, Ident, Item, ItemEnum, ItemStruct, LitByteStr, WhereClause},
-};
-
-/// "Builder" struct to implement the `SplDiscriminate` trait
-/// on an enum or struct
-pub struct SplDiscriminateBuilder {
-    /// The struct/enum identifier
-    pub ident: Ident,
-    /// The item's generic arguments (if any)
-    pub generics: Generics,
-    /// The item's where clause for generics (if any)
-    pub where_clause: Option<WhereClause>,
-    /// The TLV hash_input
-    pub hash_input: String,
-}
-
-impl TryFrom<ItemEnum> for SplDiscriminateBuilder {
-    type Error = SplDiscriminateError;
-
-    fn try_from(item_enum: ItemEnum) -> Result<Self, Self::Error> {
-        let ident = item_enum.ident;
-        let where_clause = item_enum.generics.where_clause.clone();
-        let generics = item_enum.generics;
-        let hash_input = parse_hash_input(&item_enum.attrs)?;
-        Ok(Self {
-            ident,
-            generics,
-            where_clause,
-            hash_input,
-        })
-    }
-}
-
-impl TryFrom<ItemStruct> for SplDiscriminateBuilder {
-    type Error = SplDiscriminateError;
-
-    fn try_from(item_struct: ItemStruct) -> Result<Self, Self::Error> {
-        let ident = item_struct.ident;
-        let where_clause = item_struct.generics.where_clause.clone();
-        let generics = item_struct.generics;
-        let hash_input = parse_hash_input(&item_struct.attrs)?;
-        Ok(Self {
-            ident,
-            generics,
-            where_clause,
-            hash_input,
-        })
-    }
-}
-
-impl Parse for SplDiscriminateBuilder {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let item = Item::parse(input)?;
-        match item {
-            Item::Enum(item_enum) => item_enum.try_into(),
-            Item::Struct(item_struct) => item_struct.try_into(),
-            _ => {
-                return Err(syn::Error::new(
-                    Span::call_site(),
-                    "Only enums and structs are supported",
-                ))
-            }
-        }
-        .map_err(|e| syn::Error::new(input.span(), format!("Failed to parse item: {}", e)))
-    }
-}
-
-impl ToTokens for SplDiscriminateBuilder {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        tokens.extend::<TokenStream>(self.into());
-    }
-}
-
-impl From<&SplDiscriminateBuilder> for TokenStream {
-    fn from(builder: &SplDiscriminateBuilder) -> Self {
-        let ident = &builder.ident;
-        let generics = &builder.generics;
-        let where_clause = &builder.where_clause;
-        let bytes = get_discriminator_bytes(&builder.hash_input);
-        quote! {
-            impl #generics spl_discriminator::discriminator::SplDiscriminate for #ident #generics #where_clause {
-                const SPL_DISCRIMINATOR: spl_discriminator::discriminator::ArrayDiscriminator
-                    = spl_discriminator::discriminator::ArrayDiscriminator::new(*#bytes);
-            }
-        }
-    }
-}
-
-/// Returns the bytes for the TLV hash_input discriminator
-fn get_discriminator_bytes(hash_input: &str) -> LitByteStr {
-    LitByteStr::new(
-        &Sha256::digest(hash_input.as_bytes())[..8],
-        Span::call_site(),
-    )
-}
diff --git a/libraries/discriminator/syn/src/parser.rs b/libraries/discriminator/syn/src/parser.rs
deleted file mode 100644
index 1d70c3ab304..00000000000
--- a/libraries/discriminator/syn/src/parser.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//! Parser for the `syn` crate to parse the
-//! `#[discriminator_hash_input("...")]` attribute
-
-use {
-    crate::error::SplDiscriminateError,
-    syn::{
-        parse::{Parse, ParseStream},
-        token::Comma,
-        Attribute, LitStr,
-    },
-};
-
-/// Struct used for `syn` parsing of the hash_input attribute
-/// #[discriminator_hash_input("...")]
-struct HashInputValueParser {
-    value: LitStr,
-    _comma: Option<Comma>,
-}
-
-impl Parse for HashInputValueParser {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        let value: LitStr = input.parse()?;
-        let _comma: Option<Comma> = input.parse().unwrap_or(None);
-        Ok(HashInputValueParser { value, _comma })
-    }
-}
-
-/// Parses the hash_input from the `#[discriminator_hash_input("...")]`
-/// attribute
-pub fn parse_hash_input(attrs: &[Attribute]) -> Result<String, SplDiscriminateError> {
-    match attrs
-        .iter()
-        .find(|a| a.path().is_ident("discriminator_hash_input"))
-    {
-        Some(attr) => {
-            let parsed_args = attr
-                .parse_args::<HashInputValueParser>()
-                .map_err(|_| SplDiscriminateError::HashInputAttributeParseError)?;
-            Ok(parsed_args.value.value())
-        }
-        None => Err(SplDiscriminateError::HashInputAttributeNotProvided),
-    }
-}
diff --git a/instruction-padding/program/Cargo.toml b/libraries/math-example/Cargo.toml
similarity index 55%
rename from instruction-padding/program/Cargo.toml
rename to libraries/math-example/Cargo.toml
index 25a983e2091..fe6e995544d 100644
--- a/instruction-padding/program/Cargo.toml
+++ b/libraries/math-example/Cargo.toml
@@ -1,11 +1,10 @@
 [package]
-name = "spl-instruction-padding"
-version = "0.1.1"
-description = "Solana Program Library Instruction Padding Program"
+name = "spl-math-example"
+version = "0.1.0"
+description = "Solana Program Library Math Example"
 authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
 repository = "https://github.com/solana-labs/solana-program-library"
 license = "Apache-2.0"
-homepage = "https://solana.com/"
 edition = "2021"
 
 [features]
@@ -13,15 +12,20 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-num_enum = "0.7.2"
-solana-program = ">=1.18.11,<=2"
+borsh = "1.5.3"
+num-derive = "0.4"
+num-traits = "0.2"
+solana-program = "2.1.0"
+spl-math = { path = "../math", version = "0.3.0" }
+thiserror = "2.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
+
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
diff --git a/record/program/README.md b/libraries/math-example/README.md
similarity index 56%
rename from record/program/README.md
rename to libraries/math-example/README.md
index 188614925a6..2035ce0c8f0 100644
--- a/record/program/README.md
+++ b/libraries/math-example/README.md
@@ -1,7 +1,6 @@
-# Record
+# Math
 
-On-chain program for writing arbitrary data to an account, authorized by an
-owner of the account.
+Program wrapper around the spl-math-utils crate. The program exists for testing purposes.
 
 ## Audit
 
diff --git a/associated-token-account/program/Xargo.toml b/libraries/math-example/Xargo.toml
similarity index 100%
rename from associated-token-account/program/Xargo.toml
rename to libraries/math-example/Xargo.toml
diff --git a/associated-token-account/program/src/entrypoint.rs b/libraries/math-example/src/entrypoint.rs
similarity index 100%
rename from associated-token-account/program/src/entrypoint.rs
rename to libraries/math-example/src/entrypoint.rs
diff --git a/libraries/math/src/error.rs b/libraries/math-example/src/error.rs
similarity index 100%
rename from libraries/math/src/error.rs
rename to libraries/math-example/src/error.rs
diff --git a/libraries/math/src/instruction.rs b/libraries/math-example/src/instruction.rs
similarity index 100%
rename from libraries/math/src/instruction.rs
rename to libraries/math-example/src/instruction.rs
diff --git a/libraries/math-example/src/lib.rs b/libraries/math-example/src/lib.rs
new file mode 100644
index 00000000000..e0162970628
--- /dev/null
+++ b/libraries/math-example/src/lib.rs
@@ -0,0 +1,13 @@
+//! Math operations using unsigned integers
+
+#![deny(missing_docs)]
+#![forbid(unsafe_code)]
+
+mod entrypoint;
+pub mod error;
+pub mod instruction;
+pub mod processor;
+
+pub use spl_math::{approximations, checked_ceil_div, precise_number, uint};
+
+solana_program::declare_id!("Math111111111111111111111111111111111111111");
diff --git a/libraries/math/src/processor.rs b/libraries/math-example/src/processor.rs
similarity index 100%
rename from libraries/math/src/processor.rs
rename to libraries/math-example/src/processor.rs
diff --git a/libraries/math/tests/instruction_count.rs b/libraries/math-example/tests/instruction_count.rs
similarity index 69%
rename from libraries/math/tests/instruction_count.rs
rename to libraries/math-example/tests/instruction_count.rs
index 3604325d4cf..a7dbd26aad2 100644
--- a/libraries/math/tests/instruction_count.rs
+++ b/libraries/math-example/tests/instruction_count.rs
@@ -5,18 +5,18 @@
 use {
     solana_program_test::*,
     solana_sdk::{signature::Signer, transaction::Transaction},
-    spl_math::{id, instruction, processor::process_instruction},
+    spl_math_example::{id, instruction, processor::process_instruction},
 };
 
 #[tokio::test]
 async fn test_precise_sqrt_u64_max() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     // This is way too big!  It's possible to dial down the numbers to get to
     // something reasonable, but the better option is to do everything in u64
     pc.set_compute_max_units(350_000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::precise_sqrt(u64::MAX)],
@@ -28,11 +28,11 @@ async fn test_precise_sqrt_u64_max() {
 
 #[tokio::test]
 async fn test_precise_sqrt_u32_max() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(170_000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::precise_sqrt(u32::MAX as u64)],
@@ -44,13 +44,13 @@ async fn test_precise_sqrt_u32_max() {
 
 #[tokio::test]
 async fn test_sqrt_u64() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     // Dial down the BPF compute budget to detect if the operation gets bloated in
     // the future
     pc.set_compute_max_units(2_500);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::sqrt_u64(u64::MAX)], Some(&payer.pubkey()));
@@ -60,13 +60,13 @@ async fn test_sqrt_u64() {
 
 #[tokio::test]
 async fn test_sqrt_u128() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     // Dial down the BPF compute budget to detect if the operation gets bloated in
     // the future
     pc.set_compute_max_units(4_100);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::sqrt_u128(u64::MAX as u128)],
@@ -78,11 +78,11 @@ async fn test_sqrt_u128() {
 
 #[tokio::test]
 async fn test_sqrt_u128_max() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(7_000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::sqrt_u128(u128::MAX)], Some(&payer.pubkey()));
@@ -92,11 +92,11 @@ async fn test_sqrt_u128_max() {
 
 #[tokio::test]
 async fn test_u64_multiply() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1350);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::u64_multiply(42, 84)], Some(&payer.pubkey()));
@@ -106,11 +106,11 @@ async fn test_u64_multiply() {
 
 #[tokio::test]
 async fn test_u64_divide() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1650);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::u64_divide(3, 1)], Some(&payer.pubkey()));
@@ -120,11 +120,11 @@ async fn test_u64_divide() {
 
 #[tokio::test]
 async fn test_f32_multiply() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1600);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f32_multiply(1.5_f32, 2.0_f32)],
@@ -136,11 +136,11 @@ async fn test_f32_multiply() {
 
 #[tokio::test]
 async fn test_f32_divide() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1650);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f32_divide(3_f32, 1.5_f32)],
@@ -152,11 +152,11 @@ async fn test_f32_divide() {
 
 #[tokio::test]
 async fn test_f32_exponentiate() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1400);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f32_exponentiate(4_f32, 2_f32)],
@@ -168,11 +168,11 @@ async fn test_f32_exponentiate() {
 
 #[tokio::test]
 async fn test_f32_natural_log() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(3500);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f32_natural_log(1_f32.exp())],
@@ -184,13 +184,13 @@ async fn test_f32_natural_log() {
 
 #[tokio::test]
 async fn test_f32_normal_cdf() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     // Dial down the BPF compute budget to detect if the operation gets bloated in
     // the future
     pc.set_compute_max_units(3_100);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::f32_normal_cdf(0_f32)], Some(&payer.pubkey()));
@@ -200,11 +200,11 @@ async fn test_f32_normal_cdf() {
 
 #[tokio::test]
 async fn test_f64_pow() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(30_000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f64_pow(50_f64, 10.5_f64)],
@@ -216,11 +216,11 @@ async fn test_f64_pow() {
 
 #[tokio::test]
 async fn test_u128_multiply() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(10000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::u128_multiply(u64::MAX.into(), u64::MAX.into())],
@@ -232,11 +232,11 @@ async fn test_u128_multiply() {
 
 #[tokio::test]
 async fn test_u128_divide() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(10000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::u128_divide(u128::MAX, u128::MAX / 69)],
@@ -248,11 +248,11 @@ async fn test_u128_divide() {
 
 #[tokio::test]
 async fn test_f64_multiply() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(10000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f64_multiply(f64::powf(2., 42.), 1e-4)],
@@ -264,11 +264,11 @@ async fn test_f64_multiply() {
 
 #[tokio::test]
 async fn test_f64_divide() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(10000);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[instruction::f64_divide(f64::powf(2., 42.), 420420.6969)],
@@ -280,11 +280,11 @@ async fn test_f64_divide() {
 
 #[tokio::test]
 async fn test_noop() {
-    let mut pc = ProgramTest::new("spl_math", id(), processor!(process_instruction));
+    let mut pc = ProgramTest::new("spl_math_example", id(), processor!(process_instruction));
 
     pc.set_compute_max_units(1200);
 
-    let (mut banks_client, payer, recent_blockhash) = pc.start().await;
+    let (banks_client, payer, recent_blockhash) = pc.start().await;
 
     let mut transaction =
         Transaction::new_with_payer(&[instruction::noop()], Some(&payer.pubkey()));
diff --git a/libraries/math/Cargo.toml b/libraries/math/Cargo.toml
index e9dc8c69ca1..5cc3ee973e2 100644
--- a/libraries/math/Cargo.toml
+++ b/libraries/math/Cargo.toml
@@ -1,33 +1,19 @@
 [package]
 name = "spl-math"
-version = "0.2.0"
+version = "0.3.0"
 description = "Solana Program Library Math"
 authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
 repository = "https://github.com/solana-labs/solana-program-library"
 license = "Apache-2.0"
 edition = "2021"
 
-[features]
-no-entrypoint = []
-test-sbf = []
-
 [dependencies]
-borsh = "1.5.1"
-num-derive = "0.4"
 num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-thiserror = "1.0"
-uint = "0.9"
+uint = "0.10"
 
 [dev-dependencies]
-proptest = "1.4.0"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-libm = "0.2.8"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
+proptest = "1.6.0"
+libm = "0.2.11"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/math/Xargo.toml b/libraries/math/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/libraries/math/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/libraries/math/src/entrypoint.rs b/libraries/math/src/entrypoint.rs
deleted file mode 100644
index 8876e45b78b..00000000000
--- a/libraries/math/src/entrypoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Program entrypoint
-
-#![cfg(not(feature = "no-entrypoint"))]
-
-use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    crate::processor::process_instruction(program_id, accounts, instruction_data)
-}
diff --git a/libraries/math/src/lib.rs b/libraries/math/src/lib.rs
index 3e9c5ba83b4..54c5a430917 100644
--- a/libraries/math/src/lib.rs
+++ b/libraries/math/src/lib.rs
@@ -1,15 +1,6 @@
-//! Math operations using unsigned integers
-
-#![deny(missing_docs)]
-#![forbid(unsafe_code)]
+//! Math utilities.
 
 pub mod approximations;
 pub mod checked_ceil_div;
-mod entrypoint;
-pub mod error;
-pub mod instruction;
 pub mod precise_number;
-pub mod processor;
 pub mod uint;
-
-solana_program::declare_id!("Math111111111111111111111111111111111111111");
diff --git a/libraries/math/src/precise_number.rs b/libraries/math/src/precise_number.rs
index 6e9c10651e5..23d66af0e71 100644
--- a/libraries/math/src/precise_number.rs
+++ b/libraries/math/src/precise_number.rs
@@ -346,7 +346,7 @@ impl PreciseNumber {
     /// Based on testing around the limits, this base is the smallest value that
     /// provides an epsilon of 11 digits
     fn maximum_sqrt_base() -> Self {
-        Self::new(std::u128::MAX).unwrap()
+        Self::new(u128::MAX).unwrap()
     }
 
     /// Approximate the square root using Newton's method.  Based on testing,
diff --git a/libraries/math/src/uint.rs b/libraries/math/src/uint.rs
index da7adc00d20..43f952fc3b8 100644
--- a/libraries/math/src/uint.rs
+++ b/libraries/math/src/uint.rs
@@ -5,6 +5,7 @@
 #![allow(clippy::assign_op_pattern)]
 #![allow(clippy::ptr_offset_with_cast)]
 #![allow(clippy::manual_range_contains)]
+#![allow(missing_docs)]
 
 use uint::construct_uint;
 
diff --git a/libraries/merkle-tree-reference/Cargo.toml b/libraries/merkle-tree-reference/Cargo.toml
index 080fe203f44..cf5a7fc0ce5 100644
--- a/libraries/merkle-tree-reference/Cargo.toml
+++ b/libraries/merkle-tree-reference/Cargo.toml
@@ -8,8 +8,8 @@ license = "Apache-2.0"
 edition = "2021"
 
 [dependencies]
-solana-program = "1.10.33"
-thiserror = "1.0.61"
+solana-program = ">=1.18.11,<=2"
+thiserror = "2.0.9"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/libraries/pod/Cargo.toml b/libraries/pod/Cargo.toml
deleted file mode 100644
index a0a5039e338..00000000000
--- a/libraries/pod/Cargo.toml
+++ /dev/null
@@ -1,30 +0,0 @@
-[package]
-name = "spl-pod"
-version = "0.2.2"
-description = "Solana Program Library Plain Old Data (Pod)"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-serde-traits = ["dep:serde", "dep:base64"]
-borsh = ["dep:borsh"]
-
-[dependencies]
-base64 = { version = "0.22.1", optional = true }
-borsh = { version = "1.5.1", optional = true }
-bytemuck = { version = "1.16.0" }
-serde = { version = "1.0.203", optional = true }
-solana-program = ">=1.18.11,<=2"
-solana-zk-token-sdk = ">=1.18.11,<=2"
-spl-program-error = { version = "0.4.0", path = "../program-error" }
-
-[dev-dependencies]
-serde_json = "1.0.117"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/pod/README.md b/libraries/pod/README.md
deleted file mode 100644
index 984718b5cbf..00000000000
--- a/libraries/pod/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Pod
-
-This library contains types shared by SPL libraries that implement the `Pod` trait from `bytemuck` and utils for working with these types.
diff --git a/libraries/pod/src/bytemuck.rs b/libraries/pod/src/bytemuck.rs
deleted file mode 100644
index f12cee5da6e..00000000000
--- a/libraries/pod/src/bytemuck.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! wrappers for bytemuck functions
-
-use {bytemuck::Pod, solana_program::program_error::ProgramError};
-
-/// On-chain size of a `Pod` type
-pub const fn pod_get_packed_len<T: Pod>() -> usize {
-    std::mem::size_of::<T>()
-}
-
-/// Convert a `Pod` into a slice of bytes (zero copy)
-pub fn pod_bytes_of<T: Pod>(t: &T) -> &[u8] {
-    bytemuck::bytes_of(t)
-}
-
-/// Convert a slice of bytes into a `Pod` (zero copy)
-pub fn pod_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&T, ProgramError> {
-    bytemuck::try_from_bytes(bytes).map_err(|_| ProgramError::InvalidArgument)
-}
-
-/// Maybe convert a slice of bytes into a `Pod` (zero copy)
-///
-/// Returns `None` if the slice is empty, or else `Err` if input length is not
-/// equal to `pod_get_packed_len::<T>()`.
-/// This function exists primarily because `Option<T>` is not a `Pod`.
-pub fn pod_maybe_from_bytes<T: Pod>(bytes: &[u8]) -> Result<Option<&T>, ProgramError> {
-    if bytes.is_empty() {
-        Ok(None)
-    } else {
-        bytemuck::try_from_bytes(bytes)
-            .map(Some)
-            .map_err(|_| ProgramError::InvalidArgument)
-    }
-}
-
-/// Convert a slice of bytes into a mutable `Pod` (zero copy)
-pub fn pod_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut T, ProgramError> {
-    bytemuck::try_from_bytes_mut(bytes).map_err(|_| ProgramError::InvalidArgument)
-}
-
-/// Convert a slice of bytes into a `Pod` slice (zero copy)
-pub fn pod_slice_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&[T], ProgramError> {
-    bytemuck::try_cast_slice(bytes).map_err(|_| ProgramError::InvalidArgument)
-}
-
-/// Convert a slice of bytes into a mutable `Pod` slice (zero copy)
-pub fn pod_slice_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut [T], ProgramError> {
-    bytemuck::try_cast_slice_mut(bytes).map_err(|_| ProgramError::InvalidArgument)
-}
-
-/// Convert a `Pod` slice into a single slice of bytes
-pub fn pod_slice_to_bytes<T: Pod>(slice: &[T]) -> &[u8] {
-    bytemuck::cast_slice(slice)
-}
diff --git a/libraries/pod/src/error.rs b/libraries/pod/src/error.rs
deleted file mode 100644
index 35740a43c2a..00000000000
--- a/libraries/pod/src/error.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Error types
-use spl_program_error::*;
-
-/// Errors that may be returned by the spl-pod library.
-#[spl_program_error]
-pub enum PodSliceError {
-    /// Error in checked math operation
-    #[error("Error in checked math operation")]
-    CalculationFailure,
-    /// Provided byte buffer too small for expected type
-    #[error("Provided byte buffer too small for expected type")]
-    BufferTooSmall,
-    /// Provided byte buffer too large for expected type
-    #[error("Provided byte buffer too large for expected type")]
-    BufferTooLarge,
-}
diff --git a/libraries/pod/src/lib.rs b/libraries/pod/src/lib.rs
deleted file mode 100644
index 00cb6be8597..00000000000
--- a/libraries/pod/src/lib.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Crate containing `Pod` types and `bytemuck` utils used in SPL
-
-pub mod bytemuck;
-pub mod error;
-pub mod optional_keys;
-pub mod primitives;
-pub mod slice;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
diff --git a/libraries/pod/src/optional_keys.rs b/libraries/pod/src/optional_keys.rs
deleted file mode 100644
index 6530fb251da..00000000000
--- a/libraries/pod/src/optional_keys.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-//! Optional pubkeys that can be used a `Pod`s
-#[cfg(feature = "borsh")]
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-#[cfg(feature = "serde-traits")]
-use {
-    base64::{prelude::BASE64_STANDARD, Engine},
-    serde::de::{Error, Unexpected, Visitor},
-    serde::{Deserialize, Deserializer, Serialize, Serializer},
-    std::{convert::TryFrom, fmt, str::FromStr},
-};
-use {
-    bytemuck::{Pod, Zeroable},
-    solana_program::{program_error::ProgramError, program_option::COption, pubkey::Pubkey},
-    solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-};
-
-/// A Pubkey that encodes `None` as all `0`, meant to be usable as a Pod type,
-/// similar to all NonZero* number types from the bytemuck library.
-#[cfg_attr(
-    feature = "borsh",
-    derive(BorshDeserialize, BorshSerialize, BorshSchema)
-)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct OptionalNonZeroPubkey(pub Pubkey);
-impl TryFrom<Option<Pubkey>> for OptionalNonZeroPubkey {
-    type Error = ProgramError;
-    fn try_from(p: Option<Pubkey>) -> Result<Self, Self::Error> {
-        match p {
-            None => Ok(Self(Pubkey::default())),
-            Some(pubkey) => {
-                if pubkey == Pubkey::default() {
-                    Err(ProgramError::InvalidArgument)
-                } else {
-                    Ok(Self(pubkey))
-                }
-            }
-        }
-    }
-}
-impl TryFrom<COption<Pubkey>> for OptionalNonZeroPubkey {
-    type Error = ProgramError;
-    fn try_from(p: COption<Pubkey>) -> Result<Self, Self::Error> {
-        match p {
-            COption::None => Ok(Self(Pubkey::default())),
-            COption::Some(pubkey) => {
-                if pubkey == Pubkey::default() {
-                    Err(ProgramError::InvalidArgument)
-                } else {
-                    Ok(Self(pubkey))
-                }
-            }
-        }
-    }
-}
-impl From<OptionalNonZeroPubkey> for Option<Pubkey> {
-    fn from(p: OptionalNonZeroPubkey) -> Self {
-        if p.0 == Pubkey::default() {
-            None
-        } else {
-            Some(p.0)
-        }
-    }
-}
-impl From<OptionalNonZeroPubkey> for COption<Pubkey> {
-    fn from(p: OptionalNonZeroPubkey) -> Self {
-        if p.0 == Pubkey::default() {
-            COption::None
-        } else {
-            COption::Some(p.0)
-        }
-    }
-}
-
-#[cfg(feature = "serde-traits")]
-impl Serialize for OptionalNonZeroPubkey {
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if self.0 == Pubkey::default() {
-            s.serialize_none()
-        } else {
-            s.serialize_some(&self.0.to_string())
-        }
-    }
-}
-
-#[cfg(feature = "serde-traits")]
-/// Visitor for deserializing OptionalNonZeroPubkey
-struct OptionalNonZeroPubkeyVisitor;
-
-#[cfg(feature = "serde-traits")]
-impl<'de> Visitor<'de> for OptionalNonZeroPubkeyVisitor {
-    type Value = OptionalNonZeroPubkey;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a Pubkey in base58 or `null`")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let pkey = Pubkey::from_str(&v)
-            .map_err(|_| Error::invalid_value(Unexpected::Str(v), &"value string"))?;
-
-        OptionalNonZeroPubkey::try_from(Some(pkey))
-            .map_err(|_| Error::custom("Failed to convert from pubkey"))
-    }
-
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        OptionalNonZeroPubkey::try_from(None).map_err(|e| Error::custom(e.to_string()))
-    }
-}
-
-#[cfg(feature = "serde-traits")]
-impl<'de> Deserialize<'de> for OptionalNonZeroPubkey {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_any(OptionalNonZeroPubkeyVisitor)
-    }
-}
-
-/// An ElGamalPubkey that encodes `None` as all `0`, meant to be usable as a Pod
-/// type.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct OptionalNonZeroElGamalPubkey(ElGamalPubkey);
-impl OptionalNonZeroElGamalPubkey {
-    /// Checks equality between an OptionalNonZeroElGamalPubkey and an
-    /// ElGamalPubkey when interpreted as bytes.
-    pub fn equals(&self, other: &ElGamalPubkey) -> bool {
-        &self.0 == other
-    }
-}
-impl TryFrom<Option<ElGamalPubkey>> for OptionalNonZeroElGamalPubkey {
-    type Error = ProgramError;
-    fn try_from(p: Option<ElGamalPubkey>) -> Result<Self, Self::Error> {
-        match p {
-            None => Ok(Self(ElGamalPubkey::default())),
-            Some(elgamal_pubkey) => {
-                if elgamal_pubkey == ElGamalPubkey::default() {
-                    Err(ProgramError::InvalidArgument)
-                } else {
-                    Ok(Self(elgamal_pubkey))
-                }
-            }
-        }
-    }
-}
-impl From<OptionalNonZeroElGamalPubkey> for Option<ElGamalPubkey> {
-    fn from(p: OptionalNonZeroElGamalPubkey) -> Self {
-        if p.0 == ElGamalPubkey::default() {
-            None
-        } else {
-            Some(p.0)
-        }
-    }
-}
-
-#[cfg(any(feature = "serde-traits", test))]
-const OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN: usize = 32;
-
-#[cfg(feature = "serde-traits")]
-impl Serialize for OptionalNonZeroElGamalPubkey {
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if self.0 == ElGamalPubkey::default() {
-            s.serialize_none()
-        } else {
-            s.serialize_some(&self.0.to_string())
-        }
-    }
-}
-
-#[cfg(feature = "serde-traits")]
-struct OptionalNonZeroElGamalPubkeyVisitor;
-
-#[cfg(feature = "serde-traits")]
-impl<'de> Visitor<'de> for OptionalNonZeroElGamalPubkeyVisitor {
-    type Value = OptionalNonZeroElGamalPubkey;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("an ElGamal public key as base64 or `null`")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let bytes = BASE64_STANDARD.decode(v).map_err(Error::custom)?;
-
-        if bytes.len() != OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN {
-            return Err(Error::custom(format!(
-                "Length of base64 decoded bytes is not {}",
-                OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN
-            )));
-        }
-
-        let mut array = [0; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN];
-        array.copy_from_slice(&bytes[0..OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]);
-        let elgamal_pubkey = ElGamalPubkey(array);
-        OptionalNonZeroElGamalPubkey::try_from(Some(elgamal_pubkey)).map_err(Error::custom)
-    }
-
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(OptionalNonZeroElGamalPubkey::default())
-    }
-}
-
-#[cfg(feature = "serde-traits")]
-impl<'de> Deserialize<'de> for OptionalNonZeroElGamalPubkey {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_any(OptionalNonZeroElGamalPubkeyVisitor)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::bytemuck::pod_from_bytes, solana_program::pubkey::PUBKEY_BYTES};
-
-    #[test]
-    fn test_pod_non_zero_option() {
-        assert_eq!(
-            Some(Pubkey::new_from_array([1; PUBKEY_BYTES])),
-            Option::<Pubkey>::from(
-                *pod_from_bytes::<OptionalNonZeroPubkey>(&[1; PUBKEY_BYTES]).unwrap()
-            )
-        );
-        assert_eq!(
-            None,
-            Option::<Pubkey>::from(
-                *pod_from_bytes::<OptionalNonZeroPubkey>(&[0; PUBKEY_BYTES]).unwrap()
-            )
-        );
-        assert_eq!(
-            pod_from_bytes::<OptionalNonZeroPubkey>(&[]).unwrap_err(),
-            ProgramError::InvalidArgument
-        );
-        assert_eq!(
-            pod_from_bytes::<OptionalNonZeroPubkey>(&[0; 1]).unwrap_err(),
-            ProgramError::InvalidArgument
-        );
-        assert_eq!(
-            pod_from_bytes::<OptionalNonZeroPubkey>(&[1; 1]).unwrap_err(),
-            ProgramError::InvalidArgument
-        );
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_non_zero_option_serde_some() {
-        let optional_non_zero_pubkey_some =
-            OptionalNonZeroPubkey(Pubkey::new_from_array([1; PUBKEY_BYTES]));
-        let serialized_some = serde_json::to_string(&optional_non_zero_pubkey_some).unwrap();
-        assert_eq!(
-            &serialized_some,
-            "\"4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi\""
-        );
-
-        let deserialized_some =
-            serde_json::from_str::<OptionalNonZeroPubkey>(&serialized_some).unwrap();
-        assert_eq!(optional_non_zero_pubkey_some, deserialized_some);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_non_zero_option_serde_none() {
-        let optional_non_zero_pubkey_none =
-            OptionalNonZeroPubkey(Pubkey::new_from_array([0; PUBKEY_BYTES]));
-        let serialized_none = serde_json::to_string(&optional_non_zero_pubkey_none).unwrap();
-        assert_eq!(&serialized_none, "null");
-
-        let deserialized_none =
-            serde_json::from_str::<OptionalNonZeroPubkey>(&serialized_none).unwrap();
-        assert_eq!(optional_non_zero_pubkey_none, deserialized_none);
-    }
-
-    #[test]
-    fn test_pod_non_zero_elgamal_option() {
-        assert_eq!(
-            Some(ElGamalPubkey([1; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN])),
-            Option::<ElGamalPubkey>::from(OptionalNonZeroElGamalPubkey(ElGamalPubkey(
-                [1; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]
-            )))
-        );
-        assert_eq!(
-            None,
-            Option::<ElGamalPubkey>::from(OptionalNonZeroElGamalPubkey(ElGamalPubkey(
-                [0; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]
-            )))
-        );
-
-        assert_eq!(
-            OptionalNonZeroElGamalPubkey(ElGamalPubkey([1; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN])),
-            *pod_from_bytes::<OptionalNonZeroElGamalPubkey>(
-                &[1; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]
-            )
-            .unwrap()
-        );
-        assert!(pod_from_bytes::<OptionalNonZeroElGamalPubkey>(&[]).is_err());
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_non_zero_elgamal_option_serde_some() {
-        let optional_non_zero_elgamal_pubkey_some =
-            OptionalNonZeroElGamalPubkey(ElGamalPubkey([1; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]));
-        let serialized_some =
-            serde_json::to_string(&optional_non_zero_elgamal_pubkey_some).unwrap();
-        assert_eq!(
-            &serialized_some,
-            "\"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=\""
-        );
-
-        let deserialized_some =
-            serde_json::from_str::<OptionalNonZeroElGamalPubkey>(&serialized_some).unwrap();
-        assert_eq!(optional_non_zero_elgamal_pubkey_some, deserialized_some);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_non_zero_elgamal_option_serde_none() {
-        let optional_non_zero_elgamal_pubkey_none =
-            OptionalNonZeroElGamalPubkey(ElGamalPubkey([0; OPTIONAL_NONZERO_ELGAMAL_PUBKEY_LEN]));
-        let serialized_none =
-            serde_json::to_string(&optional_non_zero_elgamal_pubkey_none).unwrap();
-        assert_eq!(&serialized_none, "null");
-
-        let deserialized_none =
-            serde_json::from_str::<OptionalNonZeroElGamalPubkey>(&serialized_none).unwrap();
-        assert_eq!(optional_non_zero_elgamal_pubkey_none, deserialized_none);
-    }
-}
diff --git a/libraries/pod/src/primitives.rs b/libraries/pod/src/primitives.rs
deleted file mode 100644
index bf3e455785f..00000000000
--- a/libraries/pod/src/primitives.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-//! primitive types that can be used in `Pod`s
-#[cfg(feature = "borsh")]
-use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use bytemuck::{Pod, Zeroable};
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-
-/// The standard `bool` is not a `Pod`, define a replacement that is
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "bool", into = "bool"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodBool(pub u8);
-impl PodBool {
-    pub const fn from_bool(b: bool) -> Self {
-        Self(if b { 1 } else { 0 })
-    }
-}
-
-impl From<bool> for PodBool {
-    fn from(b: bool) -> Self {
-        Self::from_bool(b)
-    }
-}
-
-impl From<&bool> for PodBool {
-    fn from(b: &bool) -> Self {
-        Self(if *b { 1 } else { 0 })
-    }
-}
-
-impl From<&PodBool> for bool {
-    fn from(b: &PodBool) -> Self {
-        b.0 != 0
-    }
-}
-
-impl From<PodBool> for bool {
-    fn from(b: PodBool) -> Self {
-        b.0 != 0
-    }
-}
-
-/// Simple macro for implementing conversion functions between Pod* ints and
-/// standard ints.
-///
-/// The standard int types can cause alignment issues when placed in a `Pod`,
-/// so these replacements are usable in all `Pod`s.
-#[macro_export]
-macro_rules! impl_int_conversion {
-    ($P:ty, $I:ty) => {
-        impl $P {
-            pub const fn from_primitive(n: $I) -> Self {
-                Self(n.to_le_bytes())
-            }
-        }
-        impl From<$I> for $P {
-            fn from(n: $I) -> Self {
-                Self::from_primitive(n)
-            }
-        }
-        impl From<$P> for $I {
-            fn from(pod: $P) -> Self {
-                Self::from_le_bytes(pod.0)
-            }
-        }
-    };
-}
-
-/// `u16` type that can be used in `Pod`s
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "u16", into = "u16"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodU16(pub [u8; 2]);
-impl_int_conversion!(PodU16, u16);
-
-/// `i16` type that can be used in Pods
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "i16", into = "i16"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodI16(pub [u8; 2]);
-impl_int_conversion!(PodI16, i16);
-
-/// `u32` type that can be used in `Pod`s
-#[cfg_attr(
-    feature = "borsh",
-    derive(BorshDeserialize, BorshSerialize, BorshSchema)
-)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "u32", into = "u32"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodU32(pub [u8; 4]);
-impl_int_conversion!(PodU32, u32);
-
-/// `u64` type that can be used in Pods
-#[cfg_attr(
-    feature = "borsh",
-    derive(BorshDeserialize, BorshSerialize, BorshSchema)
-)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "u64", into = "u64"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodU64(pub [u8; 8]);
-impl_int_conversion!(PodU64, u64);
-
-/// `i64` type that can be used in Pods
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(from = "i64", into = "i64"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct PodI64([u8; 8]);
-impl_int_conversion!(PodI64, i64);
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::bytemuck::pod_from_bytes};
-
-    #[test]
-    fn test_pod_bool() {
-        assert!(pod_from_bytes::<PodBool>(&[]).is_err());
-        assert!(pod_from_bytes::<PodBool>(&[0, 0]).is_err());
-
-        for i in 0..=u8::MAX {
-            assert_eq!(i != 0, bool::from(pod_from_bytes::<PodBool>(&[i]).unwrap()));
-        }
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_bool_serde() {
-        let pod_false: PodBool = false.into();
-        let pod_true: PodBool = true.into();
-
-        let serialized_false = serde_json::to_string(&pod_false).unwrap();
-        let serialized_true = serde_json::to_string(&pod_true).unwrap();
-        assert_eq!(&serialized_false, "false");
-        assert_eq!(&serialized_true, "true");
-
-        let deserialized_false = serde_json::from_str::<PodBool>(&serialized_false).unwrap();
-        let deserialized_true = serde_json::from_str::<PodBool>(&serialized_true).unwrap();
-        assert_eq!(pod_false, deserialized_false);
-        assert_eq!(pod_true, deserialized_true);
-    }
-
-    #[test]
-    fn test_pod_u16() {
-        assert!(pod_from_bytes::<PodU16>(&[]).is_err());
-        assert_eq!(1u16, u16::from(*pod_from_bytes::<PodU16>(&[1, 0]).unwrap()));
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_u16_serde() {
-        let pod_u16: PodU16 = u16::MAX.into();
-
-        let serialized = serde_json::to_string(&pod_u16).unwrap();
-        assert_eq!(&serialized, "65535");
-
-        let deserialized = serde_json::from_str::<PodU16>(&serialized).unwrap();
-        assert_eq!(pod_u16, deserialized);
-    }
-
-    #[test]
-    fn test_pod_i16() {
-        assert!(pod_from_bytes::<PodI16>(&[]).is_err());
-        assert_eq!(
-            -1i16,
-            i16::from(*pod_from_bytes::<PodI16>(&[255, 255]).unwrap())
-        );
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_i16_serde() {
-        let pod_i16: PodI16 = i16::MAX.into();
-
-        println!("pod_i16 {:?}", pod_i16);
-
-        let serialized = serde_json::to_string(&pod_i16).unwrap();
-        assert_eq!(&serialized, "32767");
-
-        let deserialized = serde_json::from_str::<PodI16>(&serialized).unwrap();
-        assert_eq!(pod_i16, deserialized);
-    }
-
-    #[test]
-    fn test_pod_u64() {
-        assert!(pod_from_bytes::<PodU64>(&[]).is_err());
-        assert_eq!(
-            1u64,
-            u64::from(*pod_from_bytes::<PodU64>(&[1, 0, 0, 0, 0, 0, 0, 0]).unwrap())
-        );
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_u64_serde() {
-        let pod_u64: PodU64 = u64::MAX.into();
-
-        let serialized = serde_json::to_string(&pod_u64).unwrap();
-        assert_eq!(&serialized, "18446744073709551615");
-
-        let deserialized = serde_json::from_str::<PodU64>(&serialized).unwrap();
-        assert_eq!(pod_u64, deserialized);
-    }
-
-    #[test]
-    fn test_pod_i64() {
-        assert!(pod_from_bytes::<PodI64>(&[]).is_err());
-        assert_eq!(
-            -1i64,
-            i64::from(
-                *pod_from_bytes::<PodI64>(&[255, 255, 255, 255, 255, 255, 255, 255]).unwrap()
-            )
-        );
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn test_pod_i64_serde() {
-        let pod_i64: PodI64 = i64::MAX.into();
-
-        let serialized = serde_json::to_string(&pod_i64).unwrap();
-        assert_eq!(&serialized, "9223372036854775807");
-
-        let deserialized = serde_json::from_str::<PodI64>(&serialized).unwrap();
-        assert_eq!(pod_i64, deserialized);
-    }
-}
diff --git a/libraries/pod/src/slice.rs b/libraries/pod/src/slice.rs
deleted file mode 100644
index ac912dc3005..00000000000
--- a/libraries/pod/src/slice.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-//! Special types for working with slices of `Pod`s
-
-use {
-    crate::{
-        bytemuck::{
-            pod_from_bytes, pod_from_bytes_mut, pod_slice_from_bytes, pod_slice_from_bytes_mut,
-        },
-        error::PodSliceError,
-        primitives::PodU32,
-    },
-    bytemuck::Pod,
-    solana_program::program_error::ProgramError,
-};
-
-const LENGTH_SIZE: usize = std::mem::size_of::<PodU32>();
-/// Special type for using a slice of `Pod`s in a zero-copy way
-pub struct PodSlice<'data, T: Pod> {
-    length: &'data PodU32,
-    data: &'data [T],
-}
-impl<'data, T: Pod> PodSlice<'data, T> {
-    /// Unpack the buffer into a slice
-    pub fn unpack<'a>(data: &'a [u8]) -> Result<Self, ProgramError>
-    where
-        'a: 'data,
-    {
-        if data.len() < LENGTH_SIZE {
-            return Err(PodSliceError::BufferTooSmall.into());
-        }
-        let (length, data) = data.split_at(LENGTH_SIZE);
-        let length = pod_from_bytes::<PodU32>(length)?;
-        let _max_length = max_len_for_type::<T>(data.len())?;
-        let data = pod_slice_from_bytes(data)?;
-        Ok(Self { length, data })
-    }
-
-    /// Get the slice data
-    pub fn data(&self) -> &[T] {
-        let length = u32::from(*self.length) as usize;
-        &self.data[..length]
-    }
-
-    /// Get the amount of bytes used by `num_items`
-    pub fn size_of(num_items: usize) -> Result<usize, ProgramError> {
-        std::mem::size_of::<T>()
-            .checked_mul(num_items)
-            .and_then(|len| len.checked_add(LENGTH_SIZE))
-            .ok_or_else(|| PodSliceError::CalculationFailure.into())
-    }
-}
-
-/// Special type for using a slice of mutable `Pod`s in a zero-copy way
-pub struct PodSliceMut<'data, T: Pod> {
-    length: &'data mut PodU32,
-    data: &'data mut [T],
-    max_length: usize,
-}
-impl<'data, T: Pod> PodSliceMut<'data, T> {
-    /// Unpack the mutable buffer into a mutable slice, with the option to
-    /// initialize the data
-    fn unpack_internal<'a>(data: &'a mut [u8], init: bool) -> Result<Self, ProgramError>
-    where
-        'a: 'data,
-    {
-        if data.len() < LENGTH_SIZE {
-            return Err(PodSliceError::BufferTooSmall.into());
-        }
-        let (length, data) = data.split_at_mut(LENGTH_SIZE);
-        let length = pod_from_bytes_mut::<PodU32>(length)?;
-        if init {
-            *length = 0.into();
-        }
-        let max_length = max_len_for_type::<T>(data.len())?;
-        let data = pod_slice_from_bytes_mut(data)?;
-        Ok(Self {
-            length,
-            data,
-            max_length,
-        })
-    }
-
-    /// Unpack the mutable buffer into a mutable slice
-    pub fn unpack<'a>(data: &'a mut [u8]) -> Result<Self, ProgramError>
-    where
-        'a: 'data,
-    {
-        Self::unpack_internal(data, /* init */ false)
-    }
-
-    /// Unpack the mutable buffer into a mutable slice, and initialize the
-    /// slice to 0-length
-    pub fn init<'a>(data: &'a mut [u8]) -> Result<Self, ProgramError>
-    where
-        'a: 'data,
-    {
-        Self::unpack_internal(data, /* init */ true)
-    }
-
-    /// Add another item to the slice
-    pub fn push(&mut self, t: T) -> Result<(), ProgramError> {
-        let length = u32::from(*self.length);
-        if length as usize == self.max_length {
-            Err(PodSliceError::BufferTooSmall.into())
-        } else {
-            self.data[length as usize] = t;
-            *self.length = length.saturating_add(1).into();
-            Ok(())
-        }
-    }
-}
-
-fn max_len_for_type<T>(data_len: usize) -> Result<usize, ProgramError> {
-    let size: usize = std::mem::size_of::<T>();
-    let max_len = data_len
-        .checked_div(size)
-        .ok_or(PodSliceError::CalculationFailure)?;
-    // check that it isn't over or under allocated
-    if max_len.saturating_mul(size) != data_len {
-        if max_len == 0 {
-            // Size of T is greater than buffer size
-            Err(PodSliceError::BufferTooSmall.into())
-        } else {
-            Err(PodSliceError::BufferTooLarge.into())
-        }
-    } else {
-        Ok(max_len)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::bytemuck::pod_slice_to_bytes, bytemuck::Zeroable};
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-    struct TestStruct {
-        test_field: u8,
-        test_pubkey: [u8; 32],
-    }
-
-    #[test]
-    fn test_pod_slice() {
-        let test_field_bytes = [0];
-        let test_pubkey_bytes = [1; 32];
-        let len_bytes = [2, 0, 0, 0];
-
-        // Slice will contain 2 `TestStruct`
-        let mut data_bytes = [0; 66];
-        data_bytes[0..1].copy_from_slice(&test_field_bytes);
-        data_bytes[1..33].copy_from_slice(&test_pubkey_bytes);
-        data_bytes[33..34].copy_from_slice(&test_field_bytes);
-        data_bytes[34..66].copy_from_slice(&test_pubkey_bytes);
-
-        let mut pod_slice_bytes = [0; 70];
-        pod_slice_bytes[0..4].copy_from_slice(&len_bytes);
-        pod_slice_bytes[4..70].copy_from_slice(&data_bytes);
-
-        let pod_slice = PodSlice::<TestStruct>::unpack(&pod_slice_bytes).unwrap();
-        let pod_slice_data = pod_slice.data();
-
-        assert_eq!(*pod_slice.length, PodU32::from(2));
-        assert_eq!(pod_slice_to_bytes(pod_slice.data()), data_bytes);
-        assert_eq!(pod_slice_data[0].test_field, test_field_bytes[0]);
-        assert_eq!(pod_slice_data[0].test_pubkey, test_pubkey_bytes);
-        assert_eq!(PodSlice::<TestStruct>::size_of(1).unwrap(), 37);
-    }
-
-    #[test]
-    fn test_pod_slice_buffer_too_large() {
-        // 1 `TestStruct` + length = 37 bytes
-        // we pass 38 to trigger BufferTooLarge
-        let pod_slice_bytes = [1; 38];
-        let err = PodSlice::<TestStruct>::unpack(&pod_slice_bytes)
-            .err()
-            .unwrap();
-        assert_eq!(
-            err,
-            PodSliceError::BufferTooLarge.into(),
-            "Expected an `PodSliceError::BufferTooLarge` error"
-        );
-    }
-
-    #[test]
-    fn test_pod_slice_buffer_too_small() {
-        // 1 `TestStruct` + length = 37 bytes
-        // we pass 36 to trigger BufferTooSmall
-        let pod_slice_bytes = [1; 36];
-        let err = PodSlice::<TestStruct>::unpack(&pod_slice_bytes)
-            .err()
-            .unwrap();
-        assert_eq!(
-            err,
-            PodSliceError::BufferTooSmall.into(),
-            "Expected an `PodSliceError::BufferTooSmall` error"
-        );
-    }
-
-    #[test]
-    fn test_pod_slice_mut() {
-        // slice can fit 2 `TestStruct`
-        let mut pod_slice_bytes = [0; 70];
-        // set length to 1, so we have room to push 1 more item
-        let len_bytes = [1, 0, 0, 0];
-        pod_slice_bytes[0..4].copy_from_slice(&len_bytes);
-
-        let mut pod_slice = PodSliceMut::<TestStruct>::unpack(&mut pod_slice_bytes).unwrap();
-
-        assert_eq!(*pod_slice.length, PodU32::from(1));
-        pod_slice.push(TestStruct::default()).unwrap();
-        assert_eq!(*pod_slice.length, PodU32::from(2));
-        let err = pod_slice
-            .push(TestStruct::default())
-            .expect_err("Expected an `PodSliceError::BufferTooSmall` error");
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
-    }
-}
diff --git a/libraries/program-error/Cargo.toml b/libraries/program-error/Cargo.toml
deleted file mode 100644
index e459db4d04f..00000000000
--- a/libraries/program-error/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "spl-program-error"
-version = "0.4.1"
-description = "Library for Solana Program error attributes and derive macro for creating them"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-num-derive = "0.4"
-num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-spl-program-error-derive = { version = "0.4.1", path = "./derive" }
-thiserror = "1.0"
-
-[dev-dependencies]
-lazy_static = "1.4"
-serial_test = "3.1"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/program-error/README.md b/libraries/program-error/README.md
deleted file mode 100644
index 5ada5934460..00000000000
--- a/libraries/program-error/README.md
+++ /dev/null
@@ -1,293 +0,0 @@
-# SPL Program Error
-
-Macros for implementing error-based traits on enums.
-
-- `#[derive(IntoProgramError)]`: automatically derives the trait `From<Self> for solana_program::program_error::ProgramError`.
-- `#[derive(DecodeError)]`: automatically derives the trait `solana_program::decode_error::DecodeError<T>`.
-- `#[derive(PrintProgramError)]`: automatically derives the trait `solana_program::program_error::PrintProgramError`.
-- `#[spl_program_error]`: Automatically derives all below traits:
-  - `Clone`
-  - `Debug`
-  - `Eq`
-  - `DecodeError`
-  - `IntoProgramError`
-  - `PrintProgramError`
-  - `thiserror::Error`
-  - `num_derive::FromPrimitive`
-  - `PartialEq`
-
-### `#[derive(IntoProgramError)]`
-
-This derive macro automatically derives the trait `From<Self> for solana_program::program_error::ProgramError`.
-
-Your enum must implement the following traits in order for this macro to work:
-
-- `Clone`
-- `Debug`
-- `Eq`
-- `thiserror::Error`
-- `num_derive::FromPrimitive`
-- `PartialEq`
-
-Sample code:
-
-```rust
-/// Example error
-#[derive(
-    Clone, Debug, Eq, IntoProgramError, thiserror::Error, num_derive::FromPrimitive, PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-```
-
-### `#[derive(DecodeError)]`
-
-This derive macro automatically derives the trait `solana_program::decode_error::DecodeError<T>`.
-
-Your enum must implement the following traits in order for this macro to work:
-
-- `Clone`
-- `Debug`
-- `Eq`
-- `IntoProgramError` (above)
-- `thiserror::Error`
-- `num_derive::FromPrimitive`
-- `PartialEq`
-
-Sample code:
-
-```rust
-/// Example error
-#[derive(
-    Clone,
-    Debug,
-    DecodeError,
-    Eq,
-    IntoProgramError,
-    thiserror::Error,
-    num_derive::FromPrimitive,
-    PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-```
-
-### `#[derive(PrintProgramError)]`
-
-This derive macro automatically derives the trait `solana_program::program_error::PrintProgramError`.
-
-Your enum must implement the following traits in order for this macro to work:
-
-- `Clone`
-- `Debug`
-- `DecodeError<T>` (above)
-- `Eq`
-- `IntoProgramError` (above)
-- `thiserror::Error`
-- `num_derive::FromPrimitive`
-- `PartialEq`
-
-Sample code:
-
-```rust
-/// Example error
-#[derive(
-    Clone,
-    Debug,
-    DecodeError,
-    Eq,
-    IntoProgramError,
-    thiserror::Error,
-    num_derive::FromPrimitive,
-    PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-```
-
-### `#[spl_program_error]`
-
-It can be cumbersome to ensure your program's defined errors - typically represented
-in an enum - implement the required traits and will print to the program's logs when they're
-invoked.
-
-This procedural macro will give you all of the required implementations out of the box:
-
-- `Clone`
-- `Debug`
-- `Eq`
-- `thiserror::Error`
-- `num_derive::FromPrimitive`
-- `PartialEq`
-
-It also imports the required crates so you don't have to in your program:
-
-- `num_derive`
-- `num_traits`
-- `thiserror`
-
----
-
-Just annotate your enum...
-
-```rust
-use solana_program_error_derive::*;
-
-/// Example error
-#[solana_program_error]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-```
-
-...and get:
-
-```rust
-/// Example error
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-#[automatically_derived]
-impl ::core::clone::Clone for ExampleError {
-    #[inline]
-    fn clone(&self) -> ExampleError {
-        match self {
-            ExampleError::MintHasNoMintAuthority => ExampleError::MintHasNoMintAuthority,
-            ExampleError::IncorrectMintAuthority => ExampleError::IncorrectMintAuthority,
-        }
-    }
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for ExampleError {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        ::core::fmt::Formatter::write_str(
-            f,
-            match self {
-                ExampleError::MintHasNoMintAuthority => "MintHasNoMintAuthority",
-                ExampleError::IncorrectMintAuthority => "IncorrectMintAuthority",
-            },
-        )
-    }
-}
-#[automatically_derived]
-impl ::core::marker::StructuralEq for ExampleError {}
-#[automatically_derived]
-impl ::core::cmp::Eq for ExampleError {
-    #[inline]
-    #[doc(hidden)]
-    #[no_coverage]
-    fn assert_receiver_is_total_eq(&self) -> () {}
-}
-#[allow(unused_qualifications)]
-impl std::error::Error for ExampleError {}
-#[allow(unused_qualifications)]
-impl std::fmt::Display for ExampleError {
-    fn fmt(&self, __formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        #[allow(unused_variables, deprecated, clippy::used_underscore_binding)]
-        match self {
-            ExampleError::MintHasNoMintAuthority {} => {
-                __formatter.write_fmt(format_args!("Mint has no mint authority"))
-            }
-            ExampleError::IncorrectMintAuthority {} => {
-                __formatter
-                    .write_fmt(
-                        format_args!(
-                            "Incorrect mint authority has signed the instruction"
-                        ),
-                    )
-            }
-        }
-    }
-}
-#[allow(non_upper_case_globals, unused_qualifications)]
-const _IMPL_NUM_FromPrimitive_FOR_ExampleError: () = {
-    #[allow(clippy::useless_attribute)]
-    #[allow(rust_2018_idioms)]
-    extern crate num_traits as _num_traits;
-    impl _num_traits::FromPrimitive for ExampleError {
-        #[allow(trivial_numeric_casts)]
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            if n == ExampleError::MintHasNoMintAuthority as i64 {
-                Some(ExampleError::MintHasNoMintAuthority)
-            } else if n == ExampleError::IncorrectMintAuthority as i64 {
-                Some(ExampleError::IncorrectMintAuthority)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Self::from_i64(n as i64)
-        }
-    }
-};
-#[automatically_derived]
-impl ::core::marker::StructuralPartialEq for ExampleError {}
-#[automatically_derived]
-impl ::core::cmp::PartialEq for ExampleError {
-    #[inline]
-    fn eq(&self, other: &ExampleError) -> bool {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
-        __self_tag == __arg1_tag
-    }
-}
-impl From<ExampleError> for solana_program::program_error::ProgramError {
-    fn from(e: ExampleError) -> Self {
-        solana_program::program_error::ProgramError::Custom(e as u32)
-    }
-}
-impl<T> solana_program::decode_error::DecodeError<T> for ExampleError {
-    fn type_of() -> &'static str {
-        "ExampleError"
-    }
-}
-impl solana_program::program_error::PrintProgramError for ExampleError {
-    fn print<E>(&self)
-    where
-        E: 'static + std::error::Error + solana_program::decode_error::DecodeError<E>
-            + solana_program::program_error::PrintProgramError
-            + num_traits::FromPrimitive,
-    {
-        match self {
-            ExampleError::MintHasNoMintAuthority => {
-                ::solana_program::log::sol_log("Mint has no mint authority")
-            }
-            ExampleError::IncorrectMintAuthority => {
-                ::solana_program::log::sol_log(
-                    "Incorrect mint authority has signed the instruction",
-                )
-            }
-        }
-    }
-}
-```
diff --git a/libraries/program-error/derive/Cargo.toml b/libraries/program-error/derive/Cargo.toml
deleted file mode 100644
index 74aec23ba4a..00000000000
--- a/libraries/program-error/derive/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "spl-program-error-derive"
-version = "0.4.1"
-description = "Proc-Macro Library for Solana Program error attributes and derive macro"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-sha2 = "0.10"
-syn = { version = "2.0", features = ["full"] }
diff --git a/libraries/program-error/derive/src/lib.rs b/libraries/program-error/derive/src/lib.rs
deleted file mode 100644
index 2681e85be4e..00000000000
--- a/libraries/program-error/derive/src/lib.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-//! Crate defining a procedural macro for building Solana program errors
-
-// Required to include `#[allow(clippy::integer_arithmetic)]`
-// below since the tokens generated by `quote!` in the implementation
-// for `MacroType::PrintProgramError` and `MacroType::SplProgramError`
-// trigger the lint upstream through `quote_token_with_context` within the
-// `quote` crate
-//
-// Culprit is `macro_impl.rs:66`
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-extern crate proc_macro;
-
-mod macro_impl;
-mod parser;
-
-use {
-    crate::parser::SplProgramErrorArgs,
-    macro_impl::MacroType,
-    proc_macro::TokenStream,
-    syn::{parse_macro_input, ItemEnum},
-};
-
-/// Derive macro to add `Into<solana_program::program_error::ProgramError>`
-/// trait
-#[proc_macro_derive(IntoProgramError)]
-pub fn into_program_error(input: TokenStream) -> TokenStream {
-    let ItemEnum { ident, .. } = parse_macro_input!(input as ItemEnum);
-    MacroType::IntoProgramError { ident }
-        .generate_tokens()
-        .into()
-}
-
-/// Derive macro to add `solana_program::decode_error::DecodeError` trait
-#[proc_macro_derive(DecodeError)]
-pub fn decode_error(input: TokenStream) -> TokenStream {
-    let ItemEnum { ident, .. } = parse_macro_input!(input as ItemEnum);
-    MacroType::DecodeError { ident }.generate_tokens().into()
-}
-
-/// Derive macro to add `solana_program::program_error::PrintProgramError` trait
-#[proc_macro_derive(PrintProgramError)]
-pub fn print_program_error(input: TokenStream) -> TokenStream {
-    let ItemEnum {
-        ident, variants, ..
-    } = parse_macro_input!(input as ItemEnum);
-    MacroType::PrintProgramError { ident, variants }
-        .generate_tokens()
-        .into()
-}
-
-/// Proc macro attribute to turn your enum into a Solana Program Error
-///
-/// Adds:
-/// - `Clone`
-/// - `Debug`
-/// - `Eq`
-/// - `PartialEq`
-/// - `thiserror::Error`
-/// - `num_derive::FromPrimitive`
-/// - `Into<solana_program::program_error::ProgramError>`
-/// - `solana_program::decode_error::DecodeError`
-/// - `solana_program::program_error::PrintProgramError`
-///
-/// Optionally, you can add `hash_error_code_start: u32` argument to create
-/// a unique `u32` _starting_ error codes from the names of the enum variants.
-/// Notes:
-/// - The _error_ variant will start at this value, and the rest will be
-/// incremented by one
-/// - The value provided is only for code readability, the actual error code
-/// will be a hash of the input string and is checked against your input
-///
-/// Syntax: `#[spl_program_error(hash_error_code_start = 1275525928)]`
-/// Hash Input: `spl_program_error:<enum name>:<variant name>`
-/// Value: `u32::from_le_bytes(<hash of input>[13..17])`
-#[proc_macro_attribute]
-pub fn spl_program_error(attr: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(attr as SplProgramErrorArgs);
-    let item_enum = parse_macro_input!(input as ItemEnum);
-    MacroType::SplProgramError { args, item_enum }
-        .generate_tokens()
-        .into()
-}
diff --git a/libraries/program-error/derive/src/macro_impl.rs b/libraries/program-error/derive/src/macro_impl.rs
deleted file mode 100644
index 21e89ee3441..00000000000
--- a/libraries/program-error/derive/src/macro_impl.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-//! The actual token generator for the macro
-
-use {
-    crate::parser::SplProgramErrorArgs,
-    proc_macro2::Span,
-    quote::quote,
-    sha2::{Digest, Sha256},
-    syn::{
-        punctuated::Punctuated, token::Comma, Expr, ExprLit, Ident, ItemEnum, Lit, LitInt, LitStr,
-        Token, Variant,
-    },
-};
-
-const SPL_ERROR_HASH_NAMESPACE: &str = "spl_program_error";
-const SPL_ERROR_HASH_MIN_VALUE: u32 = 7_000;
-
-/// The type of macro being called, thus directing which tokens to generate
-#[allow(clippy::enum_variant_names)]
-pub enum MacroType {
-    IntoProgramError {
-        ident: Ident,
-    },
-    DecodeError {
-        ident: Ident,
-    },
-    PrintProgramError {
-        ident: Ident,
-        variants: Punctuated<Variant, Comma>,
-    },
-    SplProgramError {
-        args: SplProgramErrorArgs,
-        item_enum: ItemEnum,
-    },
-}
-
-impl MacroType {
-    /// Generates the corresponding tokens based on variant selection
-    pub fn generate_tokens(&mut self) -> proc_macro2::TokenStream {
-        match self {
-            Self::IntoProgramError { ident } => into_program_error(ident),
-            Self::DecodeError { ident } => decode_error(ident),
-            Self::PrintProgramError { ident, variants } => print_program_error(ident, variants),
-            Self::SplProgramError { args, item_enum } => spl_program_error(args, item_enum),
-        }
-    }
-}
-
-/// Builds the implementation of
-/// `Into<solana_program::program_error::ProgramError>` More specifically,
-/// implements `From<Self> for solana_program::program_error::ProgramError`
-pub fn into_program_error(ident: &Ident) -> proc_macro2::TokenStream {
-    quote! {
-        impl From<#ident> for ::solana_program::program_error::ProgramError {
-            fn from(e: #ident) -> Self {
-                ::solana_program::program_error::ProgramError::Custom(e as u32)
-            }
-        }
-    }
-}
-
-/// Builds the implementation of `solana_program::decode_error::DecodeError<T>`
-pub fn decode_error(ident: &Ident) -> proc_macro2::TokenStream {
-    quote! {
-        impl<T> ::solana_program::decode_error::DecodeError<T> for #ident {
-            fn type_of() -> &'static str {
-                stringify!(#ident)
-            }
-        }
-    }
-}
-
-/// Builds the implementation of
-/// `solana_program::program_error::PrintProgramError`
-pub fn print_program_error(
-    ident: &Ident,
-    variants: &Punctuated<Variant, Comma>,
-) -> proc_macro2::TokenStream {
-    let ppe_match_arms = variants.iter().map(|variant| {
-        let variant_ident = &variant.ident;
-        let error_msg = get_error_message(variant)
-            .unwrap_or_else(|| String::from("Unknown custom program error"));
-        quote! {
-            #ident::#variant_ident => {
-                ::solana_program::msg!(#error_msg)
-            }
-        }
-    });
-    quote! {
-        impl ::solana_program::program_error::PrintProgramError for #ident {
-            fn print<E>(&self)
-            where
-                E: 'static
-                    + std::error::Error
-                    + ::solana_program::decode_error::DecodeError<E>
-                    + ::solana_program::program_error::PrintProgramError
-                    + num_traits::FromPrimitive,
-            {
-                match self {
-                    #(#ppe_match_arms),*
-                }
-            }
-        }
-    }
-}
-
-/// Helper to parse out the string literal from the `#[error(..)]` attribute
-fn get_error_message(variant: &Variant) -> Option<String> {
-    let attrs = &variant.attrs;
-    for attr in attrs {
-        if attr.path().is_ident("error") {
-            if let Ok(lit_str) = attr.parse_args::<LitStr>() {
-                return Some(lit_str.value());
-            }
-        }
-    }
-    None
-}
-
-/// The main function that produces the tokens required to turn your
-/// error enum into a Solana Program Error
-pub fn spl_program_error(
-    args: &SplProgramErrorArgs,
-    item_enum: &mut ItemEnum,
-) -> proc_macro2::TokenStream {
-    if let Some(error_code_start) = args.hash_error_code_start {
-        set_first_discriminant(item_enum, error_code_start);
-    }
-
-    let ident = &item_enum.ident;
-    let variants = &item_enum.variants;
-    let into_program_error = into_program_error(ident);
-    let decode_error = decode_error(ident);
-    let print_program_error = print_program_error(ident, variants);
-
-    quote! {
-        #[repr(u32)]
-        #[derive(Clone, Debug, Eq, thiserror::Error, num_derive::FromPrimitive, PartialEq)]
-        #[num_traits = "num_traits"]
-        #item_enum
-
-        #into_program_error
-
-        #decode_error
-
-        #print_program_error
-    }
-}
-
-/// This function adds a discriminant to the first enum variant based on the
-/// hash of the `SPL_ERROR_HASH_NAMESPACE` constant, the enum name and variant
-/// name.
-/// It will then check to make sure the provided `hash_error_code_start` is
-/// equal to the hash-produced `u32`.
-///
-/// See https://docs.rs/syn/latest/syn/struct.Variant.html
-fn set_first_discriminant(item_enum: &mut ItemEnum, error_code_start: u32) {
-    let enum_ident = &item_enum.ident;
-    if item_enum.variants.is_empty() {
-        panic!("Enum must have at least one variant");
-    }
-    let first_variant = &mut item_enum.variants[0];
-    let discriminant = u32_from_hash(enum_ident);
-    if discriminant == error_code_start {
-        let eq = Token![=](Span::call_site());
-        let expr = Expr::Lit(ExprLit {
-            attrs: Vec::new(),
-            lit: Lit::Int(LitInt::new(&discriminant.to_string(), Span::call_site())),
-        });
-        first_variant.discriminant = Some((eq, expr));
-    } else {
-        panic!(
-            "Error code start value from hash must be {0}. Update your macro attribute to \
-             `#[spl_program_error(hash_error_code_start = {0})]`.",
-            discriminant
-        );
-    }
-}
-
-/// Hashes the `SPL_ERROR_HASH_NAMESPACE` constant, the enum name and variant
-/// name and returns four middle bytes (13 through 16) as a u32.
-fn u32_from_hash(enum_ident: &Ident) -> u32 {
-    let hash_input = format!("{}:{}", SPL_ERROR_HASH_NAMESPACE, enum_ident);
-
-    // We don't want our error code to start at any number below
-    // `SPL_ERROR_HASH_MIN_VALUE`!
-    let mut nonce: u32 = 0;
-    loop {
-        let mut hasher = Sha256::new_with_prefix(hash_input.as_bytes());
-        hasher.update(nonce.to_le_bytes());
-        let d = u32::from_le_bytes(
-            hasher.finalize()[13..17]
-                .try_into()
-                .expect("Unable to convert hash to u32"),
-        );
-        if d >= SPL_ERROR_HASH_MIN_VALUE {
-            return d;
-        }
-        nonce += 1;
-    }
-}
diff --git a/libraries/program-error/derive/src/parser.rs b/libraries/program-error/derive/src/parser.rs
deleted file mode 100644
index a09ffc7ba7c..00000000000
--- a/libraries/program-error/derive/src/parser.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-//! Token parsing
-
-use {
-    proc_macro2::Ident,
-    syn::{
-        parse::{Parse, ParseStream},
-        token::Comma,
-        LitInt, Token,
-    },
-};
-
-/// Possible arguments to the `#[spl_program_error]` attribute
-pub struct SplProgramErrorArgs {
-    /// Whether to hash the error codes using `solana_program::hash`
-    /// or to use the default error code assigned by `num_traits`.
-    pub hash_error_code_start: Option<u32>,
-}
-
-impl Parse for SplProgramErrorArgs {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        if input.is_empty() {
-            return Ok(Self {
-                hash_error_code_start: None,
-            });
-        }
-        match SplProgramErrorArgParser::parse(input)? {
-            SplProgramErrorArgParser::HashErrorCodes { value, .. } => Ok(Self {
-                hash_error_code_start: Some(value.base10_parse::<u32>()?),
-            }),
-        }
-    }
-}
-
-/// Parser for args to the `#[spl_program_error]` attribute
-/// ie. `#[spl_program_error(hash_error_code_start = 1275525928)]`
-enum SplProgramErrorArgParser {
-    HashErrorCodes {
-        _ident: Ident,
-        _equals_sign: Token![=],
-        value: LitInt,
-        _comma: Option<Comma>,
-    },
-}
-
-impl Parse for SplProgramErrorArgParser {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        let _ident = {
-            let ident = input.parse::<Ident>()?;
-            if ident != "hash_error_code_start" {
-                return Err(input.error("Expected argument 'hash_error_code_start'"));
-            }
-            ident
-        };
-        let _equals_sign = input.parse::<Token![=]>()?;
-        let value = input.parse::<LitInt>()?;
-        let _comma: Option<Comma> = input.parse().unwrap_or(None);
-        Ok(Self::HashErrorCodes {
-            _ident,
-            _equals_sign,
-            value,
-            _comma,
-        })
-    }
-}
diff --git a/libraries/program-error/src/lib.rs b/libraries/program-error/src/lib.rs
deleted file mode 100644
index 739995dd197..00000000000
--- a/libraries/program-error/src/lib.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! Crate defining a library with a procedural macro and other
-//! dependencies for building Solana program errors
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-extern crate self as spl_program_error;
-
-// Make these available downstream for the macro to work without
-// additional imports
-pub use {
-    num_derive, num_traits, solana_program,
-    spl_program_error_derive::{
-        spl_program_error, DecodeError, IntoProgramError, PrintProgramError,
-    },
-    thiserror,
-};
diff --git a/libraries/program-error/tests/bench.rs b/libraries/program-error/tests/bench.rs
deleted file mode 100644
index 40f01bb7e90..00000000000
--- a/libraries/program-error/tests/bench.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//! Bench case with manual implementations
-use spl_program_error::*;
-
-/// Example error
-#[derive(Clone, Debug, Eq, thiserror::Error, num_derive::FromPrimitive, PartialEq)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-
-impl From<ExampleError> for solana_program::program_error::ProgramError {
-    fn from(e: ExampleError) -> Self {
-        solana_program::program_error::ProgramError::Custom(e as u32)
-    }
-}
-impl<T> solana_program::decode_error::DecodeError<T> for ExampleError {
-    fn type_of() -> &'static str {
-        "ExampleError"
-    }
-}
-
-impl solana_program::program_error::PrintProgramError for ExampleError {
-    fn print<E>(&self)
-    where
-        E: 'static
-            + std::error::Error
-            + solana_program::decode_error::DecodeError<E>
-            + solana_program::program_error::PrintProgramError
-            + num_traits::FromPrimitive,
-    {
-        match self {
-            ExampleError::MintHasNoMintAuthority => {
-                solana_program::msg!("Mint has no mint authority")
-            }
-            ExampleError::IncorrectMintAuthority => {
-                solana_program::msg!("Incorrect mint authority has signed the instruction")
-            }
-        }
-    }
-}
-
-/// Tests that all macros compile
-#[test]
-fn test_macros_compile() {
-    let _ = ExampleError::MintHasNoMintAuthority;
-}
diff --git a/libraries/program-error/tests/decode.rs b/libraries/program-error/tests/decode.rs
deleted file mode 100644
index 0c7c209bc14..00000000000
--- a/libraries/program-error/tests/decode.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! Tests `#[derive(DecodeError)]`
-
-use spl_program_error::*;
-
-/// Example error
-#[derive(
-    Clone,
-    Debug,
-    DecodeError,
-    Eq,
-    IntoProgramError,
-    thiserror::Error,
-    num_derive::FromPrimitive,
-    PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-
-/// Tests that all macros compile
-#[test]
-fn test_macros_compile() {
-    let _ = ExampleError::MintHasNoMintAuthority;
-}
diff --git a/libraries/program-error/tests/into.rs b/libraries/program-error/tests/into.rs
deleted file mode 100644
index 0f32b8f40d3..00000000000
--- a/libraries/program-error/tests/into.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Tests `#[derive(IntoProgramError)]`
-
-use spl_program_error::*;
-
-/// Example error
-#[derive(
-    Clone, Debug, Eq, IntoProgramError, thiserror::Error, num_derive::FromPrimitive, PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-
-/// Tests that all macros compile
-#[test]
-fn test_macros_compile() {
-    let _ = ExampleError::MintHasNoMintAuthority;
-}
diff --git a/libraries/program-error/tests/mod.rs b/libraries/program-error/tests/mod.rs
deleted file mode 100644
index 413587758e9..00000000000
--- a/libraries/program-error/tests/mod.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-pub mod bench;
-pub mod decode;
-pub mod into;
-pub mod print;
-pub mod spl;
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        serial_test::serial,
-        solana_program::{
-            decode_error::DecodeError,
-            program_error::{PrintProgramError, ProgramError},
-        },
-        std::sync::{Arc, RwLock},
-    };
-
-    // Used to capture output for `PrintProgramError` for testing
-    lazy_static::lazy_static! {
-        static ref EXPECTED_DATA: Arc<RwLock<Vec<u8>>> = Arc::new(RwLock::new(Vec::new()));
-    }
-    fn set_expected_data(expected_data: Vec<u8>) {
-        *EXPECTED_DATA.write().unwrap() = expected_data;
-    }
-    pub struct SyscallStubs {}
-    impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
-        fn sol_log(&self, message: &str) {
-            assert_eq!(
-                message,
-                String::from_utf8_lossy(&EXPECTED_DATA.read().unwrap())
-            );
-        }
-    }
-
-    // `#[derive(IntoProgramError)]`
-    #[test]
-    fn test_derive_into_program_error() {
-        // `Into<ProgramError>`
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::MintHasNoMintAuthority),
-            Into::<ProgramError>::into(into::ExampleError::MintHasNoMintAuthority),
-        );
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::IncorrectMintAuthority),
-            Into::<ProgramError>::into(into::ExampleError::IncorrectMintAuthority),
-        );
-    }
-
-    // `#[derive(DecodeError)]`
-    #[test]
-    fn test_derive_decode_error() {
-        // `Into<ProgramError>`
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::MintHasNoMintAuthority),
-            Into::<ProgramError>::into(decode::ExampleError::MintHasNoMintAuthority),
-        );
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::IncorrectMintAuthority),
-            Into::<ProgramError>::into(decode::ExampleError::IncorrectMintAuthority),
-        );
-        // `DecodeError<T>`
-        assert_eq!(
-            <bench::ExampleError as DecodeError<bench::ExampleError>>::type_of(),
-            <bench::ExampleError as DecodeError<decode::ExampleError>>::type_of(),
-        );
-    }
-    // `#[derive(PrintProgramError)]`
-    #[test]
-    #[serial]
-    fn test_derive_print_program_error() {
-        use std::sync::Once;
-        static ONCE: Once = Once::new();
-
-        ONCE.call_once(|| {
-            solana_sdk::program_stubs::set_syscall_stubs(Box::new(SyscallStubs {}));
-        });
-        // `Into<ProgramError>`
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::MintHasNoMintAuthority),
-            Into::<ProgramError>::into(print::ExampleError::MintHasNoMintAuthority),
-        );
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::IncorrectMintAuthority),
-            Into::<ProgramError>::into(print::ExampleError::IncorrectMintAuthority),
-        );
-        // `DecodeError<T>`
-        assert_eq!(
-            <bench::ExampleError as DecodeError<bench::ExampleError>>::type_of(),
-            <bench::ExampleError as DecodeError<print::ExampleError>>::type_of(),
-        );
-        // `PrintProgramError`
-        set_expected_data("Mint has no mint authority".as_bytes().to_vec());
-        PrintProgramError::print::<print::ExampleError>(
-            &print::ExampleError::MintHasNoMintAuthority,
-        );
-        set_expected_data(
-            "Incorrect mint authority has signed the instruction"
-                .as_bytes()
-                .to_vec(),
-        );
-        PrintProgramError::print::<print::ExampleError>(
-            &print::ExampleError::IncorrectMintAuthority,
-        );
-    }
-
-    // `#[spl_program_error]`
-    #[test]
-    #[serial]
-    fn test_spl_program_error() {
-        use std::sync::Once;
-        static ONCE: Once = Once::new();
-
-        ONCE.call_once(|| {
-            solana_sdk::program_stubs::set_syscall_stubs(Box::new(SyscallStubs {}));
-        });
-        // `Into<ProgramError>`
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::MintHasNoMintAuthority),
-            Into::<ProgramError>::into(spl::ExampleError::MintHasNoMintAuthority),
-        );
-        assert_eq!(
-            Into::<ProgramError>::into(bench::ExampleError::IncorrectMintAuthority),
-            Into::<ProgramError>::into(spl::ExampleError::IncorrectMintAuthority),
-        );
-        // `DecodeError<T>`
-        assert_eq!(
-            <bench::ExampleError as DecodeError<bench::ExampleError>>::type_of(),
-            <bench::ExampleError as DecodeError<spl::ExampleError>>::type_of(),
-        );
-        // `PrintProgramError`
-        set_expected_data("Mint has no mint authority".as_bytes().to_vec());
-        PrintProgramError::print::<spl::ExampleError>(&spl::ExampleError::MintHasNoMintAuthority);
-        set_expected_data(
-            "Incorrect mint authority has signed the instruction"
-                .as_bytes()
-                .to_vec(),
-        );
-        PrintProgramError::print::<spl::ExampleError>(&spl::ExampleError::IncorrectMintAuthority);
-    }
-}
diff --git a/libraries/program-error/tests/print.rs b/libraries/program-error/tests/print.rs
deleted file mode 100644
index 8b68f66a581..00000000000
--- a/libraries/program-error/tests/print.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Tests `#[derive(PrintProgramError)]`
-
-use spl_program_error::*;
-
-/// Example error
-#[derive(
-    Clone,
-    Debug,
-    DecodeError,
-    Eq,
-    IntoProgramError,
-    PrintProgramError,
-    thiserror::Error,
-    num_derive::FromPrimitive,
-    PartialEq,
-)]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-
-/// Tests that all macros compile
-#[test]
-fn test_macros_compile() {
-    let _ = ExampleError::MintHasNoMintAuthority;
-}
diff --git a/libraries/program-error/tests/spl.rs b/libraries/program-error/tests/spl.rs
deleted file mode 100644
index bbdb9af0aca..00000000000
--- a/libraries/program-error/tests/spl.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! Tests `#[spl_program_error]`
-
-use spl_program_error::*;
-
-/// Example error
-#[spl_program_error]
-pub enum ExampleError {
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-}
-
-/// Tests that all macros compile
-#[test]
-fn test_macros_compile() {
-    let _ = ExampleError::MintHasNoMintAuthority;
-}
-
-/// Example library error with namespace
-#[spl_program_error(hash_error_code_start = 2_056_342_880)]
-enum ExampleLibraryError {
-    /// This is a very informative error
-    #[error("This is a very informative error")]
-    VeryInformativeError,
-    /// This is a super important error
-    #[error("This is a super important error")]
-    SuperImportantError,
-    /// This is a mega serious error
-    #[error("This is a mega serious error")]
-    MegaSeriousError,
-    /// You are toast
-    #[error("You are toast")]
-    YouAreToast,
-}
-
-/// Tests hashing of error codes into unique `u32` values
-#[test]
-fn test_library_error_codes() {
-    fn get_error_code_check(hash_input: &str) -> u32 {
-        let mut nonce: u32 = 0;
-        loop {
-            let hash = solana_program::hash::hashv(&[hash_input.as_bytes(), &nonce.to_le_bytes()]);
-            let mut bytes = [0u8; 4];
-            bytes.copy_from_slice(&hash.to_bytes()[13..17]);
-            let error_code = u32::from_le_bytes(bytes);
-            if error_code >= 10_000 {
-                return error_code;
-            }
-            nonce += 1;
-        }
-    }
-
-    let first_error_as_u32 = ExampleLibraryError::VeryInformativeError as u32;
-
-    assert_eq!(
-        ExampleLibraryError::VeryInformativeError as u32,
-        get_error_code_check("spl_program_error:ExampleLibraryError"),
-    );
-    assert_eq!(
-        ExampleLibraryError::SuperImportantError as u32,
-        first_error_as_u32 + 1,
-    );
-    assert_eq!(
-        ExampleLibraryError::MegaSeriousError as u32,
-        first_error_as_u32 + 2,
-    );
-    assert_eq!(
-        ExampleLibraryError::YouAreToast as u32,
-        first_error_as_u32 + 3,
-    );
-}
diff --git a/libraries/tlv-account-resolution/Cargo.toml b/libraries/tlv-account-resolution/Cargo.toml
deleted file mode 100644
index 5f4aa728982..00000000000
--- a/libraries/tlv-account-resolution/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "spl-tlv-account-resolution"
-version = "0.6.3"
-description = "Solana Program Library TLV Account Resolution Interface"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-serde-traits = ["dep:serde"]
-test-sbf = []
-
-[dependencies]
-bytemuck = { version = "1.16.0", features = ["derive"] }
-serde = { version = "1.0.203", optional = true }
-solana-program = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2", path = "../discriminator" }
-spl-program-error = { version = "0.4.0", path = "../program-error" }
-spl-type-length-value = { version = "0.4.3", path = "../type-length-value" }
-spl-pod = { version = "0.2.2", path = "../pod" }
-
-[dev-dependencies]
-futures = "0.3.30"
-futures-util = "0.3"
-solana-client = ">=1.18.11,<=2"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/tlv-account-resolution/README.md b/libraries/tlv-account-resolution/README.md
deleted file mode 100644
index 58a4bc7a269..00000000000
--- a/libraries/tlv-account-resolution/README.md
+++ /dev/null
@@ -1,196 +0,0 @@
-# TLV Account Resolution
-
-Library defining a generic state interface to encode additional required accounts
-for an instruction, using Type-Length-Value structures.
-
-## Example usage
-
-If you want to encode the additional required accounts for your instruction
-into a TLV entry in an account, you can do the following:
-
-```rust
-use {
-    solana_program::{account_info::AccountInfo, instruction::{AccountMeta, Instruction}, pubkey::Pubkey},
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_tlv_account_resolution::{
-        account::ExtraAccountMeta,
-        seeds::Seed,
-        state::ExtraAccountMetaList
-    },
-};
-
-struct MyInstruction;
-impl SplDiscriminate for MyInstruction {
-    // For ease of use, give it the same discriminator as its instruction definition
-    const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-}
-
-// Prepare the additional required account keys and signer / writable
-let extra_metas = [
-    AccountMeta::new(Pubkey::new_unique(), false).into(),
-    AccountMeta::new_readonly(Pubkey::new_unique(), true).into(),
-    ExtraAccountMeta::new_with_seeds(
-        &[
-            Seed::Literal {
-                bytes: b"some_string".to_vec(),
-            },
-            Seed::InstructionData {
-                index: 1,
-                length: 1, // u8
-            },
-            Seed::AccountKey { index: 1 },
-        ],
-        false,
-        true,
-    ).unwrap(),
-    ExtraAccountMeta::new_external_pda_with_seeds(
-        0,
-        &[Seed::AccountKey { index: 2 }],
-        false,
-        false,
-    ).unwrap(),
-];
-
-// Allocate a new buffer with the proper `account_size`
-let account_size = ExtraAccountMetaList::size_of(extra_metas.len()).unwrap();
-let mut buffer = vec![0; account_size];
-
-// Initialize the structure for your instruction
-ExtraAccountMetaList::init::<MyInstruction>(&mut buffer, &extra_metas).unwrap();
-
-// Off-chain, you can add the additional accounts directly from the account data
-// You need to provide the resolver a way to fetch account data off-chain
-let client = RpcClient::new_mock("succeeds".to_string());
-let program_id = Pubkey::new_unique();
-let mut instruction = Instruction::new_with_bytes(program_id, &[0, 1, 2], vec![]);
-ExtraAccountMetaList::add_to_instruction::<_, _, MyInstruction>(
-    &mut instruction,
-    |address: &Pubkey| {
-        client
-            .get_account(address)
-            .map_ok(|acct| Some(acct.data))
-        },
-    &buffer,
-)
-.await
-.unwrap();
-
-// On-chain, you can add the additional accounts *and* account infos
-let mut cpi_instruction = Instruction::new_with_bytes(program_id, &[0, 1, 2], vec![]);
-
-// Include all of the well-known required account infos here first
-let mut cpi_account_infos = vec![]; 
-
-// Provide all "remaining_account_infos" that are *not* part of any other known interface
-let remaining_account_infos = &[]; 
-ExtraAccountMetaList::add_to_cpi_instruction::<MyInstruction>(
-    &mut cpi_instruction,
-    &mut cpi_account_infos,
-    &buffer,
-    &remaining_account_infos,
-).unwrap();
-```
-
-For ease of use on-chain, `ExtraAccountMetaList::init` is also
-provided to initialize directly from a set of given accounts.
-
-## Motivation
-
-The Solana account model presents unique challenges for program interfaces.
-Since it's impossible to load additional accounts on-chain, if a program requires
-additional accounts to properly implement an instruction, there's no clear way
-for clients to fetch these accounts.
-
-There are two main ways to fetch additional accounts, dynamically through program
-simulation, or statically by fetching account data. This library implements
-additional account resolution statically. You can find more information about
-dynamic account resolution in the Appendix.
-
-### Static Account Resolution
-
-It's possible for programs to write the additional required account infos
-into account data, so that on-chain and off-chain clients simply need to read
-the data to figure out the additional required accounts.
-
-Rather than exposing this data dynamically through program execution, this method
-uses static account data.
-
-For example, let's imagine there's a `Transferable` interface, along with a
-`transfer` instruction. Some programs that implement `transfer` may need more
-accounts than just the ones defined in the interface. How does an on-chain or
-off-chain client figure out the additional required accounts?
-
-The "static" approach requires programs to write the extra required accounts to
-an account defined at a given address. This could be directly in the `mint`, or
-some address derivable from the mint address.
-
-Off-chain, a client must fetch this additional account and read its data to find
-out the additional required accounts, and then include them in the instruction.
-
-On-chain, a program must have access to "remaining account infos" containing the
-special account and all other required accounts to properly create the CPI
-instruction and give the correct account infos.
-
-This approach could also be called a "state interface".
-
-### Types of Required Accounts
-
-This library is capable of storing two types of configurations for additional
-required accounts:
-
-- Accounts with a fixed address
-- Accounts with a **dynamic program-derived address** derived from seeds that
-may come from any combination of the following:
-  - Hard-coded values, such as string literals or integers
-  - A slice of the instruction data provided to the transfer-hook program
-  - The address of another account in the total list of accounts
-  - A program id from another account in the instruction
-
-When you store configurations for a dynamic Program-Derived Address within the
-additional required accounts, the PDA itself is evaluated (or resolved) at the
-time of instruction invocation using the instruction itself. This
-occurs in the offchain and onchain helpers mentioned below, which leverage
-the SPL TLV Account Resolution library to perform this resolution
-automatically.
-
-## How it Works
-
-This library uses `spl-type-length-value` to read and write required instruction
-accounts from account data.
-
-Interface instructions must have an 8-byte discriminator, so that the exposed
-`ExtraAccountMetaList` type can use the instruction discriminator as an
-`ArrayDiscriminator`, which allows that discriminator to serve as a unique TLV
-discriminator for identifying entries that correspond to that particular
-instruction.
-
-This can be confusing. Typically, a type implements `SplDiscriminate`, so that
-the type can be written into TLV data. In this case, `ExtraAccountMetaList` is
-generic over `SplDiscriminate`, meaning that a program can write many different instances of
-`ExtraAccountMetaList` into one account, using different `ArrayDiscriminator`s.
-
-Also, it's reusing an instruction discriminator as a TLV discriminator. For example,
-if the `transfer` instruction has a discriminator of `[1, 2, 3, 4, 5, 6, 7, 8]`,
-then the account uses a TLV discriminator of `[1, 2, 3, 4, 5, 6, 7, 8]` to denote
-where the additional account metas are stored.
-
-This isn't required, but makes it easier for clients to find the additional
-required accounts for an instruction.
-
-## Appendix
-
-### Dynamic Account Resolution
-
-To expose the additional accounts required, instruction interfaces can include
-supplemental instructions to return the required accounts.
-
-For example, in the `Transferable` interface example, along with a `transfer`
-instruction, also requires implementations to expose a
-`get_additional_accounts_for_transfer` instruction.
-
-In the program implementation, this instruction writes the additional accounts
-into return data, making it easy for on-chain and off-chain clients to consume.
-
-See the
-[relevant sRFC](https://forum.solana.com/t/srfc-00010-additional-accounts-request-transfer-spec/122)
-for more information about the dynamic approach.
diff --git a/libraries/tlv-account-resolution/src/account.rs b/libraries/tlv-account-resolution/src/account.rs
deleted file mode 100644
index 86575793a95..00000000000
--- a/libraries/tlv-account-resolution/src/account.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-//! Struct for managing extra required account configs, ie. defining accounts
-//! required for your interface program, which can be  `AccountMeta`s - which
-//! have fixed addresses - or PDAs - which have addresses derived from a
-//! collection of seeds
-
-use {
-    crate::{error::AccountResolutionError, pubkey_data::PubkeyData, seeds::Seed},
-    bytemuck::{Pod, Zeroable},
-    solana_program::{
-        account_info::AccountInfo,
-        instruction::AccountMeta,
-        program_error::ProgramError,
-        pubkey::{Pubkey, PUBKEY_BYTES},
-    },
-    spl_pod::primitives::PodBool,
-};
-
-/// Resolve a program-derived address (PDA) from the instruction data
-/// and the accounts that have already been resolved
-fn resolve_pda<'a, F>(
-    seeds: &[Seed],
-    instruction_data: &[u8],
-    program_id: &Pubkey,
-    get_account_key_data_fn: F,
-) -> Result<Pubkey, ProgramError>
-where
-    F: Fn(usize) -> Option<(&'a Pubkey, Option<&'a [u8]>)>,
-{
-    let mut pda_seeds: Vec<&[u8]> = vec![];
-    for config in seeds {
-        match config {
-            Seed::Uninitialized => (),
-            Seed::Literal { bytes } => pda_seeds.push(bytes),
-            Seed::InstructionData { index, length } => {
-                let arg_start = *index as usize;
-                let arg_end = arg_start + *length as usize;
-                if arg_end > instruction_data.len() {
-                    return Err(AccountResolutionError::InstructionDataTooSmall.into());
-                }
-                pda_seeds.push(&instruction_data[arg_start..arg_end]);
-            }
-            Seed::AccountKey { index } => {
-                let account_index = *index as usize;
-                let address = get_account_key_data_fn(account_index)
-                    .ok_or::<ProgramError>(AccountResolutionError::AccountNotFound.into())?
-                    .0;
-                pda_seeds.push(address.as_ref());
-            }
-            Seed::AccountData {
-                account_index,
-                data_index,
-                length,
-            } => {
-                let account_index = *account_index as usize;
-                let account_data = get_account_key_data_fn(account_index)
-                    .ok_or::<ProgramError>(AccountResolutionError::AccountNotFound.into())?
-                    .1
-                    .ok_or::<ProgramError>(AccountResolutionError::AccountDataNotFound.into())?;
-                let arg_start = *data_index as usize;
-                let arg_end = arg_start + *length as usize;
-                if account_data.len() < arg_end {
-                    return Err(AccountResolutionError::AccountDataTooSmall.into());
-                }
-                pda_seeds.push(&account_data[arg_start..arg_end]);
-            }
-        }
-    }
-    Ok(Pubkey::find_program_address(&pda_seeds, program_id).0)
-}
-
-/// Resolve a pubkey from a pubkey data configuration.
-fn resolve_key_data<'a, F>(
-    key_data: &PubkeyData,
-    instruction_data: &[u8],
-    get_account_key_data_fn: F,
-) -> Result<Pubkey, ProgramError>
-where
-    F: Fn(usize) -> Option<(&'a Pubkey, Option<&'a [u8]>)>,
-{
-    match key_data {
-        PubkeyData::Uninitialized => Err(ProgramError::InvalidAccountData),
-        PubkeyData::InstructionData { index } => {
-            let key_start = *index as usize;
-            let key_end = key_start + PUBKEY_BYTES;
-            if key_end > instruction_data.len() {
-                return Err(AccountResolutionError::InstructionDataTooSmall.into());
-            }
-            Ok(Pubkey::new_from_array(
-                instruction_data[key_start..key_end].try_into().unwrap(),
-            ))
-        }
-        PubkeyData::AccountData {
-            account_index,
-            data_index,
-        } => {
-            let account_index = *account_index as usize;
-            let account_data = get_account_key_data_fn(account_index)
-                .ok_or::<ProgramError>(AccountResolutionError::AccountNotFound.into())?
-                .1
-                .ok_or::<ProgramError>(AccountResolutionError::AccountDataNotFound.into())?;
-            let arg_start = *data_index as usize;
-            let arg_end = arg_start + PUBKEY_BYTES;
-            if account_data.len() < arg_end {
-                return Err(AccountResolutionError::AccountDataTooSmall.into());
-            }
-            Ok(Pubkey::new_from_array(
-                account_data[arg_start..arg_end].try_into().unwrap(),
-            ))
-        }
-    }
-}
-
-/// `Pod` type for defining a required account in a validation account.
-///
-/// This can be any of the following:
-///
-/// * A standard `AccountMeta`
-/// * A PDA (with seed configurations)
-/// * A pubkey stored in some data (account or instruction data)
-///
-/// Can be used in TLV-encoded data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ExtraAccountMeta {
-    /// Discriminator to tell whether this represents a standard
-    /// `AccountMeta`, PDA, or pubkey data.
-    pub discriminator: u8,
-    /// This `address_config` field can either be the pubkey of the account,
-    /// the seeds used to derive the pubkey from provided inputs (PDA), or the
-    /// data used to derive the pubkey (account or instruction data).
-    pub address_config: [u8; 32],
-    /// Whether the account should sign
-    pub is_signer: PodBool,
-    /// Whether the account should be writable
-    pub is_writable: PodBool,
-}
-/// Helper used to know when the top bit is set, to interpret the
-/// discriminator as an index rather than as a type
-const U8_TOP_BIT: u8 = 1 << 7;
-impl ExtraAccountMeta {
-    /// Create a `ExtraAccountMeta` from a public key,
-    /// thus representing a standard `AccountMeta`
-    pub fn new_with_pubkey(
-        pubkey: &Pubkey,
-        is_signer: bool,
-        is_writable: bool,
-    ) -> Result<Self, ProgramError> {
-        Ok(Self {
-            discriminator: 0,
-            address_config: pubkey.to_bytes(),
-            is_signer: is_signer.into(),
-            is_writable: is_writable.into(),
-        })
-    }
-
-    /// Create a `ExtraAccountMeta` from a list of seed configurations,
-    /// thus representing a PDA
-    pub fn new_with_seeds(
-        seeds: &[Seed],
-        is_signer: bool,
-        is_writable: bool,
-    ) -> Result<Self, ProgramError> {
-        Ok(Self {
-            discriminator: 1,
-            address_config: Seed::pack_into_address_config(seeds)?,
-            is_signer: is_signer.into(),
-            is_writable: is_writable.into(),
-        })
-    }
-
-    /// Create a `ExtraAccountMeta` from a pubkey data configuration.
-    pub fn new_with_pubkey_data(
-        key_data: &PubkeyData,
-        is_signer: bool,
-        is_writable: bool,
-    ) -> Result<Self, ProgramError> {
-        Ok(Self {
-            discriminator: 2,
-            address_config: PubkeyData::pack_into_address_config(key_data)?,
-            is_signer: is_signer.into(),
-            is_writable: is_writable.into(),
-        })
-    }
-
-    /// Create a `ExtraAccountMeta` from a list of seed configurations,
-    /// representing a PDA for an external program
-    ///
-    /// This PDA belongs to a program elsewhere in the account list, rather
-    /// than the executing program. For a PDA on the executing program, use
-    /// `ExtraAccountMeta::new_with_seeds`.
-    pub fn new_external_pda_with_seeds(
-        program_index: u8,
-        seeds: &[Seed],
-        is_signer: bool,
-        is_writable: bool,
-    ) -> Result<Self, ProgramError> {
-        Ok(Self {
-            discriminator: program_index
-                .checked_add(U8_TOP_BIT)
-                .ok_or(AccountResolutionError::InvalidSeedConfig)?,
-            address_config: Seed::pack_into_address_config(seeds)?,
-            is_signer: is_signer.into(),
-            is_writable: is_writable.into(),
-        })
-    }
-
-    /// Resolve an `ExtraAccountMeta` into an `AccountMeta`, potentially
-    /// resolving a program-derived address (PDA) if necessary
-    pub fn resolve<'a, F>(
-        &self,
-        instruction_data: &[u8],
-        program_id: &Pubkey,
-        get_account_key_data_fn: F,
-    ) -> Result<AccountMeta, ProgramError>
-    where
-        F: Fn(usize) -> Option<(&'a Pubkey, Option<&'a [u8]>)>,
-    {
-        match self.discriminator {
-            0 => AccountMeta::try_from(self),
-            x if x == 1 || x >= U8_TOP_BIT => {
-                let program_id = if x == 1 {
-                    program_id
-                } else {
-                    get_account_key_data_fn(x.saturating_sub(U8_TOP_BIT) as usize)
-                        .ok_or::<ProgramError>(AccountResolutionError::AccountNotFound.into())?
-                        .0
-                };
-                let seeds = Seed::unpack_address_config(&self.address_config)?;
-                Ok(AccountMeta {
-                    pubkey: resolve_pda(
-                        &seeds,
-                        instruction_data,
-                        program_id,
-                        get_account_key_data_fn,
-                    )?,
-                    is_signer: self.is_signer.into(),
-                    is_writable: self.is_writable.into(),
-                })
-            }
-            2 => {
-                let key_data = PubkeyData::unpack(&self.address_config)?;
-                Ok(AccountMeta {
-                    pubkey: resolve_key_data(&key_data, instruction_data, get_account_key_data_fn)?,
-                    is_signer: self.is_signer.into(),
-                    is_writable: self.is_writable.into(),
-                })
-            }
-            _ => Err(ProgramError::InvalidAccountData),
-        }
-    }
-}
-
-impl From<&AccountMeta> for ExtraAccountMeta {
-    fn from(meta: &AccountMeta) -> Self {
-        Self {
-            discriminator: 0,
-            address_config: meta.pubkey.to_bytes(),
-            is_signer: meta.is_signer.into(),
-            is_writable: meta.is_writable.into(),
-        }
-    }
-}
-impl From<AccountMeta> for ExtraAccountMeta {
-    fn from(meta: AccountMeta) -> Self {
-        ExtraAccountMeta::from(&meta)
-    }
-}
-impl From<&AccountInfo<'_>> for ExtraAccountMeta {
-    fn from(account_info: &AccountInfo) -> Self {
-        Self {
-            discriminator: 0,
-            address_config: account_info.key.to_bytes(),
-            is_signer: account_info.is_signer.into(),
-            is_writable: account_info.is_writable.into(),
-        }
-    }
-}
-impl From<AccountInfo<'_>> for ExtraAccountMeta {
-    fn from(account_info: AccountInfo) -> Self {
-        ExtraAccountMeta::from(&account_info)
-    }
-}
-
-impl TryFrom<&ExtraAccountMeta> for AccountMeta {
-    type Error = ProgramError;
-
-    fn try_from(pod: &ExtraAccountMeta) -> Result<Self, Self::Error> {
-        if pod.discriminator == 0 {
-            Ok(AccountMeta {
-                pubkey: Pubkey::from(pod.address_config),
-                is_signer: pod.is_signer.into(),
-                is_writable: pod.is_writable.into(),
-            })
-        } else {
-            Err(AccountResolutionError::AccountTypeNotAccountMeta.into())
-        }
-    }
-}
diff --git a/libraries/tlv-account-resolution/src/error.rs b/libraries/tlv-account-resolution/src/error.rs
deleted file mode 100644
index 03aeaeba709..00000000000
--- a/libraries/tlv-account-resolution/src/error.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-//! Error types
-
-use spl_program_error::*;
-
-/// Errors that may be returned by the Account Resolution library.
-#[spl_program_error(hash_error_code_start = 2_724_315_840)]
-pub enum AccountResolutionError {
-    /// Incorrect account provided
-    #[error("Incorrect account provided")]
-    IncorrectAccount,
-    /// Not enough accounts provided
-    #[error("Not enough accounts provided")]
-    NotEnoughAccounts,
-    /// No value initialized in TLV data
-    #[error("No value initialized in TLV data")]
-    TlvUninitialized,
-    /// Some value initialized in TLV data
-    #[error("Some value initialized in TLV data")]
-    TlvInitialized,
-    /// Too many pubkeys provided
-    #[error("Too many pubkeys provided")]
-    TooManyPubkeys,
-    /// Failed to parse `Pubkey` from bytes
-    #[error("Failed to parse `Pubkey` from bytes")]
-    InvalidPubkey,
-    /// Attempted to deserialize an `AccountMeta` but the underlying type has
-    /// PDA configs rather than a fixed address
-    #[error(
-        "Attempted to deserialize an `AccountMeta` but the underlying type has PDA configs rather \
-         than a fixed address"
-    )]
-    AccountTypeNotAccountMeta,
-    /// Provided list of seed configurations too large for a validation account
-    #[error("Provided list of seed configurations too large for a validation account")]
-    SeedConfigsTooLarge,
-    /// Not enough bytes available to pack seed configuration
-    #[error("Not enough bytes available to pack seed configuration")]
-    NotEnoughBytesForSeed,
-    /// The provided bytes are not valid for a seed configuration
-    #[error("The provided bytes are not valid for a seed configuration")]
-    InvalidBytesForSeed,
-    /// Tried to pack an invalid seed configuration
-    #[error("Tried to pack an invalid seed configuration")]
-    InvalidSeedConfig,
-    /// Instruction data too small for seed configuration
-    #[error("Instruction data too small for seed configuration")]
-    InstructionDataTooSmall,
-    /// Could not find account at specified index
-    #[error("Could not find account at specified index")]
-    AccountNotFound,
-    /// Error in checked math operation
-    #[error("Error in checked math operation")]
-    CalculationFailure,
-    /// Could not find account data at specified index
-    #[error("Could not find account data at specified index")]
-    AccountDataNotFound,
-    /// Account data too small for requested seed configuration
-    #[error("Account data too small for requested seed configuration")]
-    AccountDataTooSmall,
-    /// Failed to fetch account
-    #[error("Failed to fetch account")]
-    AccountFetchFailed,
-    /// Not enough bytes available to pack pubkey data configuration.
-    #[error("Not enough bytes available to pack pubkey data configuration")]
-    NotEnoughBytesForPubkeyData,
-    /// The provided bytes are not valid for a pubkey data configuration
-    #[error("The provided bytes are not valid for a pubkey data configuration")]
-    InvalidBytesForPubkeyData,
-    /// Tried to pack an invalid pubkey data configuration
-    #[error("Tried to pack an invalid pubkey data configuration")]
-    InvalidPubkeyDataConfig,
-}
diff --git a/libraries/tlv-account-resolution/src/lib.rs b/libraries/tlv-account-resolution/src/lib.rs
deleted file mode 100644
index 5fbe38d1f70..00000000000
--- a/libraries/tlv-account-resolution/src/lib.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! Crate defining a state interface for offchain account resolution. If a
-//! program writes the proper state information into one of their accounts, any
-//! offchain and onchain client can fetch any additional required accounts for
-//! an instruction.
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod account;
-pub mod error;
-pub mod pubkey_data;
-pub mod seeds;
-pub mod state;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
diff --git a/libraries/tlv-account-resolution/src/pubkey_data.rs b/libraries/tlv-account-resolution/src/pubkey_data.rs
deleted file mode 100644
index 6585ba5c38a..00000000000
--- a/libraries/tlv-account-resolution/src/pubkey_data.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-//! Types for managing extra account meta keys that may be extracted from some
-//! data.
-//!
-//! This can be either account data from some account in the list of accounts
-//! or from the instruction data itself.
-
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {crate::error::AccountResolutionError, solana_program::program_error::ProgramError};
-
-/// Enum to describe a required key stored in some data.
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-pub enum PubkeyData {
-    /// Uninitialized configuration byte space.
-    Uninitialized,
-    /// A pubkey to be resolved from the instruction data.
-    ///
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Start index of instruction data
-    ///
-    /// Note: Length is always 32 bytes.
-    InstructionData {
-        /// The index where the address bytes begin in the instruction data.
-        index: u8,
-    },
-    /// A pubkey to be resolved from the inner data of some account.
-    ///
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Index of account in accounts list
-    ///     * 1 - Start index of account data
-    ///
-    /// Note: Length is always 32 bytes.
-    AccountData {
-        /// The index of the account in the entire accounts list.
-        account_index: u8,
-        /// The index where the address bytes begin in the account data.
-        data_index: u8,
-    },
-}
-impl PubkeyData {
-    /// Get the size of a pubkey data configuration.
-    pub fn tlv_size(&self) -> u8 {
-        match self {
-            Self::Uninitialized => 0,
-            // 1 byte for the discriminator, 1 byte for the index.
-            Self::InstructionData { .. } => 1 + 1,
-            // 1 byte for the discriminator, 1 byte for the account index,
-            // 1 byte for the data index.
-            Self::AccountData { .. } => 1 + 1 + 1,
-        }
-    }
-
-    /// Packs a pubkey data configuration into a slice.
-    pub fn pack(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-        // Because no `PubkeyData` variant is larger than 3 bytes, this check
-        // is sufficient for the data length.
-        if dst.len() != self.tlv_size() as usize {
-            return Err(AccountResolutionError::NotEnoughBytesForPubkeyData.into());
-        }
-        match &self {
-            Self::Uninitialized => {
-                return Err(AccountResolutionError::InvalidPubkeyDataConfig.into())
-            }
-            Self::InstructionData { index } => {
-                dst[0] = 1;
-                dst[1] = *index;
-            }
-            Self::AccountData {
-                account_index,
-                data_index,
-            } => {
-                dst[0] = 2;
-                dst[1] = *account_index;
-                dst[2] = *data_index;
-            }
-        }
-        Ok(())
-    }
-
-    /// Packs a pubkey data configuration into a 32-byte array, filling the
-    /// rest with 0s.
-    pub fn pack_into_address_config(key_data: &Self) -> Result<[u8; 32], ProgramError> {
-        let mut packed = [0u8; 32];
-        let tlv_size = key_data.tlv_size() as usize;
-        key_data.pack(&mut packed[..tlv_size])?;
-        Ok(packed)
-    }
-
-    /// Unpacks a pubkey data configuration from a slice.
-    pub fn unpack(bytes: &[u8]) -> Result<Self, ProgramError> {
-        let (discrim, rest) = bytes
-            .split_first()
-            .ok_or::<ProgramError>(ProgramError::InvalidAccountData)?;
-        match discrim {
-            0 => Ok(Self::Uninitialized),
-            1 => {
-                if rest.is_empty() {
-                    return Err(AccountResolutionError::InvalidBytesForPubkeyData.into());
-                }
-                Ok(Self::InstructionData { index: rest[0] })
-            }
-            2 => {
-                if rest.len() < 2 {
-                    return Err(AccountResolutionError::InvalidBytesForPubkeyData.into());
-                }
-                Ok(Self::AccountData {
-                    account_index: rest[0],
-                    data_index: rest[1],
-                })
-            }
-            _ => Err(ProgramError::InvalidAccountData),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_pack() {
-        // Should fail if the length is too short.
-        let key = PubkeyData::InstructionData { index: 0 };
-        let mut packed = vec![0u8; key.tlv_size() as usize - 1];
-        assert_eq!(
-            key.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::NotEnoughBytesForPubkeyData.into(),
-        );
-
-        // Should fail if the length is too long.
-        let key = PubkeyData::InstructionData { index: 0 };
-        let mut packed = vec![0u8; key.tlv_size() as usize + 1];
-        assert_eq!(
-            key.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::NotEnoughBytesForPubkeyData.into(),
-        );
-
-        // Can't pack a `PubkeyData::Uninitialized`.
-        let key = PubkeyData::Uninitialized;
-        let mut packed = vec![0u8; key.tlv_size() as usize];
-        assert_eq!(
-            key.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::InvalidPubkeyDataConfig.into(),
-        );
-    }
-
-    #[test]
-    fn test_unpack() {
-        // Can unpack zeroes.
-        let zeroes = [0u8; 32];
-        let key = PubkeyData::unpack(&zeroes).unwrap();
-        assert_eq!(key, PubkeyData::Uninitialized);
-
-        // Should fail for empty bytes.
-        let bytes = [];
-        assert_eq!(
-            PubkeyData::unpack(&bytes).unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-    }
-
-    fn test_pack_unpack_key(key: PubkeyData) {
-        let tlv_size = key.tlv_size() as usize;
-        let mut packed = vec![0u8; tlv_size];
-        key.pack(&mut packed).unwrap();
-        let unpacked = PubkeyData::unpack(&packed).unwrap();
-        assert_eq!(key, unpacked);
-    }
-
-    #[test]
-    fn test_pack_unpack() {
-        // Instruction data.
-        test_pack_unpack_key(PubkeyData::InstructionData { index: 0 });
-
-        // Account data.
-        test_pack_unpack_key(PubkeyData::AccountData {
-            account_index: 0,
-            data_index: 0,
-        });
-    }
-}
diff --git a/libraries/tlv-account-resolution/src/seeds.rs b/libraries/tlv-account-resolution/src/seeds.rs
deleted file mode 100644
index a3936ae8134..00000000000
--- a/libraries/tlv-account-resolution/src/seeds.rs
+++ /dev/null
@@ -1,524 +0,0 @@
-//! Types for managing seed configurations in TLV Account Resolution
-//!
-//! As determined by the `address_config` field of `ExtraAccountMeta`,
-//! seed configurations are limited to a maximum of 32 bytes.
-//! This means that the maximum number of seed configurations that can be
-//! packed into a single `ExtraAccountMeta` will depend directly on the size
-//! of the seed configurations themselves.
-//!
-//! Sizes are as follows:
-//!     * `Seed::Literal`: 1 + 1 + N
-//!         * 1 - Discriminator
-//!         * 1 - Length of literal
-//!         * N - Literal bytes themselves
-//!     * `Seed::InstructionData`: 1 + 1 + 1 = 3
-//!         * 1 - Discriminator
-//!         * 1 - Start index of instruction data
-//!         * 1 - Length of instruction data starting at index
-//!     * `Seed::AccountKey` - 1 + 1 = 2
-//!         * 1 - Discriminator
-//!         * 1 - Index of account in accounts list
-//!     * `Seed::AccountData`: 1 + 1 + 1 + 1 = 4
-//!         * 1 - Discriminator
-//!         * 1 - Index of account in accounts list
-//!         * 1 - Start index of account data
-//!         * 1 - Length of account data starting at index
-//!
-//! No matter which types of seeds you choose, the total size of all seed
-//! configurations must be less than or equal to 32 bytes.
-
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {crate::error::AccountResolutionError, solana_program::program_error::ProgramError};
-
-/// Enum to describe a required seed for a Program-Derived Address
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-pub enum Seed {
-    /// Uninitialized configuration byte space
-    Uninitialized,
-    /// A literal hard-coded argument
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Length of literal
-    ///     * N - Literal bytes themselves
-    Literal {
-        /// The literal value represented as a vector of bytes.
-        ///
-        /// For example, if a literal value is a string literal,
-        /// such as "my-seed", this value would be
-        /// `"my-seed".as_bytes().to_vec()`.
-        bytes: Vec<u8>,
-    },
-    /// An instruction-provided argument, to be resolved from the instruction
-    /// data
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Start index of instruction data
-    ///     * 1 - Length of instruction data starting at index
-    InstructionData {
-        /// The index where the bytes of an instruction argument begin
-        index: u8,
-        /// The length of the instruction argument (number of bytes)
-        ///
-        /// Note: Max seed length is 32 bytes, so `u8` is appropriate here
-        length: u8,
-    },
-    /// The public key of an account from the entire accounts list.
-    /// Note: This includes an extra accounts required.
-    ///
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Index of account in accounts list
-    AccountKey {
-        /// The index of the account in the entire accounts list
-        index: u8,
-    },
-    /// An argument to be resolved from the inner data of some account
-    /// Packed as:
-    ///     * 1 - Discriminator
-    ///     * 1 - Index of account in accounts list
-    ///     * 1 - Start index of account data
-    ///     * 1 - Length of account data starting at index
-    #[cfg_attr(
-        feature = "serde-traits",
-        serde(rename_all = "camelCase", alias = "account_data")
-    )]
-    AccountData {
-        /// The index of the account in the entire accounts list
-        account_index: u8,
-        /// The index where the bytes of an account data argument begin
-        data_index: u8,
-        /// The length of the argument (number of bytes)
-        ///
-        /// Note: Max seed length is 32 bytes, so `u8` is appropriate here
-        length: u8,
-    },
-}
-impl Seed {
-    /// Get the size of a seed configuration
-    pub fn tlv_size(&self) -> u8 {
-        match &self {
-            // 1 byte for the discriminator
-            Self::Uninitialized => 0,
-            // 1 byte for the discriminator, 1 byte for the length of the bytes, then the raw bytes
-            Self::Literal { bytes } => 1 + 1 + bytes.len() as u8,
-            // 1 byte for the discriminator, 1 byte for the index, 1 byte for the length
-            Self::InstructionData { .. } => 1 + 1 + 1,
-            // 1 byte for the discriminator, 1 byte for the index
-            Self::AccountKey { .. } => 1 + 1,
-            // 1 byte for the discriminator, 1 byte for the account index,
-            // 1 byte for the data index 1 byte for the length
-            Self::AccountData { .. } => 1 + 1 + 1 + 1,
-        }
-    }
-
-    /// Packs a seed configuration into a slice
-    pub fn pack(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-        if dst.len() != self.tlv_size() as usize {
-            return Err(AccountResolutionError::NotEnoughBytesForSeed.into());
-        }
-        if dst.len() > 32 {
-            return Err(AccountResolutionError::SeedConfigsTooLarge.into());
-        }
-        match &self {
-            Self::Uninitialized => return Err(AccountResolutionError::InvalidSeedConfig.into()),
-            Self::Literal { bytes } => {
-                dst[0] = 1;
-                dst[1] = bytes.len() as u8;
-                dst[2..].copy_from_slice(bytes);
-            }
-            Self::InstructionData { index, length } => {
-                dst[0] = 2;
-                dst[1] = *index;
-                dst[2] = *length;
-            }
-            Self::AccountKey { index } => {
-                dst[0] = 3;
-                dst[1] = *index;
-            }
-            Self::AccountData {
-                account_index,
-                data_index,
-                length,
-            } => {
-                dst[0] = 4;
-                dst[1] = *account_index;
-                dst[2] = *data_index;
-                dst[3] = *length;
-            }
-        }
-        Ok(())
-    }
-
-    /// Packs a vector of seed configurations into a 32-byte array,
-    /// filling the rest with 0s. Errors if it overflows.
-    pub fn pack_into_address_config(seeds: &[Self]) -> Result<[u8; 32], ProgramError> {
-        let mut packed = [0u8; 32];
-        let mut i: usize = 0;
-        for seed in seeds {
-            let seed_size = seed.tlv_size() as usize;
-            let slice_end = i + seed_size;
-            if slice_end > 32 {
-                return Err(AccountResolutionError::SeedConfigsTooLarge.into());
-            }
-            seed.pack(&mut packed[i..slice_end])?;
-            i = slice_end;
-        }
-        Ok(packed)
-    }
-
-    /// Unpacks a seed configuration from a slice
-    pub fn unpack(bytes: &[u8]) -> Result<Self, ProgramError> {
-        let (discrim, rest) = bytes
-            .split_first()
-            .ok_or::<ProgramError>(ProgramError::InvalidAccountData)?;
-        match discrim {
-            0 => Ok(Self::Uninitialized),
-            1 => unpack_seed_literal(rest),
-            2 => unpack_seed_instruction_arg(rest),
-            3 => unpack_seed_account_key(rest),
-            4 => unpack_seed_account_data(rest),
-            _ => Err(ProgramError::InvalidAccountData),
-        }
-    }
-
-    /// Unpacks all seed configurations from a 32-byte array.
-    /// Stops when it hits uninitialized data (0s).
-    pub fn unpack_address_config(address_config: &[u8; 32]) -> Result<Vec<Self>, ProgramError> {
-        let mut seeds = vec![];
-        let mut i = 0;
-        while i < 32 {
-            let seed = Self::unpack(&address_config[i..])?;
-            let seed_size = seed.tlv_size() as usize;
-            i += seed_size;
-            if seed == Self::Uninitialized {
-                break;
-            }
-            seeds.push(seed);
-        }
-        Ok(seeds)
-    }
-}
-
-fn unpack_seed_literal(bytes: &[u8]) -> Result<Seed, ProgramError> {
-    let (length, rest) = bytes
-        .split_first()
-        // Should be at least 1 byte
-        .ok_or::<ProgramError>(AccountResolutionError::InvalidBytesForSeed.into())?;
-    let length = *length as usize;
-    if rest.len() < length {
-        // Should be at least `length` bytes
-        return Err(AccountResolutionError::InvalidBytesForSeed.into());
-    }
-    Ok(Seed::Literal {
-        bytes: rest[..length].to_vec(),
-    })
-}
-
-fn unpack_seed_instruction_arg(bytes: &[u8]) -> Result<Seed, ProgramError> {
-    if bytes.len() < 2 {
-        // Should be at least 2 bytes
-        return Err(AccountResolutionError::InvalidBytesForSeed.into());
-    }
-    Ok(Seed::InstructionData {
-        index: bytes[0],
-        length: bytes[1],
-    })
-}
-
-fn unpack_seed_account_key(bytes: &[u8]) -> Result<Seed, ProgramError> {
-    if bytes.is_empty() {
-        // Should be at least 1 byte
-        return Err(AccountResolutionError::InvalidBytesForSeed.into());
-    }
-    Ok(Seed::AccountKey { index: bytes[0] })
-}
-
-fn unpack_seed_account_data(bytes: &[u8]) -> Result<Seed, ProgramError> {
-    if bytes.len() < 3 {
-        // Should be at least 3 bytes
-        return Err(AccountResolutionError::InvalidBytesForSeed.into());
-    }
-    Ok(Seed::AccountData {
-        account_index: bytes[0],
-        data_index: bytes[1],
-        length: bytes[2],
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_pack() {
-        // Seed too large
-        let seed = Seed::Literal { bytes: vec![1; 33] };
-        let mut packed = vec![0u8; seed.tlv_size() as usize];
-        assert_eq!(
-            seed.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::SeedConfigsTooLarge.into()
-        );
-        assert_eq!(
-            Seed::pack_into_address_config(&[seed]).unwrap_err(),
-            AccountResolutionError::SeedConfigsTooLarge.into()
-        );
-
-        // Should fail if the length is wrong
-        let seed = Seed::Literal { bytes: vec![1; 12] };
-        let mut packed = vec![0u8; seed.tlv_size() as usize - 1];
-        assert_eq!(
-            seed.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::NotEnoughBytesForSeed.into()
-        );
-
-        // Can't pack a `Seed::Uninitialized`
-        let seed = Seed::Uninitialized;
-        let mut packed = vec![0u8; seed.tlv_size() as usize];
-        assert_eq!(
-            seed.pack(&mut packed).unwrap_err(),
-            AccountResolutionError::InvalidSeedConfig.into()
-        );
-    }
-
-    #[test]
-    fn test_pack_address_config() {
-        // Should fail if one seed is too large
-        let seed = Seed::Literal { bytes: vec![1; 36] };
-        assert_eq!(
-            Seed::pack_into_address_config(&[seed]).unwrap_err(),
-            AccountResolutionError::SeedConfigsTooLarge.into()
-        );
-
-        // Should fail if the combination of all seeds is too large
-        let seed1 = Seed::Literal { bytes: vec![1; 30] }; // 30 bytes
-        let seed2 = Seed::InstructionData {
-            index: 0,
-            length: 4,
-        }; // 3 bytes
-        assert_eq!(
-            Seed::pack_into_address_config(&[seed1, seed2]).unwrap_err(),
-            AccountResolutionError::SeedConfigsTooLarge.into()
-        );
-    }
-
-    #[test]
-    fn test_unpack() {
-        // Can unpack zeroes
-        let zeroes = [0u8; 32];
-        let seeds = Seed::unpack_address_config(&zeroes).unwrap();
-        assert_eq!(seeds, vec![]);
-
-        // Should fail for empty bytes
-        let bytes = [];
-        assert_eq!(
-            Seed::unpack(&bytes).unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-
-        // Should fail if bytes are malformed for literal seed
-        let bytes = [
-            1, // Discrim (Literal)
-            4, // Length
-            1, 1, 1, // Incorrect length
-        ];
-        assert_eq!(
-            Seed::unpack(&bytes).unwrap_err(),
-            AccountResolutionError::InvalidBytesForSeed.into()
-        );
-
-        // Should fail if bytes are malformed for literal seed
-        let bytes = [
-            2, // Discrim (InstructionData)
-            2, // Index (Length missing)
-        ];
-        assert_eq!(
-            Seed::unpack(&bytes).unwrap_err(),
-            AccountResolutionError::InvalidBytesForSeed.into()
-        );
-
-        // Should fail if bytes are malformed for literal seed
-        let bytes = [
-            3, // Discrim (AccountKey, Index missing)
-        ];
-        assert_eq!(
-            Seed::unpack(&bytes).unwrap_err(),
-            AccountResolutionError::InvalidBytesForSeed.into()
-        );
-    }
-
-    #[test]
-    fn test_unpack_address_config() {
-        // Should fail if bytes are malformed
-        let bytes = [
-            1, // Discrim (Literal)
-            4, // Length
-            1, 1, 1, 1, // 4
-            6, // Discrim (Invalid)
-            2, // Index
-            1, // Length
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        ];
-        assert_eq!(
-            Seed::unpack_address_config(&bytes).unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-
-        // Should fail if 32nd byte is not zero, but it would be the
-        // start of a config
-        //
-        // Namely, if a seed config is unpacked and leaves 1 byte remaining,
-        // it has to be 0, since no valid seed config can be 1 byte long
-        let bytes = [
-            1,  // Discrim (Literal)
-            16, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 16
-            1,  // Discrim (Literal)
-            11, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 11
-            2, // Non-zero byte
-        ];
-        assert_eq!(
-            Seed::unpack_address_config(&bytes).unwrap_err(),
-            AccountResolutionError::InvalidBytesForSeed.into(),
-        );
-
-        // Should pass if 31st byte is not zero, but it would be
-        // the start of a config
-        //
-        // Similar to above, however we now have 2 bytes to work with,
-        // which could be a valid seed config
-        let bytes = [
-            1,  // Discrim (Literal)
-            16, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 16
-            1,  // Discrim (Literal)
-            10, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10
-            3, // Non-zero byte - Discrim (AccountKey)
-            0, // Index
-        ];
-        assert_eq!(
-            Seed::unpack_address_config(&bytes).unwrap(),
-            vec![
-                Seed::Literal {
-                    bytes: vec![1u8; 16]
-                },
-                Seed::Literal {
-                    bytes: vec![1u8; 10]
-                },
-                Seed::AccountKey { index: 0 }
-            ],
-        );
-
-        // Should fail if 31st byte is not zero and a valid seed config
-        // discriminator, but the seed config requires more than 2 bytes
-        let bytes = [
-            1,  // Discrim (Literal)
-            16, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 16
-            1,  // Discrim (Literal)
-            10, // Length
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10
-            2, // Non-zero byte - Discrim (InstructionData)
-            0, // Index (Length missing)
-        ];
-        assert_eq!(
-            Seed::unpack_address_config(&bytes).unwrap_err(),
-            AccountResolutionError::InvalidBytesForSeed.into(),
-        );
-    }
-
-    fn test_pack_unpack_seed(seed: Seed) {
-        let tlv_size = seed.tlv_size() as usize;
-        let mut packed = vec![0u8; tlv_size];
-        seed.pack(&mut packed).unwrap();
-        let unpacked = Seed::unpack(&packed).unwrap();
-        assert_eq!(seed, unpacked);
-    }
-
-    #[test]
-    fn test_pack_unpack() {
-        let mut mixed = vec![];
-
-        // Literals
-
-        let bytes = b"hello";
-        let seed = Seed::Literal {
-            bytes: bytes.to_vec(),
-        };
-        test_pack_unpack_seed(seed);
-
-        let bytes = 8u8.to_le_bytes();
-        let seed = Seed::Literal {
-            bytes: bytes.to_vec(),
-        };
-        test_pack_unpack_seed(seed.clone());
-        mixed.push(seed);
-
-        let bytes = 32u32.to_le_bytes();
-        let seed = Seed::Literal {
-            bytes: bytes.to_vec(),
-        };
-        test_pack_unpack_seed(seed.clone());
-        mixed.push(seed);
-
-        // Instruction args
-
-        let seed = Seed::InstructionData {
-            index: 0,
-            length: 0,
-        };
-        test_pack_unpack_seed(seed);
-
-        let seed = Seed::InstructionData {
-            index: 6,
-            length: 9,
-        };
-        test_pack_unpack_seed(seed.clone());
-        mixed.push(seed);
-
-        // Account keys
-
-        let seed = Seed::AccountKey { index: 0 };
-        test_pack_unpack_seed(seed);
-
-        let seed = Seed::AccountKey { index: 9 };
-        test_pack_unpack_seed(seed.clone());
-        mixed.push(seed);
-
-        // Account data
-
-        let seed = Seed::AccountData {
-            account_index: 0,
-            data_index: 0,
-            length: 0,
-        };
-        test_pack_unpack_seed(seed);
-
-        let seed = Seed::AccountData {
-            account_index: 0,
-            data_index: 0,
-            length: 9,
-        };
-        test_pack_unpack_seed(seed.clone());
-        mixed.push(seed);
-
-        // Arrays
-
-        let packed_array = Seed::pack_into_address_config(&mixed).unwrap();
-        let unpacked_array = Seed::unpack_address_config(&packed_array).unwrap();
-        assert_eq!(mixed, unpacked_array);
-
-        let mut shuffled_mixed = mixed.clone();
-        shuffled_mixed.swap(0, 1);
-        shuffled_mixed.swap(1, 4);
-        shuffled_mixed.swap(3, 0);
-
-        let packed_array = Seed::pack_into_address_config(&shuffled_mixed).unwrap();
-        let unpacked_array = Seed::unpack_address_config(&packed_array).unwrap();
-        assert_eq!(shuffled_mixed, unpacked_array);
-    }
-}
diff --git a/libraries/tlv-account-resolution/src/state.rs b/libraries/tlv-account-resolution/src/state.rs
deleted file mode 100644
index 16230521251..00000000000
--- a/libraries/tlv-account-resolution/src/state.rs
+++ /dev/null
@@ -1,1728 +0,0 @@
-//! State transition types
-
-use {
-    crate::{account::ExtraAccountMeta, error::AccountResolutionError},
-    solana_program::{
-        account_info::AccountInfo,
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_discriminator::SplDiscriminate,
-    spl_pod::slice::{PodSlice, PodSliceMut},
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut},
-    std::future::Future,
-};
-
-/// Type representing the output of an account fetching function, for easy
-/// chaining between APIs
-pub type AccountDataResult = Result<Option<Vec<u8>>, AccountFetchError>;
-/// Generic error type that can come out of any client while fetching account
-/// data
-pub type AccountFetchError = Box<dyn std::error::Error + Send + Sync>;
-
-/// Helper to convert an `AccountInfo` to an `AccountMeta`
-fn account_info_to_meta(account_info: &AccountInfo) -> AccountMeta {
-    AccountMeta {
-        pubkey: *account_info.key,
-        is_signer: account_info.is_signer,
-        is_writable: account_info.is_writable,
-    }
-}
-
-/// De-escalate an account meta if necessary
-fn de_escalate_account_meta(account_meta: &mut AccountMeta, account_metas: &[AccountMeta]) {
-    // This is a little tricky to read, but the idea is to see if
-    // this account is marked as writable or signer anywhere in
-    // the instruction at the start. If so, DON'T escalate it to
-    // be a writer or signer in the CPI
-    let maybe_highest_privileges = account_metas
-        .iter()
-        .filter(|&x| x.pubkey == account_meta.pubkey)
-        .map(|x| (x.is_signer, x.is_writable))
-        .reduce(|acc, x| (acc.0 || x.0, acc.1 || x.1));
-    // If `Some`, then the account was found somewhere in the instruction
-    if let Some((is_signer, is_writable)) = maybe_highest_privileges {
-        if !is_signer && is_signer != account_meta.is_signer {
-            // Existing account is *NOT* a signer already, but the CPI
-            // wants it to be, so de-escalate to not be a signer
-            account_meta.is_signer = false;
-        }
-        if !is_writable && is_writable != account_meta.is_writable {
-            // Existing account is *NOT* writable already, but the CPI
-            // wants it to be, so de-escalate to not be writable
-            account_meta.is_writable = false;
-        }
-    }
-}
-
-/// Stateless helper for storing additional accounts required for an
-/// instruction.
-///
-/// This struct works with any `SplDiscriminate`, and stores the extra accounts
-/// needed for that specific instruction, using the given `ArrayDiscriminator`
-/// as the type-length-value `ArrayDiscriminator`, and then storing all of the
-/// given `AccountMeta`s as a zero-copy slice.
-///
-/// Sample usage:
-///
-/// ```rust
-/// use {
-///     futures_util::TryFutureExt,
-///     solana_client::nonblocking::rpc_client::RpcClient,
-///     solana_program::{
-///         account_info::AccountInfo, instruction::{AccountMeta, Instruction},
-///         pubkey::Pubkey
-///     },
-///     spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-///     spl_tlv_account_resolution::{
-///         account::ExtraAccountMeta,
-///         seeds::Seed,
-///         state::{AccountDataResult, AccountFetchError, ExtraAccountMetaList}
-///     },
-/// };
-///
-/// struct MyInstruction;
-/// impl SplDiscriminate for MyInstruction {
-///     // Give it a unique discriminator, can also be generated using a hash function
-///     const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-/// }
-///
-/// // actually put it in the additional required account keys and signer / writable
-/// let extra_metas = [
-///     AccountMeta::new(Pubkey::new_unique(), false).into(),
-///     AccountMeta::new_readonly(Pubkey::new_unique(), false).into(),
-///     ExtraAccountMeta::new_with_seeds(
-///         &[
-///             Seed::Literal {
-///                 bytes: b"some_string".to_vec(),
-///             },
-///             Seed::InstructionData {
-///                 index: 1,
-///                 length: 1, // u8
-///             },
-///             Seed::AccountKey { index: 1 },
-///         ],
-///         false,
-///         true,
-///     ).unwrap(),
-///     ExtraAccountMeta::new_external_pda_with_seeds(
-///         0,
-///         &[Seed::AccountKey { index: 2 }],
-///         false,
-///         false,
-///     ).unwrap(),
-/// ];
-///
-/// // assume that this buffer is actually account data, already allocated to `account_size`
-/// let account_size = ExtraAccountMetaList::size_of(extra_metas.len()).unwrap();
-/// let mut buffer = vec![0; account_size];
-///
-/// // Initialize the structure for your instruction
-/// ExtraAccountMetaList::init::<MyInstruction>(&mut buffer, &extra_metas).unwrap();
-///
-/// // Off-chain, you can add the additional accounts directly from the account data
-/// // You need to provide the resolver a way to fetch account data off-chain
-/// struct MyClient {
-///     client: RpcClient,
-/// }
-/// impl MyClient {
-///     pub fn new() -> Self {
-///         Self {
-///             client: RpcClient::new_mock("succeeds".to_string()),
-///         }
-///     }
-///     pub async fn get_account_data(&self, address: Pubkey) -> AccountDataResult {
-///         self.client.get_account(&address)
-///             .await
-///             .map(|acct| Some(acct.data))
-///             .map_err(|e| Box::new(e) as AccountFetchError)
-///     }
-/// }
-///
-/// let client = MyClient::new();
-/// let program_id = Pubkey::new_unique();
-/// let mut instruction = Instruction::new_with_bytes(program_id, &[0, 1, 2], vec![]);
-/// # futures::executor::block_on(async {
-///     // Now use the resolver to add the additional accounts off-chain
-///     ExtraAccountMetaList::add_to_instruction::<MyInstruction, _, _>(
-///         &mut instruction,
-///         |address: Pubkey| client.get_account_data(address),
-///         &buffer,
-///     )
-///     .await;
-/// # });
-///
-/// // On-chain, you can add the additional accounts *and* account infos
-/// let mut cpi_instruction = Instruction::new_with_bytes(program_id, &[0, 1, 2], vec![]);
-/// let mut cpi_account_infos = vec![]; // assume the other required account infos are already included
-/// let remaining_account_infos: &[AccountInfo<'_>] = &[]; // these are the account infos provided to the instruction that are *not* part of any other known interface
-/// ExtraAccountMetaList::add_to_cpi_instruction::<MyInstruction>(
-///     &mut cpi_instruction,
-///     &mut cpi_account_infos,
-///     &buffer,
-///     &remaining_account_infos,
-/// );
-/// ```
-pub struct ExtraAccountMetaList;
-impl ExtraAccountMetaList {
-    /// Initialize pod slice data for the given instruction and its required
-    /// list of `ExtraAccountMeta`s
-    pub fn init<T: SplDiscriminate>(
-        data: &mut [u8],
-        extra_account_metas: &[ExtraAccountMeta],
-    ) -> Result<(), ProgramError> {
-        let mut state = TlvStateMut::unpack(data).unwrap();
-        let tlv_size = PodSlice::<ExtraAccountMeta>::size_of(extra_account_metas.len())?;
-        let (bytes, _) = state.alloc::<T>(tlv_size, false)?;
-        let mut validation_data = PodSliceMut::init(bytes)?;
-        for meta in extra_account_metas {
-            validation_data.push(*meta)?;
-        }
-        Ok(())
-    }
-
-    /// Update pod slice data for the given instruction and its required
-    /// list of `ExtraAccountMeta`s
-    pub fn update<T: SplDiscriminate>(
-        data: &mut [u8],
-        extra_account_metas: &[ExtraAccountMeta],
-    ) -> Result<(), ProgramError> {
-        let mut state = TlvStateMut::unpack(data).unwrap();
-        let tlv_size = PodSlice::<ExtraAccountMeta>::size_of(extra_account_metas.len())?;
-        let bytes = state.realloc_first::<T>(tlv_size)?;
-        let mut validation_data = PodSliceMut::init(bytes)?;
-        for meta in extra_account_metas {
-            validation_data.push(*meta)?;
-        }
-        Ok(())
-    }
-
-    /// Get the underlying `PodSlice<ExtraAccountMeta>` from an unpacked TLV
-    ///
-    /// Due to lifetime annoyances, this function can't just take in the bytes,
-    /// since then we would be returning a reference to a locally created
-    /// `TlvStateBorrowed`. I hope there's a better way to do this!
-    pub fn unpack_with_tlv_state<'a, T: SplDiscriminate>(
-        tlv_state: &'a TlvStateBorrowed,
-    ) -> Result<PodSlice<'a, ExtraAccountMeta>, ProgramError> {
-        let bytes = tlv_state.get_first_bytes::<T>()?;
-        PodSlice::<ExtraAccountMeta>::unpack(bytes)
-    }
-
-    /// Get the byte size required to hold `num_items` items
-    pub fn size_of(num_items: usize) -> Result<usize, ProgramError> {
-        Ok(TlvStateBorrowed::get_base_len()
-            .saturating_add(PodSlice::<ExtraAccountMeta>::size_of(num_items)?))
-    }
-
-    /// Checks provided account infos against validation data, using
-    /// instruction data and program ID to resolve any dynamic PDAs
-    /// if necessary.
-    ///
-    /// Note: this function will also verify all extra required accounts
-    /// have been provided in the correct order
-    pub fn check_account_infos<T: SplDiscriminate>(
-        account_infos: &[AccountInfo],
-        instruction_data: &[u8],
-        program_id: &Pubkey,
-        data: &[u8],
-    ) -> Result<(), ProgramError> {
-        let state = TlvStateBorrowed::unpack(data).unwrap();
-        let extra_meta_list = ExtraAccountMetaList::unpack_with_tlv_state::<T>(&state)?;
-        let extra_account_metas = extra_meta_list.data();
-
-        let initial_accounts_len = account_infos.len() - extra_account_metas.len();
-
-        // Convert to `AccountMeta` to check resolved metas
-        let provided_metas = account_infos
-            .iter()
-            .map(account_info_to_meta)
-            .collect::<Vec<_>>();
-
-        for (i, config) in extra_account_metas.iter().enumerate() {
-            let meta = {
-                // Create a list of `Ref`s so we can reference account data in the
-                // resolution step
-                let account_key_data_refs = account_infos
-                    .iter()
-                    .map(|info| {
-                        let key = *info.key;
-                        let data = info.try_borrow_data()?;
-                        Ok((key, data))
-                    })
-                    .collect::<Result<Vec<_>, ProgramError>>()?;
-
-                config.resolve(instruction_data, program_id, |usize| {
-                    account_key_data_refs
-                        .get(usize)
-                        .map(|(pubkey, opt_data)| (pubkey, Some(opt_data.as_ref())))
-                })?
-            };
-
-            // Ensure the account is in the correct position
-            let expected_index = i
-                .checked_add(initial_accounts_len)
-                .ok_or::<ProgramError>(AccountResolutionError::CalculationFailure.into())?;
-            if provided_metas.get(expected_index) != Some(&meta) {
-                return Err(AccountResolutionError::IncorrectAccount.into());
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Add the additional account metas to an existing instruction
-    pub async fn add_to_instruction<T: SplDiscriminate, F, Fut>(
-        instruction: &mut Instruction,
-        fetch_account_data_fn: F,
-        data: &[u8],
-    ) -> Result<(), ProgramError>
-    where
-        F: Fn(Pubkey) -> Fut,
-        Fut: Future<Output = AccountDataResult>,
-    {
-        let state = TlvStateBorrowed::unpack(data)?;
-        let bytes = state.get_first_bytes::<T>()?;
-        let extra_account_metas = PodSlice::<ExtraAccountMeta>::unpack(bytes)?;
-
-        // Fetch account data for each of the instruction accounts
-        let mut account_key_datas = vec![];
-        for meta in instruction.accounts.iter() {
-            let account_data = fetch_account_data_fn(meta.pubkey)
-                .await
-                .map_err::<ProgramError, _>(|_| {
-                    AccountResolutionError::AccountFetchFailed.into()
-                })?;
-            account_key_datas.push((meta.pubkey, account_data));
-        }
-
-        for extra_meta in extra_account_metas.data().iter() {
-            let mut meta =
-                extra_meta.resolve(&instruction.data, &instruction.program_id, |usize| {
-                    account_key_datas
-                        .get(usize)
-                        .map(|(pubkey, opt_data)| (pubkey, opt_data.as_ref().map(|x| x.as_slice())))
-                })?;
-            de_escalate_account_meta(&mut meta, &instruction.accounts);
-
-            // Fetch account data for the new account
-            account_key_datas.push((
-                meta.pubkey,
-                fetch_account_data_fn(meta.pubkey)
-                    .await
-                    .map_err::<ProgramError, _>(|_| {
-                        AccountResolutionError::AccountFetchFailed.into()
-                    })?,
-            ));
-            instruction.accounts.push(meta);
-        }
-        Ok(())
-    }
-
-    /// Add the additional account metas and account infos for a CPI
-    pub fn add_to_cpi_instruction<'a, T: SplDiscriminate>(
-        cpi_instruction: &mut Instruction,
-        cpi_account_infos: &mut Vec<AccountInfo<'a>>,
-        data: &[u8],
-        account_infos: &[AccountInfo<'a>],
-    ) -> Result<(), ProgramError> {
-        let state = TlvStateBorrowed::unpack(data)?;
-        let bytes = state.get_first_bytes::<T>()?;
-        let extra_account_metas = PodSlice::<ExtraAccountMeta>::unpack(bytes)?;
-
-        for extra_meta in extra_account_metas.data().iter() {
-            let mut meta = {
-                // Create a list of `Ref`s so we can reference account data in the
-                // resolution step
-                let account_key_data_refs = cpi_account_infos
-                    .iter()
-                    .map(|info| {
-                        let key = *info.key;
-                        let data = info.try_borrow_data()?;
-                        Ok((key, data))
-                    })
-                    .collect::<Result<Vec<_>, ProgramError>>()?;
-
-                extra_meta.resolve(
-                    &cpi_instruction.data,
-                    &cpi_instruction.program_id,
-                    |usize| {
-                        account_key_data_refs
-                            .get(usize)
-                            .map(|(pubkey, opt_data)| (pubkey, Some(opt_data.as_ref())))
-                    },
-                )?
-            };
-            de_escalate_account_meta(&mut meta, &cpi_instruction.accounts);
-
-            let account_info = account_infos
-                .iter()
-                .find(|&x| *x.key == meta.pubkey)
-                .ok_or(AccountResolutionError::IncorrectAccount)?
-                .clone();
-
-            cpi_instruction.accounts.push(meta);
-            cpi_account_infos.push(account_info);
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::{pubkey_data::PubkeyData, seeds::Seed},
-        solana_program::{clock::Epoch, instruction::AccountMeta, pubkey::Pubkey},
-        solana_program_test::tokio,
-        spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-        std::collections::HashMap,
-    };
-
-    pub struct TestInstruction;
-    impl SplDiscriminate for TestInstruction {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-    }
-
-    pub struct TestOtherInstruction;
-    impl SplDiscriminate for TestOtherInstruction {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([2; ArrayDiscriminator::LENGTH]);
-    }
-
-    pub struct MockRpc<'a> {
-        cache: HashMap<Pubkey, &'a AccountInfo<'a>>,
-    }
-    impl<'a> MockRpc<'a> {
-        pub fn setup(account_infos: &'a [AccountInfo<'a>]) -> Self {
-            let mut cache = HashMap::new();
-            for info in account_infos {
-                cache.insert(*info.key, info);
-            }
-            Self { cache }
-        }
-
-        pub async fn get_account_data(&self, pubkey: Pubkey) -> AccountDataResult {
-            Ok(self
-                .cache
-                .get(&pubkey)
-                .map(|account| account.try_borrow_data().unwrap().to_vec()))
-        }
-    }
-
-    #[tokio::test]
-    async fn init_with_metas() {
-        let metas = [
-            AccountMeta::new(Pubkey::new_unique(), false).into(),
-            AccountMeta::new(Pubkey::new_unique(), true).into(),
-            AccountMeta::new_readonly(Pubkey::new_unique(), true).into(),
-            AccountMeta::new_readonly(Pubkey::new_unique(), false).into(),
-        ];
-        let account_size = ExtraAccountMetaList::size_of(metas.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &metas).unwrap();
-
-        let mock_rpc = MockRpc::setup(&[]);
-
-        let mut instruction = Instruction::new_with_bytes(Pubkey::new_unique(), &[], vec![]);
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let check_metas = metas
-            .iter()
-            .map(|e| AccountMeta::try_from(e).unwrap())
-            .collect::<Vec<_>>();
-
-        assert_eq!(instruction.accounts, check_metas,);
-    }
-
-    #[tokio::test]
-    async fn init_with_infos() {
-        let program_id = Pubkey::new_unique();
-
-        let pubkey1 = Pubkey::new_unique();
-        let mut lamports1 = 0;
-        let mut data1 = [];
-        let pubkey2 = Pubkey::new_unique();
-        let mut lamports2 = 0;
-        let mut data2 = [4, 4, 4, 6, 6, 6, 8, 8];
-        let pubkey3 = Pubkey::new_unique();
-        let mut lamports3 = 0;
-        let mut data3 = [];
-        let owner = Pubkey::new_unique();
-        let account_infos = [
-            AccountInfo::new(
-                &pubkey1,
-                false,
-                true,
-                &mut lamports1,
-                &mut data1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey2,
-                true,
-                false,
-                &mut lamports2,
-                &mut data2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey3,
-                false,
-                false,
-                &mut lamports3,
-                &mut data3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-        ];
-
-        let required_pda = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::AccountKey { index: 0 },
-                Seed::AccountData {
-                    account_index: 1,
-                    data_index: 2,
-                    length: 4,
-                },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-
-        // Convert to `ExtraAccountMeta`
-        let required_extra_accounts = [
-            ExtraAccountMeta::from(&account_infos[0]),
-            ExtraAccountMeta::from(&account_infos[1]),
-            ExtraAccountMeta::from(&account_infos[2]),
-            required_pda,
-        ];
-
-        let account_size = ExtraAccountMetaList::size_of(required_extra_accounts.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &required_extra_accounts)
-            .unwrap();
-
-        let mock_rpc = MockRpc::setup(&account_infos);
-
-        let mut instruction = Instruction::new_with_bytes(program_id, &[], vec![]);
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let (check_required_pda, _) = Pubkey::find_program_address(
-            &[
-                account_infos[0].key.as_ref(),                      // Account key
-                &account_infos[1].try_borrow_data().unwrap()[2..6], // Account data
-            ],
-            &program_id,
-        );
-
-        // Convert to `AccountMeta` to check instruction
-        let check_metas = [
-            account_info_to_meta(&account_infos[0]),
-            account_info_to_meta(&account_infos[1]),
-            account_info_to_meta(&account_infos[2]),
-            AccountMeta::new(check_required_pda, false),
-        ];
-
-        assert_eq!(instruction.accounts, check_metas,);
-
-        assert_eq!(
-            instruction.accounts.get(3).unwrap().pubkey,
-            check_required_pda
-        );
-    }
-
-    #[tokio::test]
-    async fn init_with_extra_account_metas() {
-        let program_id = Pubkey::new_unique();
-
-        let extra_meta3_literal_str = "seed_prefix";
-
-        let ix_account1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let ix_account2 = AccountMeta::new(Pubkey::new_unique(), true);
-
-        let extra_meta1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let extra_meta2 = AccountMeta::new(Pubkey::new_unique(), true);
-        let extra_meta3 = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: extra_meta3_literal_str.as_bytes().to_vec(),
-                },
-                Seed::InstructionData {
-                    index: 1,
-                    length: 1, // u8
-                },
-                Seed::AccountKey { index: 0 },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-        let extra_meta4 = ExtraAccountMeta::new_with_pubkey_data(
-            &PubkeyData::InstructionData { index: 4 },
-            false,
-            true,
-        )
-        .unwrap();
-
-        let metas = [
-            ExtraAccountMeta::from(&extra_meta1),
-            ExtraAccountMeta::from(&extra_meta2),
-            extra_meta3,
-            extra_meta4,
-        ];
-
-        let mut ix_data = vec![1, 2, 3, 4];
-        let check_extra_meta4_pubkey = Pubkey::new_unique();
-        ix_data.extend_from_slice(check_extra_meta4_pubkey.as_ref());
-
-        let ix_accounts = vec![ix_account1.clone(), ix_account2.clone()];
-        let mut instruction = Instruction::new_with_bytes(program_id, &ix_data, ix_accounts);
-
-        let account_size = ExtraAccountMetaList::size_of(metas.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &metas).unwrap();
-
-        let mock_rpc = MockRpc::setup(&[]);
-
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let check_extra_meta3_u8_arg = ix_data[1];
-        let check_extra_meta3_pubkey = Pubkey::find_program_address(
-            &[
-                extra_meta3_literal_str.as_bytes(),
-                &[check_extra_meta3_u8_arg],
-                ix_account1.pubkey.as_ref(),
-                extra_meta1.pubkey.as_ref(),
-            ],
-            &program_id,
-        )
-        .0;
-        let check_metas = [
-            ix_account1,
-            ix_account2,
-            extra_meta1,
-            extra_meta2,
-            AccountMeta::new(check_extra_meta3_pubkey, false),
-            AccountMeta::new(check_extra_meta4_pubkey, false),
-        ];
-
-        assert_eq!(
-            instruction.accounts.get(4).unwrap().pubkey,
-            check_extra_meta3_pubkey,
-        );
-        assert_eq!(
-            instruction.accounts.get(5).unwrap().pubkey,
-            check_extra_meta4_pubkey,
-        );
-        assert_eq!(instruction.accounts, check_metas,);
-    }
-
-    #[tokio::test]
-    async fn init_multiple() {
-        let extra_meta5_literal_str = "seed_prefix";
-        let extra_meta5_literal_u32 = 4u32;
-        let other_meta2_literal_str = "other_seed_prefix";
-
-        let extra_meta1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let extra_meta2 = AccountMeta::new(Pubkey::new_unique(), true);
-        let extra_meta3 = AccountMeta::new_readonly(Pubkey::new_unique(), true);
-        let extra_meta4 = AccountMeta::new_readonly(Pubkey::new_unique(), false);
-        let extra_meta5 = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: extra_meta5_literal_str.as_bytes().to_vec(),
-                },
-                Seed::Literal {
-                    bytes: extra_meta5_literal_u32.to_le_bytes().to_vec(),
-                },
-                Seed::InstructionData {
-                    index: 5,
-                    length: 1, // u8
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-        let extra_meta6 = ExtraAccountMeta::new_with_pubkey_data(
-            &PubkeyData::InstructionData { index: 8 },
-            false,
-            true,
-        )
-        .unwrap();
-
-        let other_meta1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let other_meta2 = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: other_meta2_literal_str.as_bytes().to_vec(),
-                },
-                Seed::InstructionData {
-                    index: 1,
-                    length: 4, // u32
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-        let other_meta3 = ExtraAccountMeta::new_with_pubkey_data(
-            &PubkeyData::InstructionData { index: 7 },
-            false,
-            true,
-        )
-        .unwrap();
-
-        let metas = [
-            ExtraAccountMeta::from(&extra_meta1),
-            ExtraAccountMeta::from(&extra_meta2),
-            ExtraAccountMeta::from(&extra_meta3),
-            ExtraAccountMeta::from(&extra_meta4),
-            extra_meta5,
-            extra_meta6,
-        ];
-        let other_metas = [
-            ExtraAccountMeta::from(&other_meta1),
-            other_meta2,
-            other_meta3,
-        ];
-
-        let account_size = ExtraAccountMetaList::size_of(metas.len()).unwrap()
-            + ExtraAccountMetaList::size_of(other_metas.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &metas).unwrap();
-        ExtraAccountMetaList::init::<TestOtherInstruction>(&mut buffer, &other_metas).unwrap();
-
-        let mock_rpc = MockRpc::setup(&[]);
-
-        let program_id = Pubkey::new_unique();
-
-        let mut ix_data = vec![0, 0, 0, 0, 0, 7, 0, 0];
-        let check_extra_meta6_pubkey = Pubkey::new_unique();
-        ix_data.extend_from_slice(check_extra_meta6_pubkey.as_ref());
-
-        let ix_accounts = vec![];
-
-        let mut instruction = Instruction::new_with_bytes(program_id, &ix_data, ix_accounts);
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let check_extra_meta5_u8_arg = ix_data[5];
-        let check_extra_meta5_pubkey = Pubkey::find_program_address(
-            &[
-                extra_meta5_literal_str.as_bytes(),
-                extra_meta5_literal_u32.to_le_bytes().as_ref(),
-                &[check_extra_meta5_u8_arg],
-                extra_meta3.pubkey.as_ref(),
-            ],
-            &program_id,
-        )
-        .0;
-        let check_metas = [
-            extra_meta1,
-            extra_meta2,
-            extra_meta3,
-            extra_meta4,
-            AccountMeta::new(check_extra_meta5_pubkey, false),
-            AccountMeta::new(check_extra_meta6_pubkey, false),
-        ];
-
-        assert_eq!(
-            instruction.accounts.get(4).unwrap().pubkey,
-            check_extra_meta5_pubkey,
-        );
-        assert_eq!(
-            instruction.accounts.get(5).unwrap().pubkey,
-            check_extra_meta6_pubkey,
-        );
-        assert_eq!(instruction.accounts, check_metas,);
-
-        let program_id = Pubkey::new_unique();
-
-        let ix_account1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let ix_account2 = AccountMeta::new(Pubkey::new_unique(), true);
-        let ix_accounts = vec![ix_account1.clone(), ix_account2.clone()];
-
-        let mut ix_data = vec![0, 26, 0, 0, 0, 0, 0];
-        let check_other_meta3_pubkey = Pubkey::new_unique();
-        ix_data.extend_from_slice(check_other_meta3_pubkey.as_ref());
-
-        let mut instruction = Instruction::new_with_bytes(program_id, &ix_data, ix_accounts);
-        ExtraAccountMetaList::add_to_instruction::<TestOtherInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let check_other_meta2_u32_arg = u32::from_le_bytes(ix_data[1..5].try_into().unwrap());
-        let check_other_meta2_pubkey = Pubkey::find_program_address(
-            &[
-                other_meta2_literal_str.as_bytes(),
-                check_other_meta2_u32_arg.to_le_bytes().as_ref(),
-                ix_account1.pubkey.as_ref(),
-            ],
-            &program_id,
-        )
-        .0;
-        let check_other_metas = [
-            ix_account1,
-            ix_account2,
-            other_meta1,
-            AccountMeta::new(check_other_meta2_pubkey, false),
-            AccountMeta::new(check_other_meta3_pubkey, false),
-        ];
-
-        assert_eq!(
-            instruction.accounts.get(3).unwrap().pubkey,
-            check_other_meta2_pubkey,
-        );
-        assert_eq!(
-            instruction.accounts.get(4).unwrap().pubkey,
-            check_other_meta3_pubkey,
-        );
-        assert_eq!(instruction.accounts, check_other_metas,);
-    }
-
-    #[tokio::test]
-    async fn init_mixed() {
-        let extra_meta5_literal_str = "seed_prefix";
-        let extra_meta6_literal_u64 = 28u64;
-
-        let pubkey1 = Pubkey::new_unique();
-        let mut lamports1 = 0;
-        let mut data1 = [];
-        let pubkey2 = Pubkey::new_unique();
-        let mut lamports2 = 0;
-        let mut data2 = [];
-        let pubkey3 = Pubkey::new_unique();
-        let mut lamports3 = 0;
-        let mut data3 = [];
-        let owner = Pubkey::new_unique();
-        let account_infos = [
-            AccountInfo::new(
-                &pubkey1,
-                false,
-                true,
-                &mut lamports1,
-                &mut data1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey2,
-                true,
-                false,
-                &mut lamports2,
-                &mut data2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey3,
-                false,
-                false,
-                &mut lamports3,
-                &mut data3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-        ];
-
-        let extra_meta1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let extra_meta2 = AccountMeta::new(Pubkey::new_unique(), true);
-        let extra_meta3 = AccountMeta::new_readonly(Pubkey::new_unique(), true);
-        let extra_meta4 = AccountMeta::new_readonly(Pubkey::new_unique(), false);
-        let extra_meta5 = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: extra_meta5_literal_str.as_bytes().to_vec(),
-                },
-                Seed::InstructionData {
-                    index: 1,
-                    length: 8, // [u8; 8]
-                },
-                Seed::InstructionData {
-                    index: 9,
-                    length: 32, // Pubkey
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-        let extra_meta6 = ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: extra_meta6_literal_u64.to_le_bytes().to_vec(),
-                },
-                Seed::AccountKey { index: 1 },
-                Seed::AccountKey { index: 4 },
-            ],
-            false,
-            true,
-        )
-        .unwrap();
-        let extra_meta7 = ExtraAccountMeta::new_with_pubkey_data(
-            &PubkeyData::InstructionData { index: 41 }, // After the other pubkey arg.
-            false,
-            true,
-        )
-        .unwrap();
-
-        let test_ix_required_extra_accounts = account_infos
-            .iter()
-            .map(ExtraAccountMeta::from)
-            .collect::<Vec<_>>();
-        let test_other_ix_required_extra_accounts = [
-            ExtraAccountMeta::from(&extra_meta1),
-            ExtraAccountMeta::from(&extra_meta2),
-            ExtraAccountMeta::from(&extra_meta3),
-            ExtraAccountMeta::from(&extra_meta4),
-            extra_meta5,
-            extra_meta6,
-            extra_meta7,
-        ];
-
-        let account_size = ExtraAccountMetaList::size_of(test_ix_required_extra_accounts.len())
-            .unwrap()
-            + ExtraAccountMetaList::size_of(test_other_ix_required_extra_accounts.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-
-        ExtraAccountMetaList::init::<TestInstruction>(
-            &mut buffer,
-            &test_ix_required_extra_accounts,
-        )
-        .unwrap();
-        ExtraAccountMetaList::init::<TestOtherInstruction>(
-            &mut buffer,
-            &test_other_ix_required_extra_accounts,
-        )
-        .unwrap();
-
-        let mock_rpc = MockRpc::setup(&account_infos);
-
-        let program_id = Pubkey::new_unique();
-        let mut instruction = Instruction::new_with_bytes(program_id, &[], vec![]);
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let test_ix_check_metas = account_infos
-            .iter()
-            .map(account_info_to_meta)
-            .collect::<Vec<_>>();
-        assert_eq!(instruction.accounts, test_ix_check_metas,);
-
-        let program_id = Pubkey::new_unique();
-
-        let instruction_u8array_arg = [1, 2, 3, 4, 5, 6, 7, 8];
-        let instruction_pubkey_arg = Pubkey::new_unique();
-        let instruction_key_data_pubkey_arg = Pubkey::new_unique();
-
-        let mut instruction_data = vec![0];
-        instruction_data.extend_from_slice(&instruction_u8array_arg);
-        instruction_data.extend_from_slice(instruction_pubkey_arg.as_ref());
-        instruction_data.extend_from_slice(instruction_key_data_pubkey_arg.as_ref());
-
-        let mut instruction = Instruction::new_with_bytes(program_id, &instruction_data, vec![]);
-        ExtraAccountMetaList::add_to_instruction::<TestOtherInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        let check_extra_meta5_pubkey = Pubkey::find_program_address(
-            &[
-                extra_meta5_literal_str.as_bytes(),
-                &instruction_u8array_arg,
-                instruction_pubkey_arg.as_ref(),
-                extra_meta3.pubkey.as_ref(),
-            ],
-            &program_id,
-        )
-        .0;
-
-        let check_extra_meta6_pubkey = Pubkey::find_program_address(
-            &[
-                extra_meta6_literal_u64.to_le_bytes().as_ref(),
-                extra_meta2.pubkey.as_ref(),
-                check_extra_meta5_pubkey.as_ref(), // The first PDA should be at index 4
-            ],
-            &program_id,
-        )
-        .0;
-
-        let test_other_ix_check_metas = vec![
-            extra_meta1,
-            extra_meta2,
-            extra_meta3,
-            extra_meta4,
-            AccountMeta::new(check_extra_meta5_pubkey, false),
-            AccountMeta::new(check_extra_meta6_pubkey, false),
-            AccountMeta::new(instruction_key_data_pubkey_arg, false),
-        ];
-
-        assert_eq!(
-            instruction.accounts.get(4).unwrap().pubkey,
-            check_extra_meta5_pubkey,
-        );
-        assert_eq!(
-            instruction.accounts.get(5).unwrap().pubkey,
-            check_extra_meta6_pubkey,
-        );
-        assert_eq!(
-            instruction.accounts.get(6).unwrap().pubkey,
-            instruction_key_data_pubkey_arg,
-        );
-        assert_eq!(instruction.accounts, test_other_ix_check_metas,);
-    }
-
-    #[tokio::test]
-    async fn cpi_instruction() {
-        // Say we have a program that CPIs to another program.
-        //
-        // Say that _other_ program will need extra account infos.
-
-        // This will be our program
-        let program_id = Pubkey::new_unique();
-        let owner = Pubkey::new_unique();
-
-        // Some seeds used by the program for PDAs
-        let required_pda1_literal_string = "required_pda1";
-        let required_pda2_literal_u32 = 4u32;
-        let required_key_data_instruction_data = Pubkey::new_unique();
-
-        // Define instruction data
-        //  - 0: u8
-        //  - 1-8: [u8; 8]
-        //  - 9-16: u64
-        let instruction_u8array_arg = [1, 2, 3, 4, 5, 6, 7, 8];
-        let instruction_u64_arg = 208u64;
-        let mut instruction_data = vec![0];
-        instruction_data.extend_from_slice(&instruction_u8array_arg);
-        instruction_data.extend_from_slice(instruction_u64_arg.to_le_bytes().as_ref());
-        instruction_data.extend_from_slice(required_key_data_instruction_data.as_ref());
-
-        // Define known instruction accounts
-        let ix_accounts = vec![
-            AccountMeta::new(Pubkey::new_unique(), false),
-            AccountMeta::new(Pubkey::new_unique(), false),
-        ];
-
-        // Define extra account metas required by the program we will CPI to
-        let extra_meta1 = AccountMeta::new(Pubkey::new_unique(), false);
-        let extra_meta2 = AccountMeta::new(Pubkey::new_unique(), true);
-        let extra_meta3 = AccountMeta::new_readonly(Pubkey::new_unique(), false);
-        let required_accounts = [
-            ExtraAccountMeta::from(&extra_meta1),
-            ExtraAccountMeta::from(&extra_meta2),
-            ExtraAccountMeta::from(&extra_meta3),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: required_pda1_literal_string.as_bytes().to_vec(),
-                    },
-                    Seed::InstructionData {
-                        index: 1,
-                        length: 8, // [u8; 8]
-                    },
-                    Seed::AccountKey { index: 1 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: required_pda2_literal_u32.to_le_bytes().to_vec(),
-                    },
-                    Seed::InstructionData {
-                        index: 9,
-                        length: 8, // u64
-                    },
-                    Seed::AccountKey { index: 5 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::InstructionData {
-                        index: 0,
-                        length: 1, // u8
-                    },
-                    Seed::AccountData {
-                        account_index: 2,
-                        data_index: 0,
-                        length: 8,
-                    },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::AccountData {
-                        account_index: 5,
-                        data_index: 4,
-                        length: 4,
-                    }, // This one is a PDA!
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey_data(
-                &PubkeyData::InstructionData { index: 17 },
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey_data(
-                &PubkeyData::AccountData {
-                    account_index: 6,
-                    data_index: 0,
-                },
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey_data(
-                &PubkeyData::AccountData {
-                    account_index: 7,
-                    data_index: 8,
-                },
-                false,
-                true,
-            )
-            .unwrap(),
-        ];
-
-        // Now here we're going to build the list of account infos
-        // We'll need to include:
-        //  - The instruction account infos for the program to CPI to
-        //  - The extra account infos for the program to CPI to
-        //  - Some other arbitrary account infos our program may use
-
-        // First we need to manually derive each PDA
-        let check_required_pda1_pubkey = Pubkey::find_program_address(
-            &[
-                required_pda1_literal_string.as_bytes(),
-                &instruction_u8array_arg,
-                ix_accounts.get(1).unwrap().pubkey.as_ref(), // The second account
-            ],
-            &program_id,
-        )
-        .0;
-        let check_required_pda2_pubkey = Pubkey::find_program_address(
-            &[
-                required_pda2_literal_u32.to_le_bytes().as_ref(),
-                instruction_u64_arg.to_le_bytes().as_ref(),
-                check_required_pda1_pubkey.as_ref(), // The first PDA should be at index 5
-            ],
-            &program_id,
-        )
-        .0;
-        let check_required_pda3_pubkey = Pubkey::find_program_address(
-            &[
-                &[0],    // Instruction "discriminator" (u8)
-                &[8; 8], // The first 8 bytes of the data for account at index 2 (extra account 1)
-            ],
-            &program_id,
-        )
-        .0;
-        let check_required_pda4_pubkey = Pubkey::find_program_address(
-            &[
-                &[7; 4], /* 4 bytes starting at index 4 of the data for account at index 5 (extra
-                         * pda 1) */
-            ],
-            &program_id,
-        )
-        .0;
-        let check_key_data1_pubkey = required_key_data_instruction_data;
-        let check_key_data2_pubkey = Pubkey::new_from_array([8; 32]);
-        let check_key_data3_pubkey = Pubkey::new_from_array([9; 32]);
-
-        // The instruction account infos for the program to CPI to
-        let pubkey_ix_1 = ix_accounts.first().unwrap().pubkey;
-        let mut lamports_ix_1 = 0;
-        let mut data_ix_1 = [];
-        let pubkey_ix_2 = ix_accounts.get(1).unwrap().pubkey;
-        let mut lamports_ix_2 = 0;
-        let mut data_ix_2 = [];
-
-        // The extra account infos for the program to CPI to
-        let mut lamports1 = 0;
-        let mut data1 = [8; 12];
-        let mut lamports2 = 0;
-        let mut data2 = [];
-        let mut lamports3 = 0;
-        let mut data3 = [];
-        let mut lamports_pda1 = 0;
-        let mut data_pda1 = [7; 12];
-        let mut lamports_pda2 = 0;
-        let mut data_pda2 = [8; 32];
-        let mut lamports_pda3 = 0;
-        let mut data_pda3 = [0; 40];
-        data_pda3[8..].copy_from_slice(&[9; 32]); // Add pubkey data for pubkey data pubkey 3.
-        let mut lamports_pda4 = 0;
-        let mut data_pda4 = [];
-        let mut data_key_data1 = [];
-        let mut lamports_key_data1 = 0;
-        let mut data_key_data2 = [];
-        let mut lamports_key_data2 = 0;
-        let mut data_key_data3 = [];
-        let mut lamports_key_data3 = 0;
-
-        // Some other arbitrary account infos our program may use
-        let pubkey_arb_1 = Pubkey::new_unique();
-        let mut lamports_arb_1 = 0;
-        let mut data_arb_1 = [];
-        let pubkey_arb_2 = Pubkey::new_unique();
-        let mut lamports_arb_2 = 0;
-        let mut data_arb_2 = [];
-
-        let all_account_infos = [
-            AccountInfo::new(
-                &pubkey_ix_1,
-                ix_accounts.first().unwrap().is_signer,
-                ix_accounts.first().unwrap().is_writable,
-                &mut lamports_ix_1,
-                &mut data_ix_1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey_ix_2,
-                ix_accounts.get(1).unwrap().is_signer,
-                ix_accounts.get(1).unwrap().is_writable,
-                &mut lamports_ix_2,
-                &mut data_ix_2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &extra_meta1.pubkey,
-                required_accounts.first().unwrap().is_signer.into(),
-                required_accounts.first().unwrap().is_writable.into(),
-                &mut lamports1,
-                &mut data1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &extra_meta2.pubkey,
-                required_accounts.get(1).unwrap().is_signer.into(),
-                required_accounts.get(1).unwrap().is_writable.into(),
-                &mut lamports2,
-                &mut data2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &extra_meta3.pubkey,
-                required_accounts.get(2).unwrap().is_signer.into(),
-                required_accounts.get(2).unwrap().is_writable.into(),
-                &mut lamports3,
-                &mut data3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_required_pda1_pubkey,
-                required_accounts.get(3).unwrap().is_signer.into(),
-                required_accounts.get(3).unwrap().is_writable.into(),
-                &mut lamports_pda1,
-                &mut data_pda1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_required_pda2_pubkey,
-                required_accounts.get(4).unwrap().is_signer.into(),
-                required_accounts.get(4).unwrap().is_writable.into(),
-                &mut lamports_pda2,
-                &mut data_pda2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_required_pda3_pubkey,
-                required_accounts.get(5).unwrap().is_signer.into(),
-                required_accounts.get(5).unwrap().is_writable.into(),
-                &mut lamports_pda3,
-                &mut data_pda3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_required_pda4_pubkey,
-                required_accounts.get(6).unwrap().is_signer.into(),
-                required_accounts.get(6).unwrap().is_writable.into(),
-                &mut lamports_pda4,
-                &mut data_pda4,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_key_data1_pubkey,
-                required_accounts.get(7).unwrap().is_signer.into(),
-                required_accounts.get(7).unwrap().is_writable.into(),
-                &mut lamports_key_data1,
-                &mut data_key_data1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_key_data2_pubkey,
-                required_accounts.get(8).unwrap().is_signer.into(),
-                required_accounts.get(8).unwrap().is_writable.into(),
-                &mut lamports_key_data2,
-                &mut data_key_data2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &check_key_data3_pubkey,
-                required_accounts.get(9).unwrap().is_signer.into(),
-                required_accounts.get(9).unwrap().is_writable.into(),
-                &mut lamports_key_data3,
-                &mut data_key_data3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey_arb_1,
-                false,
-                true,
-                &mut lamports_arb_1,
-                &mut data_arb_1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            AccountInfo::new(
-                &pubkey_arb_2,
-                false,
-                true,
-                &mut lamports_arb_2,
-                &mut data_arb_2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-        ];
-
-        // Let's use a mock RPC and set up a test instruction to check the CPI
-        // instruction against later
-        let rpc_account_infos = all_account_infos.clone();
-        let mock_rpc = MockRpc::setup(&rpc_account_infos);
-
-        let account_size = ExtraAccountMetaList::size_of(required_accounts.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &required_accounts).unwrap();
-
-        let mut instruction =
-            Instruction::new_with_bytes(program_id, &instruction_data, ix_accounts.clone());
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            &buffer,
-        )
-        .await
-        .unwrap();
-
-        // Perform the account resolution for the CPI instruction
-
-        // Create the instruction itself
-        let mut cpi_instruction =
-            Instruction::new_with_bytes(program_id, &instruction_data, ix_accounts);
-
-        // Start with the known account infos
-        let mut cpi_account_infos =
-            vec![all_account_infos[0].clone(), all_account_infos[1].clone()];
-
-        // Mess up the ordering of the account infos to make it harder!
-        let mut messed_account_infos = all_account_infos.clone();
-        messed_account_infos.swap(0, 4);
-        messed_account_infos.swap(1, 2);
-        messed_account_infos.swap(3, 4);
-        messed_account_infos.swap(5, 6);
-        messed_account_infos.swap(8, 7);
-
-        // Resolve the rest!
-        ExtraAccountMetaList::add_to_cpi_instruction::<TestInstruction>(
-            &mut cpi_instruction,
-            &mut cpi_account_infos,
-            &buffer,
-            &messed_account_infos,
-        )
-        .unwrap();
-
-        // Our CPI instruction should match the check instruction.
-        assert_eq!(cpi_instruction, instruction);
-
-        // CPI account infos should have the instruction account infos
-        // and the extra required account infos from the validation account,
-        // and they should be in the correct order.
-        // Note: The two additional arbitrary account infos for the currently
-        // executing program won't be present in the CPI instruction's account
-        // infos, so we will omit them (hence the `..9`).
-        let check_account_infos = &all_account_infos[..12];
-        assert_eq!(cpi_account_infos.len(), check_account_infos.len());
-        for (a, b) in std::iter::zip(cpi_account_infos, check_account_infos) {
-            assert_eq!(a.key, b.key);
-            assert_eq!(a.is_signer, b.is_signer);
-            assert_eq!(a.is_writable, b.is_writable);
-        }
-    }
-
-    async fn update_and_assert_metas(
-        program_id: Pubkey,
-        buffer: &mut Vec<u8>,
-        updated_metas: &[ExtraAccountMeta],
-        check_metas: &[AccountMeta],
-    ) {
-        // resize buffer if necessary
-        let account_size = ExtraAccountMetaList::size_of(updated_metas.len()).unwrap();
-        if account_size > buffer.len() {
-            buffer.resize(account_size, 0);
-        }
-
-        // update
-        ExtraAccountMetaList::update::<TestInstruction>(buffer, updated_metas).unwrap();
-
-        // retrieve metas and assert
-        let state = TlvStateBorrowed::unpack(buffer).unwrap();
-        let unpacked_metas_pod =
-            ExtraAccountMetaList::unpack_with_tlv_state::<TestInstruction>(&state).unwrap();
-        let unpacked_metas = unpacked_metas_pod.data();
-        assert_eq!(
-            unpacked_metas, updated_metas,
-            "The ExtraAccountMetas in the buffer should match the expected ones."
-        );
-
-        let mock_rpc = MockRpc::setup(&[]);
-
-        let mut instruction = Instruction::new_with_bytes(program_id, &[], vec![]);
-        ExtraAccountMetaList::add_to_instruction::<TestInstruction, _, _>(
-            &mut instruction,
-            |pubkey| mock_rpc.get_account_data(pubkey),
-            buffer,
-        )
-        .await
-        .unwrap();
-
-        assert_eq!(instruction.accounts, check_metas,);
-    }
-
-    #[tokio::test]
-    async fn update_extra_account_meta_list() {
-        let program_id = Pubkey::new_unique();
-
-        // Create list of initial metas
-        let initial_metas = [
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), false, true).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), true, false).unwrap(),
-        ];
-
-        // initialize
-        let initial_account_size = ExtraAccountMetaList::size_of(initial_metas.len()).unwrap();
-        let mut buffer = vec![0; initial_account_size];
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &initial_metas).unwrap();
-
-        // Create updated metas list of the same size
-        let updated_metas_1 = [
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), true, true).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), false, false).unwrap(),
-        ];
-        let check_metas_1 = updated_metas_1
-            .iter()
-            .map(|e| AccountMeta::try_from(e).unwrap())
-            .collect::<Vec<_>>();
-        update_and_assert_metas(program_id, &mut buffer, &updated_metas_1, &check_metas_1).await;
-
-        // Create updated and larger list of metas
-        let updated_metas_2 = [
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), true, true).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), false, false).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), false, true).unwrap(),
-        ];
-        let check_metas_2 = updated_metas_2
-            .iter()
-            .map(|e| AccountMeta::try_from(e).unwrap())
-            .collect::<Vec<_>>();
-        update_and_assert_metas(program_id, &mut buffer, &updated_metas_2, &check_metas_2).await;
-
-        // Create updated and smaller list of metas
-        let updated_metas_3 =
-            [ExtraAccountMeta::new_with_pubkey(&Pubkey::new_unique(), true, true).unwrap()];
-        let check_metas_3 = updated_metas_3
-            .iter()
-            .map(|e| AccountMeta::try_from(e).unwrap())
-            .collect::<Vec<_>>();
-        update_and_assert_metas(program_id, &mut buffer, &updated_metas_3, &check_metas_3).await;
-
-        // Create updated list of metas with a simple PDA
-        let seed_pubkey = Pubkey::new_unique();
-        let updated_metas_4 = [
-            ExtraAccountMeta::new_with_pubkey(&seed_pubkey, true, true).unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: b"seed-prefix".to_vec(),
-                    },
-                    Seed::AccountKey { index: 0 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-        ];
-        let simple_pda = Pubkey::find_program_address(
-            &[
-                b"seed-prefix",       // Literal prefix
-                seed_pubkey.as_ref(), // Account at index 0
-            ],
-            &program_id,
-        )
-        .0;
-        let check_metas_4 = [
-            AccountMeta::new(seed_pubkey, true),
-            AccountMeta::new(simple_pda, false),
-        ];
-
-        update_and_assert_metas(program_id, &mut buffer, &updated_metas_4, &check_metas_4).await;
-    }
-
-    #[test]
-    fn check_account_infos_test() {
-        let program_id = Pubkey::new_unique();
-        let owner = Pubkey::new_unique();
-
-        // Create a list of required account metas
-        let pubkey1 = Pubkey::new_unique();
-        let pubkey2 = Pubkey::new_unique();
-        let required_accounts = [
-            ExtraAccountMeta::new_with_pubkey(&pubkey1, false, true).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&pubkey2, false, false).unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: b"lit_seed".to_vec(),
-                    },
-                    Seed::InstructionData {
-                        index: 0,
-                        length: 4,
-                    },
-                    Seed::AccountKey { index: 0 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey_data(
-                &PubkeyData::InstructionData { index: 8 },
-                false,
-                true,
-            )
-            .unwrap(),
-        ];
-
-        // Create the validation data
-        let account_size = ExtraAccountMetaList::size_of(required_accounts.len()).unwrap();
-        let mut buffer = vec![0; account_size];
-        ExtraAccountMetaList::init::<TestInstruction>(&mut buffer, &required_accounts).unwrap();
-
-        // Create the instruction data
-        let mut instruction_data = vec![0, 1, 2, 3, 4, 5, 6, 7];
-        let key_data_pubkey = Pubkey::new_unique();
-        instruction_data.extend_from_slice(key_data_pubkey.as_ref());
-
-        // Set up a list of the required accounts as account infos,
-        // with two instruction accounts
-        let pubkey_ix_1 = Pubkey::new_unique();
-        let mut lamports_ix_1 = 0;
-        let mut data_ix_1 = [];
-        let pubkey_ix_2 = Pubkey::new_unique();
-        let mut lamports_ix_2 = 0;
-        let mut data_ix_2 = [];
-        let mut lamports1 = 0;
-        let mut data1 = [];
-        let mut lamports2 = 0;
-        let mut data2 = [];
-        let mut lamports3 = 0;
-        let mut data3 = [];
-        let mut lamports4 = 0;
-        let mut data4 = [];
-        let pda = Pubkey::find_program_address(
-            &[b"lit_seed", &instruction_data[..4], pubkey_ix_1.as_ref()],
-            &program_id,
-        )
-        .0;
-        let account_infos = [
-            // Instruction account 1
-            AccountInfo::new(
-                &pubkey_ix_1,
-                false,
-                true,
-                &mut lamports_ix_1,
-                &mut data_ix_1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            // Instruction account 2
-            AccountInfo::new(
-                &pubkey_ix_2,
-                false,
-                true,
-                &mut lamports_ix_2,
-                &mut data_ix_2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            // Required account 1
-            AccountInfo::new(
-                &pubkey1,
-                false,
-                true,
-                &mut lamports1,
-                &mut data1,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            // Required account 2
-            AccountInfo::new(
-                &pubkey2,
-                false,
-                false,
-                &mut lamports2,
-                &mut data2,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            // Required account 3 (PDA)
-            AccountInfo::new(
-                &pda,
-                false,
-                true,
-                &mut lamports3,
-                &mut data3,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-            // Required account 4 (pubkey data)
-            AccountInfo::new(
-                &key_data_pubkey,
-                false,
-                true,
-                &mut lamports4,
-                &mut data4,
-                &owner,
-                false,
-                Epoch::default(),
-            ),
-        ];
-
-        // Create another list of account infos to intentionally mess up
-        let mut messed_account_infos = account_infos.clone().to_vec();
-        messed_account_infos.swap(0, 2);
-        messed_account_infos.swap(1, 4);
-        messed_account_infos.swap(3, 2);
-        messed_account_infos.swap(5, 4);
-
-        // Account info check should fail for the messed list
-        assert_eq!(
-            ExtraAccountMetaList::check_account_infos::<TestInstruction>(
-                &messed_account_infos,
-                &instruction_data,
-                &program_id,
-                &buffer,
-            )
-            .unwrap_err(),
-            AccountResolutionError::IncorrectAccount.into(),
-        );
-
-        // Account info check should pass for the correct list
-        assert_eq!(
-            ExtraAccountMetaList::check_account_infos::<TestInstruction>(
-                &account_infos,
-                &instruction_data,
-                &program_id,
-                &buffer,
-            ),
-            Ok(()),
-        );
-    }
-}
diff --git a/libraries/type-length-value-derive-test/Cargo.toml b/libraries/type-length-value-derive-test/Cargo.toml
deleted file mode 100644
index 18070cd7a5b..00000000000
--- a/libraries/type-length-value-derive-test/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "spl-type-length-value-derive-test"
-version = "0.1.0"
-description = "Testing Derive Macro Library for SPL Type Length Value traits"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dev-dependencies]
-borsh = "1.5.1"
-solana-program = "1.16"
-spl-discriminator = { version = "0.2.2", path = "../discriminator" }
-spl-type-length-value = { version = "0.4.3", path = "../type-length-value", features = [
-  "derive",
-] }
diff --git a/libraries/type-length-value-derive-test/src/lib.rs b/libraries/type-length-value-derive-test/src/lib.rs
deleted file mode 100644
index 2d0310383ca..00000000000
--- a/libraries/type-length-value-derive-test/src/lib.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//! Test crate to avoid making `borsh` a direct dependency of
-//! `spl-type-length-value`. You can't use a derive macro from within the same
-//! crate that the macro is defined, so we need this extra crate for just
-//! testing the macro itself.
-
-#[cfg(test)]
-pub mod test {
-    use {
-        borsh::{BorshDeserialize, BorshSerialize},
-        solana_program::borsh1::{get_instance_packed_len, try_from_slice_unchecked},
-        spl_discriminator::SplDiscriminate,
-        spl_type_length_value::{variable_len_pack::VariableLenPack, SplBorshVariableLenPack},
-    };
-
-    #[derive(
-        Clone,
-        Debug,
-        Default,
-        PartialEq,
-        BorshDeserialize,
-        BorshSerialize,
-        SplDiscriminate,
-        SplBorshVariableLenPack,
-    )]
-    #[discriminator_hash_input("vehicle::my_vehicle")]
-    pub struct Vehicle {
-        vin: [u8; 8],
-        plate: [u8; 7],
-    }
-
-    #[test]
-    fn test_derive() {
-        let vehicle = Vehicle {
-            vin: [0; 8],
-            plate: [0; 7],
-        };
-
-        assert_eq!(
-            get_instance_packed_len::<Vehicle>(&vehicle).unwrap(),
-            vehicle.get_packed_len().unwrap()
-        );
-
-        let dst1 = &mut [0u8; 15];
-        borsh::to_writer(&mut dst1[..], &vehicle).unwrap();
-
-        let dst2 = &mut [0u8; 15];
-        vehicle.pack_into_slice(&mut dst2[..]).unwrap();
-
-        assert_eq!(dst1, dst2,);
-
-        let mut buffer = [0u8; 15];
-        buffer.copy_from_slice(&dst1[..]);
-
-        assert_eq!(
-            try_from_slice_unchecked::<Vehicle>(&buffer).unwrap(),
-            Vehicle::unpack_from_slice(&buffer).unwrap()
-        );
-    }
-}
diff --git a/libraries/type-length-value/Cargo.toml b/libraries/type-length-value/Cargo.toml
deleted file mode 100644
index bf630f97c9a..00000000000
--- a/libraries/type-length-value/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "spl-type-length-value"
-version = "0.4.3"
-description = "Solana Program Library Type-Length-Value Management"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-exclude = ["js/**"]
-
-[features]
-derive = ["dep:spl-type-length-value-derive"]
-
-[dependencies]
-bytemuck = { version = "1.16.0", features = ["derive"] }
-solana-program = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2", path = "../discriminator" }
-spl-program-error = { version = "0.4.0", path = "../program-error" }
-spl-type-length-value-derive = { version = "0.1", path = "./derive", optional = true }
-spl-pod = { version = "0.2.2", path = "../pod" }
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/libraries/type-length-value/README.md b/libraries/type-length-value/README.md
deleted file mode 100644
index 24ccf8aff95..00000000000
--- a/libraries/type-length-value/README.md
+++ /dev/null
@@ -1,183 +0,0 @@
-# Type-Length-Value
-
-Library with utilities for working with Type-Length-Value structures.
-
-## Example usage
-
-This simple examples defines a zero-copy type with its discriminator.
-
-```rust
-use {
-    borsh::{BorshSerialize, BorshDeserialize},
-    bytemuck::{Pod, Zeroable},
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate}
-    spl_type_length_value::{
-        state::{TlvState, TlvStateBorrowed, TlvStateMut}
-    },
-};
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-struct MyPodValue {
-    data: [u8; 32],
-}
-impl SplDiscriminate for MyPodValue {
-    // Give it a unique discriminator, can also be generated using a hash function
-    const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-}
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-struct MyOtherPodValue {
-    data: u8,
-}
-// Give this type a non-derivable implementation of `Default` to write some data
-impl Default for MyOtherPodValue {
-    fn default() -> Self {
-        Self {
-            data: 10,
-        }
-    }
-}
-impl SplDiscriminate for MyOtherPodValue {
-    // Some other unique discriminator
-    const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([2; ArrayDiscriminator::LENGTH]);
-}
-
-// Account will have two sets of `get_base_len()` (8-byte discriminator and 4-byte length),
-// and enough room for a `MyPodValue` and a `MyOtherPodValue`
-let account_size = TlvState::get_base_len() + std::mem::size_of::<MyPodValue>() + \
-    TlvState::get_base_len() + std::mem::size_of::<MyOtherPodValue>();
-
-// Buffer likely comes from a Solana `solana_program::account_info::AccountInfo`,
-// but this example just uses a vector.
-let mut buffer = vec![0; account_size];
-
-// Unpack the base buffer as a TLV structure
-let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-// Init and write default value
-// Note: you'll need to provide a boolean whether or not to allow repeating
-// values with the same TLV discriminator.
-// If set to false, this function will error when an existing entry is detected.
-let value = state.init_value::<MyPodValue>(false).unwrap();
-// Update it in-place
-value.data[0] = 1;
-
-// Init and write another default value
-// This time, we're going to allow repeating values.
-let other_value1 = state.init_value::<MyOtherPodValue>(true).unwrap();
-assert_eq!(other_value1.data, 10);
-// Update it in-place
-other_value1.data = 2;
-
-// Let's do it again, since we can now have repeating values!
-let other_value2 = state.init_value::<MyOtherPodValue>(true).unwrap();
-assert_eq!(other_value2.data, 10);
-// Update it in-place
-other_value2.data = 4;
-
-// Later on, to work with it again, since we did _not_ allow repeating entries,
-// we can just get the first value we encounter.
-let value = state.get_first_value_mut::<MyPodValue>().unwrap();
-
-// Or fetch it from an immutable buffer
-let state = TlvStateBorrowed::unpack(&buffer).unwrap();
-let value1 = state.get_first_value::<MyOtherPodValue>().unwrap();
-
-// Since we used repeating entries for `MyOtherPodValue`, we can grab either one by
-// its entry number
-let value1 = state.get_value_with_repetition::<MyOtherPodValue>(1).unwrap();
-let value2 = state.get_value_with_repetition::<MyOtherPodValue>(2).unwrap();
-
-```
-
-## Motivation
-
-The Solana blockchain exposes slabs of bytes to on-chain programs, allowing program
-writers to interpret these bytes and change them however they wish. Currently,
-programs interpret account bytes as being only of one type. For example, an token
-mint account is only ever a token mint, an AMM pool account is only ever an AMM pool,
-a token metadata account can only hold token metadata, etc.
-
-In a world of interfaces, a program will likely implement multiple interfaces.
-As a concrete and important example, imagine a token program where mints hold
-their own metadata. This means that a single account can be both a mint and
-metadata.
-
-To allow easy implementation of multiple interfaces, accounts must be able to
-hold multiple different types within one opaque slab of bytes. The
-[type-length-value](https://en.wikipedia.org/wiki/Type%E2%80%93length%E2%80%93value)
-scheme facilitates this exact case.
-
-## How it works
-
-This library allows for holding multiple disparate types within the same account
-by encoding the type, then length, then value.
-
-The type is an 8-byte `ArrayDiscriminator`, which can be set to anything.
-
-The length is a little-endian `u32`.
-
-The value is a slab of `length` bytes that can be used however a program desires.
-
-When searching through the buffer for a particular type, the library looks at
-the first 8-byte discriminator. If it's all zeroes, this means it's uninitialized.
-If not, it reads the next 4-byte length. If the discriminator matches, it returns
-the next `length` bytes. If not, it jumps ahead `length` bytes and reads the
-next 8-byte discriminator.
-
-## Serialization of variable-length types
-
-The initial example works using the `bytemuck` crate for zero-copy serialization
-and deserialization. It's possible to use Borsh by implementing the `VariableLenPack`
-trait on your type.
-
-```rust
-use {
-    borsh::{BorshDeserialize, BorshSerialize},
-    solana_program::borsh::{get_instance_packed_len, try_from_slice_unchecked},
-    spl_type_length_value::{
-        state::{TlvState, TlvStateMut},
-        variable_len_pack::VariableLenPack
-    },
-};
-#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize)]
-struct MyVariableLenType {
-    data: String, // variable length type
-}
-impl SplDiscriminate for MyVariableLenType {
-    const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([5; ArrayDiscriminator::LENGTH]);
-}
-impl VariableLenPack for MyVariableLenType {
-    fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-        borsh::to_writer(&mut dst[..], self).map_err(Into::into)
-    }
-
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        try_from_slice_unchecked(src).map_err(Into::into)
-    }
-
-    fn get_packed_len(&self) -> Result<usize, ProgramError> {
-        get_instance_packed_len(self).map_err(Into::into)
-    }
-}
-let initial_data = "This is a pretty cool test!";
-// Allocate exactly the right size for the string, can go bigger if desired
-let tlv_size = 4 + initial_data.len();
-let account_size = TlvState::get_base_len() + tlv_size;
-
-// Buffer likely comes from a Solana `solana_program::account_info::AccountInfo`,
-// but this example just uses a vector.
-let mut buffer = vec![0; account_size];
-let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-// No need to hold onto the bytes since we'll serialize back into the right place
-// For this example, let's _not_ allow repeating entries.
-let _ = state.alloc::<MyVariableLenType>(tlv_size, false).unwrap();
-let my_variable_len = MyVariableLenType {
-    data: initial_data.to_string()
-};
-state.pack_variable_len_value(&my_variable_len).unwrap();
-let deser = state.get_first_variable_len_value::<MyVariableLenType>().unwrap();
-assert_eq!(deser, my_variable_len);
-```
diff --git a/libraries/type-length-value/derive/Cargo.toml b/libraries/type-length-value/derive/Cargo.toml
deleted file mode 100644
index d0461352612..00000000000
--- a/libraries/type-length-value/derive/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "spl-type-length-value-derive"
-version = "0.1.0"
-description = "Derive Macro Library for SPL Type Length Value traits"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "2.0", features = ["full"] }
\ No newline at end of file
diff --git a/libraries/type-length-value/derive/src/builder.rs b/libraries/type-length-value/derive/src/builder.rs
deleted file mode 100644
index a11c5b6b109..00000000000
--- a/libraries/type-length-value/derive/src/builder.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-//! The actual token generator for the macro
-use {
-    proc_macro2::{Span, TokenStream},
-    quote::{quote, ToTokens},
-    syn::{parse::Parse, Generics, Ident, Item, ItemEnum, ItemStruct, WhereClause},
-};
-
-pub struct SplBorshVariableLenPackBuilder {
-    /// The struct/enum identifier
-    pub ident: Ident,
-    /// The item's generic arguments (if any)
-    pub generics: Generics,
-    /// The item's where clause for generics (if any)
-    pub where_clause: Option<WhereClause>,
-}
-
-impl TryFrom<ItemEnum> for SplBorshVariableLenPackBuilder {
-    type Error = syn::Error;
-
-    fn try_from(item_enum: ItemEnum) -> Result<Self, Self::Error> {
-        let ident = item_enum.ident;
-        let where_clause = item_enum.generics.where_clause.clone();
-        let generics = item_enum.generics;
-        Ok(Self {
-            ident,
-            generics,
-            where_clause,
-        })
-    }
-}
-
-impl TryFrom<ItemStruct> for SplBorshVariableLenPackBuilder {
-    type Error = syn::Error;
-
-    fn try_from(item_struct: ItemStruct) -> Result<Self, Self::Error> {
-        let ident = item_struct.ident;
-        let where_clause = item_struct.generics.where_clause.clone();
-        let generics = item_struct.generics;
-        Ok(Self {
-            ident,
-            generics,
-            where_clause,
-        })
-    }
-}
-
-impl Parse for SplBorshVariableLenPackBuilder {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let item = Item::parse(input)?;
-        match item {
-            Item::Enum(item_enum) => item_enum.try_into(),
-            Item::Struct(item_struct) => item_struct.try_into(),
-            _ => {
-                return Err(syn::Error::new(
-                    Span::call_site(),
-                    "Only enums and structs are supported",
-                ))
-            }
-        }
-        .map_err(|e| syn::Error::new(input.span(), format!("Failed to parse item: {}", e)))
-    }
-}
-
-impl ToTokens for SplBorshVariableLenPackBuilder {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        tokens.extend::<TokenStream>(self.into());
-    }
-}
-
-impl From<&SplBorshVariableLenPackBuilder> for TokenStream {
-    fn from(builder: &SplBorshVariableLenPackBuilder) -> Self {
-        let ident = &builder.ident;
-        let generics = &builder.generics;
-        let where_clause = &builder.where_clause;
-        quote! {
-            impl #generics spl_type_length_value::variable_len_pack::VariableLenPack for #ident #generics #where_clause {
-                fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), solana_program::program_error::ProgramError> {
-                    borsh::to_writer(&mut dst[..], self).map_err(Into::into)
-                }
-
-                fn unpack_from_slice(src: &[u8]) -> Result<Self, solana_program::program_error::ProgramError> {
-                    solana_program::borsh1::try_from_slice_unchecked(src).map_err(Into::into)
-                }
-
-                fn get_packed_len(&self) -> Result<usize, solana_program::program_error::ProgramError> {
-                    solana_program::borsh1::get_instance_packed_len(self).map_err(Into::into)
-                }
-            }
-        }
-    }
-}
diff --git a/libraries/type-length-value/derive/src/lib.rs b/libraries/type-length-value/derive/src/lib.rs
deleted file mode 100644
index b3f0f12a297..00000000000
--- a/libraries/type-length-value/derive/src/lib.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Crate defining a derive macro for a basic borsh implementation of
-//! the trait `VariableLenPack`.
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-extern crate proc_macro;
-
-mod builder;
-
-use {
-    builder::SplBorshVariableLenPackBuilder, proc_macro::TokenStream, quote::ToTokens,
-    syn::parse_macro_input,
-};
-
-/// Derive macro to add `VariableLenPack` trait for borsh-implemented types
-#[proc_macro_derive(SplBorshVariableLenPack)]
-pub fn spl_borsh_variable_len_pack(input: TokenStream) -> TokenStream {
-    parse_macro_input!(input as SplBorshVariableLenPackBuilder)
-        .to_token_stream()
-        .into()
-}
diff --git a/libraries/type-length-value/js/.eslintignore b/libraries/type-length-value/js/.eslintignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/libraries/type-length-value/js/.eslintignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/libraries/type-length-value/js/.eslintrc b/libraries/type-length-value/js/.eslintrc
deleted file mode 100644
index 5aef10a4729..00000000000
--- a/libraries/type-length-value/js/.eslintrc
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "root": true,
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended",
-        "plugin:require-extensions/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier",
-        "require-extensions"
-    ],
-    "rules": {
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/consistent-type-imports": "error"
-    },
-    "overrides": [
-        {
-            "files": [
-                "examples/**/*",
-                "test/**/*"
-            ],
-            "rules": {
-                "require-extensions/require-extensions": "off",
-                "require-extensions/require-index": "off"
-            }
-        }
-    ]
-}
diff --git a/libraries/type-length-value/js/.gitignore b/libraries/type-length-value/js/.gitignore
deleted file mode 100644
index 21f33db819c..00000000000
--- a/libraries/type-length-value/js/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.idea
-.vscode
-.DS_Store
-
-node_modules
-
-pnpm-lock.yaml
-yarn.lock
-
-docs
-lib
-test-ledger
-*.tsbuildinfo
diff --git a/libraries/type-length-value/js/.mocharc.json b/libraries/type-length-value/js/.mocharc.json
deleted file mode 100644
index 451c14c3016..00000000000
--- a/libraries/type-length-value/js/.mocharc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "extension": ["ts"],
-    "node-option": ["experimental-specifier-resolution=node", "loader=ts-node/esm"],
-    "timeout": 5000
-}
diff --git a/libraries/type-length-value/js/.nojekyll b/libraries/type-length-value/js/.nojekyll
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/libraries/type-length-value/js/.prettierignore b/libraries/type-length-value/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/libraries/type-length-value/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/libraries/type-length-value/js/.prettierrc b/libraries/type-length-value/js/.prettierrc
deleted file mode 100644
index b9ce4c1923a..00000000000
--- a/libraries/type-length-value/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "printWidth": 120,
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}
\ No newline at end of file
diff --git a/libraries/type-length-value/js/LICENSE b/libraries/type-length-value/js/LICENSE
deleted file mode 100644
index d6456956733..00000000000
--- a/libraries/type-length-value/js/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/libraries/type-length-value/js/README.md b/libraries/type-length-value/js/README.md
deleted file mode 100644
index 69db493a984..00000000000
--- a/libraries/type-length-value/js/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Type-Length-Value-js
-
-Library with utilities for working with Type-Length-Value structures in js.
-
-## Example usage
-
-```ts
-import { TlvState, SplDiscriminator } from '@solana/spl-type-length-value';
-
-const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-const discriminator = splDiscriminate("<discriminator-hash-input>", discriminatorSize);
-
-const firstValue = tlv.firstBytes(discriminator);
-
-const allValues = tlv.bytesRepeating(discriminator);
-
-const firstThreeValues = tlv.bytesRepeating(discriminator, 3);
-```
diff --git a/libraries/type-length-value/js/package.json b/libraries/type-length-value/js/package.json
deleted file mode 100644
index 7f098b65453..00000000000
--- a/libraries/type-length-value/js/package.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
-    "name": "@solana/spl-type-length-value",
-    "description": "SPL Type Length Value Library",
-    "version": "0.1.0",
-    "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "repository": "https://github.com/solana-labs/solana-program-library",
-    "license": "Apache-2.0",
-    "type": "module",
-    "sideEffects": false,
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "lib",
-        "src",
-        "LICENSE",
-        "README.md"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "./lib/cjs/index.js",
-    "module": "./lib/esm/index.js",
-    "types": "./lib/types/index.d.ts",
-    "exports": {
-        "types": "./lib/types/index.d.ts",
-        "require": "./lib/cjs/index.js",
-        "import": "./lib/esm/index.js"
-    },
-    "scripts": {
-        "build": "tsc --build --verbose tsconfig.all.json",
-        "clean": "shx rm -rf lib **/*.tsbuildinfo || true",
-        "deploy": "npm run deploy:docs",
-        "deploy:docs": "npm run docs && gh-pages --dest type-length-value/js --dist docs --dotfiles",
-        "docs": "shx rm -rf docs && typedoc && shx cp .nojekyll docs/",
-        "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-        "lint": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}' && eslint --max-warnings 0 .",
-        "lint:fix": "npm run fmt && eslint --fix .",
-        "nuke": "shx rm -rf node_modules package-lock.json || true",
-        "postbuild": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json",
-        "reinstall": "npm run nuke && npm install",
-        "release": "npm run clean && npm run build",
-        "test": "mocha test",
-        "watch": "tsc --build --verbose --watch tsconfig.all.json"
-    },
-    "dependencies": {
-        "buffer": "^6.0.3"
-    },
-    "devDependencies": {
-        "@types/chai": "^4.3.16",
-        "@types/mocha": "^10.0.6",
-        "@types/node": "^20.14.5",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
-        "chai": "^5.1.1",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "eslint-plugin-require-extensions": "^0.1.1",
-        "gh-pages": "^6.1.1",
-        "mocha": "^10.4.0",
-        "prettier": "^3.3.2",
-        "shx": "^0.3.4",
-        "ts-node": "^10.9.2",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
-    }
-}
diff --git a/libraries/type-length-value/js/src/errors.ts b/libraries/type-length-value/js/src/errors.ts
deleted file mode 100644
index 1b128cb8b92..00000000000
--- a/libraries/type-length-value/js/src/errors.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/** Base class for errors */
-export abstract class TlvError extends Error {
-    constructor(message?: string) {
-        super(message);
-    }
-}
-
-/** Thrown if the byte length of an tlv buffer doesn't match the expected size */
-export class TlvInvalidAccountDataError extends TlvError {
-    name = 'TlvInvalidAccountDataError';
-}
diff --git a/libraries/type-length-value/js/src/index.ts b/libraries/type-length-value/js/src/index.ts
deleted file mode 100644
index 68afecb9af3..00000000000
--- a/libraries/type-length-value/js/src/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './splDiscriminate.js';
-export * from './tlvState.js';
-export * from './errors.js';
diff --git a/libraries/type-length-value/js/src/splDiscriminate.ts b/libraries/type-length-value/js/src/splDiscriminate.ts
deleted file mode 100644
index 8590503504a..00000000000
--- a/libraries/type-length-value/js/src/splDiscriminate.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { createHash } from 'crypto';
-
-export const splDiscriminate = (discriminator: string, length = 8): Buffer => {
-    const digest = createHash('sha256').update(discriminator).digest();
-    return digest.subarray(0, length);
-};
diff --git a/libraries/type-length-value/js/src/tlvState.ts b/libraries/type-length-value/js/src/tlvState.ts
deleted file mode 100644
index 816a242843d..00000000000
--- a/libraries/type-length-value/js/src/tlvState.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-import { TlvInvalidAccountDataError } from './errors.js';
-
-export type LengthSize = 1 | 2 | 4 | 8;
-
-export type Discriminator = Uint8Array;
-
-export class TlvState {
-    private readonly tlvData: Buffer;
-    private readonly discriminatorSize: number;
-    private readonly lengthSize: LengthSize;
-
-    public constructor(buffer: Buffer, discriminatorSize = 2, lengthSize: LengthSize = 2, offset: number = 0) {
-        this.tlvData = buffer.subarray(offset);
-        this.discriminatorSize = discriminatorSize;
-        this.lengthSize = lengthSize;
-    }
-
-    /**
-     * Get the raw tlv data
-     *
-     * @return the raw tlv data
-     */
-    public get data(): Buffer {
-        return this.tlvData;
-    }
-
-    private readEntryLength<T>(size: LengthSize, offset: number, constructor: (x: number | bigint) => T): T {
-        switch (size) {
-            case 1:
-                return constructor(this.tlvData.readUInt8(offset));
-            case 2:
-                return constructor(this.tlvData.readUInt16LE(offset));
-            case 4:
-                return constructor(this.tlvData.readUInt32LE(offset));
-            case 8:
-                return constructor(this.tlvData.readBigUInt64LE(offset));
-        }
-    }
-
-    /**
-     * Get a single entry from the tlv data. This function returns the first entry with the given type.
-     *
-     * @param type the type of the entry to get
-     *
-     * @return the entry from the tlv data or null
-     */
-    public firstBytes(discriminator: Discriminator): Buffer | null {
-        const entries = this.bytesRepeating(discriminator, 1);
-        return entries.length > 0 ? entries[0] : null;
-    }
-
-    /**
-     * Get a multiple entries from the tlv data. This function returns `count` or less entries with the given type.
-     *
-     * @param type the type of the entry to get
-     * @param count the number of entries to get (0 for all entries)
-     *
-     * @return the entry from the tlv data or null
-     */
-    public bytesRepeating(discriminator: Discriminator, count = 0): Buffer[] {
-        const entries: Buffer[] = [];
-        let offset = 0;
-        while (offset < this.tlvData.length) {
-            if (offset + this.discriminatorSize + this.lengthSize > this.tlvData.length) {
-                throw new TlvInvalidAccountDataError();
-            }
-            const type = this.tlvData.subarray(offset, offset + this.discriminatorSize);
-            offset += this.discriminatorSize;
-            const entryLength = this.readEntryLength(this.lengthSize, offset, Number);
-            offset += this.lengthSize;
-            if (offset + entryLength > this.tlvData.length) {
-                throw new TlvInvalidAccountDataError();
-            }
-            if (type.equals(discriminator)) {
-                entries.push(this.tlvData.subarray(offset, offset + entryLength));
-            }
-            if (count > 0 && entries.length >= count) {
-                break;
-            }
-            offset += entryLength;
-        }
-        return entries;
-    }
-
-    /**
-     * Get all the discriminators from the tlv data. This function will return a type multiple times if it occurs multiple times in the tlv data.
-     *
-     * @return a list of the discriminators.
-     */
-    public discriminators(): Buffer[] {
-        const discriminators: Buffer[] = [];
-        let offset = 0;
-        while (offset < this.tlvData.length) {
-            if (offset + this.discriminatorSize + this.lengthSize > this.tlvData.length) {
-                throw new TlvInvalidAccountDataError();
-            }
-            const type = this.tlvData.subarray(offset, offset + this.discriminatorSize);
-            discriminators.push(type);
-            offset += this.discriminatorSize;
-            const entryLength = this.readEntryLength(this.lengthSize, offset, Number);
-            offset += this.lengthSize;
-            if (offset + entryLength > this.tlvData.length) {
-                throw new TlvInvalidAccountDataError();
-            }
-            offset += entryLength;
-        }
-        return discriminators;
-    }
-}
diff --git a/libraries/type-length-value/js/test/splDiscriminate.test.ts b/libraries/type-length-value/js/test/splDiscriminate.test.ts
deleted file mode 100644
index 0dd8616ddff..00000000000
--- a/libraries/type-length-value/js/test/splDiscriminate.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { expect } from 'chai';
-import { splDiscriminate } from '../src/splDiscriminate';
-import { createHash } from 'crypto';
-
-describe('splDiscrimintor', () => {
-    const testVectors = [
-        'hello',
-        'this-is-a-test',
-        'test-namespace:this-is-a-test',
-        'test-namespace:this-is-a-test:with-a-longer-name',
-    ];
-
-    const testExpectedBytes = testVectors.map((x) => {
-        return createHash('sha256').update(x).digest();
-    });
-
-    const testSplDiscriminator = (length: number) => {
-        for (let i = 0; i < testVectors.length; i++) {
-            const discriminator = splDiscriminate(testVectors[i], length);
-            const expectedBytes = testExpectedBytes[i].subarray(0, length);
-            expect(discriminator).to.have.length(length);
-            expect(discriminator).to.deep.equal(expectedBytes);
-        }
-    };
-
-    it('should produce the expected bytes', () => {
-        testSplDiscriminator(8);
-        testSplDiscriminator(4);
-        testSplDiscriminator(2);
-    });
-
-    it('should produce the same bytes as rust library', () => {
-        const expectedBytes = Buffer.from([105, 37, 101, 197, 75, 251, 102, 26]);
-        const discriminator = splDiscriminate('spl-transfer-hook-interface:execute');
-        expect(discriminator).to.deep.equal(expectedBytes);
-    });
-});
diff --git a/libraries/type-length-value/js/test/tlvData.test.ts b/libraries/type-length-value/js/test/tlvData.test.ts
deleted file mode 100644
index 2ac06aff7e9..00000000000
--- a/libraries/type-length-value/js/test/tlvData.test.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import type { LengthSize } from '../src/tlvState';
-import { TlvState } from '../src/tlvState';
-import { expect } from 'chai';
-
-describe('tlvData', () => {
-    // typeLength 1, lengthSize 2
-    const tlvData1 = Buffer.concat([
-        Buffer.from([0]),
-        Buffer.from([0, 0]),
-        Buffer.from([]),
-        Buffer.from([1]),
-        Buffer.from([1, 0]),
-        Buffer.from([1]),
-        Buffer.from([2]),
-        Buffer.from([2, 0]),
-        Buffer.from([1, 2]),
-        Buffer.from([0]),
-        Buffer.from([3, 0]),
-        Buffer.from([1, 2, 3]),
-    ]);
-
-    // typeLength 2, lengthSize 1
-    const tlvData2 = Buffer.concat([
-        Buffer.from([0, 0]),
-        Buffer.from([0]),
-        Buffer.from([]),
-        Buffer.from([1, 0]),
-        Buffer.from([1]),
-        Buffer.from([1]),
-        Buffer.from([2, 0]),
-        Buffer.from([2]),
-        Buffer.from([1, 2]),
-        Buffer.from([0, 0]),
-        Buffer.from([3]),
-        Buffer.from([1, 2, 3]),
-    ]);
-
-    // typeLength 4, lengthSize 8
-    const tlvData3 = Buffer.concat([
-        Buffer.from([0, 0, 0, 0]),
-        Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([]),
-        Buffer.from([1, 0, 0, 0]),
-        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([1]),
-        Buffer.from([2, 0, 0, 0]),
-        Buffer.from([2, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([1, 2]),
-        Buffer.from([0, 0, 0, 0]),
-        Buffer.from([3, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([1, 2, 3]),
-    ]);
-
-    // typeLength 8, lengthSize 4
-    const tlvData4 = Buffer.concat([
-        Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([0, 0, 0, 0]),
-        Buffer.from([]),
-        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([1, 0, 0, 0]),
-        Buffer.from([1]),
-        Buffer.from([2, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([2, 0, 0, 0]),
-        Buffer.from([1, 2]),
-        Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
-        Buffer.from([3, 0, 0, 0]),
-        Buffer.from([1, 2, 3]),
-    ]);
-
-    const testRawData = (tlvData: Buffer, discriminatorSize: number, lengthSize: LengthSize) => {
-        const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-        expect(tlv.data).to.be.deep.equal(tlvData);
-        const tlvWithOffset = new TlvState(tlvData, discriminatorSize, lengthSize, discriminatorSize + lengthSize);
-        expect(tlvWithOffset.data).to.be.deep.equal(tlvData.subarray(discriminatorSize + lengthSize));
-    };
-
-    it('should get the raw tlv data', () => {
-        testRawData(tlvData1, 1, 2);
-        testRawData(tlvData2, 2, 1);
-        testRawData(tlvData3, 4, 8);
-        testRawData(tlvData4, 8, 4);
-    });
-
-    const testIndividualEntries = (tlvData: Buffer, discriminatorSize: number, lengthSize: LengthSize) => {
-        const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-
-        const type = Buffer.alloc(discriminatorSize);
-        type[0] = 0;
-        expect(tlv.firstBytes(type)).to.be.deep.equal(Buffer.from([]));
-        type[0] = 1;
-        expect(tlv.firstBytes(type)).to.be.deep.equal(Buffer.from([1]));
-        type[0] = 2;
-        expect(tlv.firstBytes(type)).to.be.deep.equal(Buffer.from([1, 2]));
-        type[0] = 3;
-        expect(tlv.firstBytes(type)).to.be.null;
-    };
-
-    it('should get the entries individually', () => {
-        testIndividualEntries(tlvData1, 1, 2);
-        testIndividualEntries(tlvData2, 2, 1);
-        testIndividualEntries(tlvData3, 4, 8);
-        testIndividualEntries(tlvData4, 8, 4);
-    });
-
-    const testRepeatingEntries = (tlvData: Buffer, discriminatorSize: number, lengthSize: LengthSize) => {
-        const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-
-        const bufferDiscriminator = tlv.bytesRepeating(Buffer.alloc(discriminatorSize));
-        expect(bufferDiscriminator).to.have.length(2);
-        expect(bufferDiscriminator[0]).to.be.deep.equal(Buffer.from([]));
-        expect(bufferDiscriminator[1]).to.be.deep.equal(Buffer.from([1, 2, 3]));
-
-        const bufferDiscriminatorWithCount = tlv.bytesRepeating(Buffer.alloc(discriminatorSize), 1);
-        expect(bufferDiscriminatorWithCount).to.have.length(1);
-        expect(bufferDiscriminatorWithCount[0]).to.be.deep.equal(Buffer.from([]));
-    };
-
-    it('should get the repeating entries', () => {
-        testRepeatingEntries(tlvData1, 1, 2);
-        testRepeatingEntries(tlvData2, 2, 1);
-        testRepeatingEntries(tlvData3, 4, 8);
-        testRepeatingEntries(tlvData4, 8, 4);
-    });
-
-    const testDiscriminators = (tlvData: Buffer, discriminatorSize: number, lengthSize: LengthSize) => {
-        const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-        const discriminators = tlv.discriminators();
-        expect(discriminators).to.have.length(4);
-
-        const type = Buffer.alloc(discriminatorSize);
-        type[0] = 0;
-        expect(discriminators[0]).to.be.deep.equal(type);
-        type[0] = 1;
-        expect(discriminators[1]).to.be.deep.equal(type);
-        type[0] = 2;
-        expect(discriminators[2]).to.be.deep.equal(type);
-        type[0] = 0;
-        expect(discriminators[3]).to.be.deep.equal(type);
-    };
-
-    it('should get the discriminators', () => {
-        testDiscriminators(tlvData1, 1, 2);
-        testDiscriminators(tlvData2, 2, 1);
-        testDiscriminators(tlvData3, 4, 8);
-        testDiscriminators(tlvData4, 8, 4);
-    });
-});
diff --git a/libraries/type-length-value/js/tsconfig.all.json b/libraries/type-length-value/js/tsconfig.all.json
deleted file mode 100644
index 985513259e2..00000000000
--- a/libraries/type-length-value/js/tsconfig.all.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.root.json",
-    "references": [
-        {
-            "path": "./tsconfig.cjs.json"
-        },
-        {
-            "path": "./tsconfig.esm.json"
-        }
-    ]
-}
diff --git a/libraries/type-length-value/js/tsconfig.base.json b/libraries/type-length-value/js/tsconfig.base.json
deleted file mode 100644
index 90620c4e485..00000000000
--- a/libraries/type-length-value/js/tsconfig.base.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "include": [],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "stripInternal": true
-    }
-}
diff --git a/libraries/type-length-value/js/tsconfig.cjs.json b/libraries/type-length-value/js/tsconfig.cjs.json
deleted file mode 100644
index 2db9b71569e..00000000000
--- a/libraries/type-length-value/js/tsconfig.cjs.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/cjs",
-        "target": "ES2016",
-        "module": "CommonJS",
-        "sourceMap": true
-    }
-}
diff --git a/libraries/type-length-value/js/tsconfig.esm.json b/libraries/type-length-value/js/tsconfig.esm.json
deleted file mode 100644
index 25e7e25e751..00000000000
--- a/libraries/type-length-value/js/tsconfig.esm.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/esm",
-        "declarationDir": "lib/types",
-        "target": "ES2020",
-        "module": "ES2020",
-        "sourceMap": true,
-        "declaration": true,
-        "declarationMap": true
-    }
-}
diff --git a/libraries/type-length-value/js/tsconfig.json b/libraries/type-length-value/js/tsconfig.json
deleted file mode 100644
index 2f9b239bfca..00000000000
--- a/libraries/type-length-value/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig.all.json",
-    "include": ["src", "test"],
-    "compilerOptions": {
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
diff --git a/libraries/type-length-value/js/tsconfig.root.json b/libraries/type-length-value/js/tsconfig.root.json
deleted file mode 100644
index fadf294ab43..00000000000
--- a/libraries/type-length-value/js/tsconfig.root.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "compilerOptions": {
-        "composite": true
-    }
-}
diff --git a/libraries/type-length-value/js/typedoc.json b/libraries/type-length-value/js/typedoc.json
deleted file mode 100644
index c39fc53aee1..00000000000
--- a/libraries/type-length-value/js/typedoc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md"
-}
diff --git a/libraries/type-length-value/src/error.rs b/libraries/type-length-value/src/error.rs
deleted file mode 100644
index 48e5d9efa34..00000000000
--- a/libraries/type-length-value/src/error.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Error types
-
-use spl_program_error::*;
-
-/// Errors that may be returned by the Token program.
-#[spl_program_error(hash_error_code_start = 1_202_666_432)]
-pub enum TlvError {
-    /// Type not found in TLV data
-    #[error("Type not found in TLV data")]
-    TypeNotFound,
-    /// Type already exists in TLV data
-    #[error("Type already exists in TLV data")]
-    TypeAlreadyExists,
-}
diff --git a/libraries/type-length-value/src/length.rs b/libraries/type-length-value/src/length.rs
deleted file mode 100644
index 6c2a8fc3788..00000000000
--- a/libraries/type-length-value/src/length.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//! Module for the length portion of a Type-Length-Value structure
-use {
-    bytemuck::{Pod, Zeroable},
-    solana_program::program_error::ProgramError,
-    spl_pod::primitives::PodU32,
-};
-
-/// Length in TLV structure
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct Length(PodU32);
-impl TryFrom<Length> for usize {
-    type Error = ProgramError;
-    fn try_from(n: Length) -> Result<Self, Self::Error> {
-        Self::try_from(u32::from(n.0)).map_err(|_| ProgramError::AccountDataTooSmall)
-    }
-}
-impl TryFrom<usize> for Length {
-    type Error = ProgramError;
-    fn try_from(n: usize) -> Result<Self, Self::Error> {
-        u32::try_from(n)
-            .map(|v| Self(PodU32::from(v)))
-            .map_err(|_| ProgramError::AccountDataTooSmall)
-    }
-}
diff --git a/libraries/type-length-value/src/lib.rs b/libraries/type-length-value/src/lib.rs
deleted file mode 100644
index 5cc1869cab9..00000000000
--- a/libraries/type-length-value/src/lib.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! Crate defining an interface for managing type-length-value entries in a slab
-//! of bytes, to be used with Solana accounts.
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod error;
-pub mod length;
-pub mod state;
-pub mod variable_len_pack;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-// Expose derive macro on feature flag
-#[cfg(feature = "derive")]
-pub use spl_type_length_value_derive::SplBorshVariableLenPack;
diff --git a/libraries/type-length-value/src/state.rs b/libraries/type-length-value/src/state.rs
deleted file mode 100644
index 8321ce76f74..00000000000
--- a/libraries/type-length-value/src/state.rs
+++ /dev/null
@@ -1,1364 +0,0 @@
-//! Type-length-value structure definition and manipulation
-
-use {
-    crate::{error::TlvError, length::Length, variable_len_pack::VariableLenPack},
-    bytemuck::Pod,
-    solana_program::{account_info::AccountInfo, program_error::ProgramError},
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_pod::bytemuck::{pod_from_bytes, pod_from_bytes_mut},
-    std::{cmp::Ordering, mem::size_of},
-};
-
-/// Get the current TlvIndices from the current spot
-const fn get_indices_unchecked(type_start: usize, value_repetition_number: usize) -> TlvIndices {
-    let length_start = type_start.saturating_add(size_of::<ArrayDiscriminator>());
-    let value_start = length_start.saturating_add(size_of::<Length>());
-    TlvIndices {
-        type_start,
-        length_start,
-        value_start,
-        value_repetition_number,
-    }
-}
-
-/// Internal helper struct for returning the indices of the type, length, and
-/// value in a TLV entry
-#[derive(Debug)]
-struct TlvIndices {
-    pub type_start: usize,
-    pub length_start: usize,
-    pub value_start: usize,
-    pub value_repetition_number: usize,
-}
-
-fn get_indices(
-    tlv_data: &[u8],
-    value_discriminator: ArrayDiscriminator,
-    init: bool,
-    repetition_number: Option<usize>,
-) -> Result<TlvIndices, ProgramError> {
-    let mut current_repetition_number = 0;
-    let mut start_index = 0;
-    while start_index < tlv_data.len() {
-        let tlv_indices = get_indices_unchecked(start_index, current_repetition_number);
-        if tlv_data.len() < tlv_indices.value_start {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        let discriminator = ArrayDiscriminator::try_from(
-            &tlv_data[tlv_indices.type_start..tlv_indices.length_start],
-        )?;
-        if discriminator == value_discriminator {
-            if let Some(desired_repetition_number) = repetition_number {
-                if current_repetition_number == desired_repetition_number {
-                    return Ok(tlv_indices);
-                }
-            }
-            current_repetition_number += 1;
-        // got to an empty spot, init here, or error if we're searching, since
-        // nothing is written after an Uninitialized spot
-        } else if discriminator == ArrayDiscriminator::UNINITIALIZED {
-            if init {
-                return Ok(tlv_indices);
-            } else {
-                return Err(TlvError::TypeNotFound.into());
-            }
-        }
-        let length =
-            pod_from_bytes::<Length>(&tlv_data[tlv_indices.length_start..tlv_indices.value_start])?;
-        let value_end_index = tlv_indices
-            .value_start
-            .saturating_add(usize::try_from(*length)?);
-        start_index = value_end_index;
-    }
-    Err(ProgramError::InvalidAccountData)
-}
-
-// This function is doing two separate things at once, and would probably be
-// better served by some custom iterator, but let's leave that for another day.
-fn get_discriminators_and_end_index(
-    tlv_data: &[u8],
-) -> Result<(Vec<ArrayDiscriminator>, usize), ProgramError> {
-    let mut discriminators = vec![];
-    let mut start_index = 0;
-    while start_index < tlv_data.len() {
-        // This function is not concerned with repetitions, so we can just
-        // arbitrarily pass `0` here
-        let tlv_indices = get_indices_unchecked(start_index, 0);
-        if tlv_data.len() < tlv_indices.length_start {
-            // we got to the end, but there might be some uninitialized data after
-            let remainder = &tlv_data[tlv_indices.type_start..];
-            if remainder.iter().all(|&x| x == 0) {
-                return Ok((discriminators, tlv_indices.type_start));
-            } else {
-                return Err(ProgramError::InvalidAccountData);
-            }
-        }
-        let discriminator = ArrayDiscriminator::try_from(
-            &tlv_data[tlv_indices.type_start..tlv_indices.length_start],
-        )?;
-        if discriminator == ArrayDiscriminator::UNINITIALIZED {
-            return Ok((discriminators, tlv_indices.type_start));
-        } else {
-            if tlv_data.len() < tlv_indices.value_start {
-                // not enough bytes to store the length, malformed
-                return Err(ProgramError::InvalidAccountData);
-            }
-            discriminators.push(discriminator);
-            let length = pod_from_bytes::<Length>(
-                &tlv_data[tlv_indices.length_start..tlv_indices.value_start],
-            )?;
-
-            let value_end_index = tlv_indices
-                .value_start
-                .saturating_add(usize::try_from(*length)?);
-            if value_end_index > tlv_data.len() {
-                // value blows past the size of the slice, malformed
-                return Err(ProgramError::InvalidAccountData);
-            }
-            start_index = value_end_index;
-        }
-    }
-    Ok((discriminators, start_index))
-}
-
-fn get_bytes<V: SplDiscriminate>(
-    tlv_data: &[u8],
-    repetition_number: usize,
-) -> Result<&[u8], ProgramError> {
-    let TlvIndices {
-        type_start: _,
-        length_start,
-        value_start,
-        value_repetition_number: _,
-    } = get_indices(
-        tlv_data,
-        V::SPL_DISCRIMINATOR,
-        false,
-        Some(repetition_number),
-    )?;
-    // get_indices has checked that tlv_data is long enough to include these
-    // indices
-    let length = pod_from_bytes::<Length>(&tlv_data[length_start..value_start])?;
-    let value_end = value_start.saturating_add(usize::try_from(*length)?);
-    if tlv_data.len() < value_end {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    Ok(&tlv_data[value_start..value_end])
-}
-
-/// Trait for all TLV state
-///
-/// Stores data as any number of type-length-value structures underneath, where:
-///
-///   * the "type" is an `ArrayDiscriminator`, 8 bytes
-///   * the "length" is a `Length`, 4 bytes
-///   * the "value" is a slab of "length" bytes
-///
-/// With this structure, it's possible to hold onto any number of entries with
-/// unique discriminators, provided that the total underlying data has enough
-/// bytes for every entry.
-///
-/// For example, if we have two distinct types, one which is an 8-byte array
-/// of value `[0, 1, 0, 0, 0, 0, 0, 0]` and discriminator
-/// `[1, 1, 1, 1, 1, 1, 1, 1]`, and another which is just a single `u8` of value
-/// `4` with the discriminator `[2, 2, 2, 2, 2, 2, 2, 2]`, we can deserialize
-/// this buffer as follows:
-///
-/// ```
-/// use {
-///     bytemuck::{Pod, Zeroable},
-///     spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-///     spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut},
-/// };
-/// #[repr(C)]
-/// #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-/// struct MyPodValue {
-///     data: [u8; 8],
-/// }
-/// impl SplDiscriminate for MyPodValue {
-///     const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-/// }
-/// #[repr(C)]
-/// #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-/// struct MyOtherPodValue {
-///     data: u8,
-/// }
-/// impl SplDiscriminate for MyOtherPodValue {
-///     const SPL_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([2; ArrayDiscriminator::LENGTH]);
-/// }
-/// let buffer = [
-///   1, 1, 1, 1, 1, 1, 1, 1, // first type's discriminator
-///   8, 0, 0, 0,             // first type's length
-///   0, 1, 0, 0, 0, 0, 0, 0, // first type's value
-///   2, 2, 2, 2, 2, 2, 2, 2, // second type's discriminator
-///   1, 0, 0, 0,             // second type's length
-///   4,                      // second type's value
-/// ];
-/// let state = TlvStateBorrowed::unpack(&buffer).unwrap();
-/// let value = state.get_first_value::<MyPodValue>().unwrap();
-/// assert_eq!(value.data, [0, 1, 0, 0, 0, 0, 0, 0]);
-/// let value = state.get_first_value::<MyOtherPodValue>().unwrap();
-/// assert_eq!(value.data, 4);
-/// ```
-///
-/// See the README and tests for more examples on how to use these types.
-pub trait TlvState {
-    /// Get the full buffer containing all TLV data
-    fn get_data(&self) -> &[u8];
-
-    /// Unpack a portion of the TLV data as the desired Pod type for the entry
-    /// number specified
-    fn get_value_with_repetition<V: SplDiscriminate + Pod>(
-        &self,
-        repetition_number: usize,
-    ) -> Result<&V, ProgramError> {
-        let data = get_bytes::<V>(self.get_data(), repetition_number)?;
-        pod_from_bytes::<V>(data)
-    }
-
-    /// Unpack a portion of the TLV data as the desired Pod type for the first
-    /// entry found
-    fn get_first_value<V: SplDiscriminate + Pod>(&self) -> Result<&V, ProgramError> {
-        self.get_value_with_repetition::<V>(0)
-    }
-
-    /// Unpacks a portion of the TLV data as the desired variable-length type
-    /// for the entry number specified
-    fn get_variable_len_value_with_repetition<V: SplDiscriminate + VariableLenPack>(
-        &self,
-        repetition_number: usize,
-    ) -> Result<V, ProgramError> {
-        let data = get_bytes::<V>(self.get_data(), repetition_number)?;
-        V::unpack_from_slice(data)
-    }
-
-    /// Unpacks a portion of the TLV data as the desired variable-length type
-    /// for the first entry found
-    fn get_first_variable_len_value<V: SplDiscriminate + VariableLenPack>(
-        &self,
-    ) -> Result<V, ProgramError> {
-        self.get_variable_len_value_with_repetition::<V>(0)
-    }
-
-    /// Unpack a portion of the TLV data as bytes for the entry number specified
-    fn get_bytes_with_repetition<V: SplDiscriminate>(
-        &self,
-        repetition_number: usize,
-    ) -> Result<&[u8], ProgramError> {
-        get_bytes::<V>(self.get_data(), repetition_number)
-    }
-
-    /// Unpack a portion of the TLV data as bytes for the first entry found
-    fn get_first_bytes<V: SplDiscriminate>(&self) -> Result<&[u8], ProgramError> {
-        self.get_bytes_with_repetition::<V>(0)
-    }
-
-    /// Iterates through the TLV entries, returning only the types
-    fn get_discriminators(&self) -> Result<Vec<ArrayDiscriminator>, ProgramError> {
-        get_discriminators_and_end_index(self.get_data()).map(|v| v.0)
-    }
-
-    /// Get the base size required for TLV data
-    fn get_base_len() -> usize {
-        get_base_len()
-    }
-}
-
-/// Encapsulates owned TLV data
-#[derive(Debug, PartialEq)]
-pub struct TlvStateOwned {
-    /// Raw TLV data, deserialized on demand
-    data: Vec<u8>,
-}
-impl TlvStateOwned {
-    /// Unpacks TLV state data
-    ///
-    /// Fails if no state is initialized or if data is too small
-    pub fn unpack(data: Vec<u8>) -> Result<Self, ProgramError> {
-        check_data(&data)?;
-        Ok(Self { data })
-    }
-}
-impl TlvState for TlvStateOwned {
-    fn get_data(&self) -> &[u8] {
-        &self.data
-    }
-}
-
-/// Encapsulates immutable base state data (mint or account) with possible
-/// extensions
-#[derive(Debug, PartialEq)]
-pub struct TlvStateBorrowed<'data> {
-    /// Slice of data containing all TLV data, deserialized on demand
-    data: &'data [u8],
-}
-impl<'data> TlvStateBorrowed<'data> {
-    /// Unpacks TLV state data
-    ///
-    /// Fails if no state is initialized or if data is too small
-    pub fn unpack(data: &'data [u8]) -> Result<Self, ProgramError> {
-        check_data(data)?;
-        Ok(Self { data })
-    }
-}
-impl<'a> TlvState for TlvStateBorrowed<'a> {
-    fn get_data(&self) -> &[u8] {
-        self.data
-    }
-}
-
-/// Encapsulates mutable base state data (mint or account) with possible
-/// extensions
-#[derive(Debug, PartialEq)]
-pub struct TlvStateMut<'data> {
-    /// Slice of data containing all TLV data, deserialized on demand
-    data: &'data mut [u8],
-}
-impl<'data> TlvStateMut<'data> {
-    /// Unpacks TLV state data
-    ///
-    /// Fails if no state is initialized or if data is too small
-    pub fn unpack(data: &'data mut [u8]) -> Result<Self, ProgramError> {
-        check_data(data)?;
-        Ok(Self { data })
-    }
-
-    /// Unpack a portion of the TLV data as the desired type that allows
-    /// modifying the type for the entry number specified
-    pub fn get_value_with_repetition_mut<V: SplDiscriminate + Pod>(
-        &mut self,
-        repetition_number: usize,
-    ) -> Result<&mut V, ProgramError> {
-        let data = self.get_bytes_with_repetition_mut::<V>(repetition_number)?;
-        pod_from_bytes_mut::<V>(data)
-    }
-
-    /// Unpack a portion of the TLV data as the desired type that allows
-    /// modifying the type for the first entry found
-    pub fn get_first_value_mut<V: SplDiscriminate + Pod>(
-        &mut self,
-    ) -> Result<&mut V, ProgramError> {
-        self.get_value_with_repetition_mut::<V>(0)
-    }
-
-    /// Unpack a portion of the TLV data as mutable bytes for the entry number
-    /// specified
-    pub fn get_bytes_with_repetition_mut<V: SplDiscriminate>(
-        &mut self,
-        repetition_number: usize,
-    ) -> Result<&mut [u8], ProgramError> {
-        let TlvIndices {
-            type_start: _,
-            length_start,
-            value_start,
-            value_repetition_number: _,
-        } = get_indices(
-            self.data,
-            V::SPL_DISCRIMINATOR,
-            false,
-            Some(repetition_number),
-        )?;
-
-        let length = pod_from_bytes::<Length>(&self.data[length_start..value_start])?;
-        let value_end = value_start.saturating_add(usize::try_from(*length)?);
-        if self.data.len() < value_end {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        Ok(&mut self.data[value_start..value_end])
-    }
-
-    /// Unpack a portion of the TLV data as mutable bytes for the first entry
-    /// found
-    pub fn get_first_bytes_mut<V: SplDiscriminate>(&mut self) -> Result<&mut [u8], ProgramError> {
-        self.get_bytes_with_repetition_mut::<V>(0)
-    }
-
-    /// Packs the default TLV data into the first open slot in the data buffer.
-    /// Handles repetition based on the boolean arg provided:
-    /// * `true`:   If extension is already found in the buffer,
-    /// it returns an error.
-    /// * `false`:  Will add a new entry to the next open slot.
-    pub fn init_value<V: SplDiscriminate + Pod + Default>(
-        &mut self,
-        allow_repetition: bool,
-    ) -> Result<(&mut V, usize), ProgramError> {
-        let length = size_of::<V>();
-        let (buffer, repetition_number) = self.alloc::<V>(length, allow_repetition)?;
-        let extension_ref = pod_from_bytes_mut::<V>(buffer)?;
-        *extension_ref = V::default();
-        Ok((extension_ref, repetition_number))
-    }
-
-    /// Packs a variable-length value into its appropriate data segment, where
-    /// repeating discriminators _are_ allowed
-    pub fn pack_variable_len_value_with_repetition<V: SplDiscriminate + VariableLenPack>(
-        &mut self,
-        value: &V,
-        repetition_number: usize,
-    ) -> Result<(), ProgramError> {
-        let data = self.get_bytes_with_repetition_mut::<V>(repetition_number)?;
-        // NOTE: Do *not* use `pack`, since the length check will cause
-        // reallocations to smaller sizes to fail
-        value.pack_into_slice(data)
-    }
-
-    /// Packs a variable-length value into its appropriate data segment, where
-    /// no repeating discriminators are allowed
-    pub fn pack_first_variable_len_value<V: SplDiscriminate + VariableLenPack>(
-        &mut self,
-        value: &V,
-    ) -> Result<(), ProgramError> {
-        self.pack_variable_len_value_with_repetition::<V>(value, 0)
-    }
-
-    /// Allocate the given number of bytes for the given SplDiscriminate
-    pub fn alloc<V: SplDiscriminate>(
-        &mut self,
-        length: usize,
-        allow_repetition: bool,
-    ) -> Result<(&mut [u8], usize), ProgramError> {
-        let TlvIndices {
-            type_start,
-            length_start,
-            value_start,
-            value_repetition_number,
-        } = get_indices(
-            self.data,
-            V::SPL_DISCRIMINATOR,
-            true,
-            if allow_repetition { None } else { Some(0) },
-        )?;
-
-        let discriminator = ArrayDiscriminator::try_from(&self.data[type_start..length_start])?;
-        if discriminator == ArrayDiscriminator::UNINITIALIZED {
-            // write type
-            let discriminator_ref = &mut self.data[type_start..length_start];
-            discriminator_ref.copy_from_slice(V::SPL_DISCRIMINATOR.as_ref());
-            // write length
-            let length_ref =
-                pod_from_bytes_mut::<Length>(&mut self.data[length_start..value_start])?;
-            *length_ref = Length::try_from(length)?;
-
-            let value_end = value_start.saturating_add(length);
-            if self.data.len() < value_end {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            Ok((
-                &mut self.data[value_start..value_end],
-                value_repetition_number,
-            ))
-        } else {
-            Err(TlvError::TypeAlreadyExists.into())
-        }
-    }
-
-    /// Allocates and serializes a new TLV entry from a `VariableLenPack` type
-    pub fn alloc_and_pack_variable_len_entry<V: SplDiscriminate + VariableLenPack>(
-        &mut self,
-        value: &V,
-        allow_repetition: bool,
-    ) -> Result<usize, ProgramError> {
-        let length = value.get_packed_len()?;
-        let (data, repetition_number) = self.alloc::<V>(length, allow_repetition)?;
-        value.pack_into_slice(data)?;
-        Ok(repetition_number)
-    }
-
-    /// Reallocate the given number of bytes for the given SplDiscriminate. If
-    /// the new length is smaller, it will compact the rest of the buffer
-    /// and zero out the difference at the end. If it's larger, it will move
-    /// the rest of the buffer data and zero out the new data.
-    pub fn realloc_with_repetition<V: SplDiscriminate>(
-        &mut self,
-        length: usize,
-        repetition_number: usize,
-    ) -> Result<&mut [u8], ProgramError> {
-        let TlvIndices {
-            type_start: _,
-            length_start,
-            value_start,
-            value_repetition_number: _,
-        } = get_indices(
-            self.data,
-            V::SPL_DISCRIMINATOR,
-            false,
-            Some(repetition_number),
-        )?;
-        let (_, end_index) = get_discriminators_and_end_index(self.data)?;
-        let data_len = self.data.len();
-
-        let length_ref = pod_from_bytes_mut::<Length>(&mut self.data[length_start..value_start])?;
-        let old_length = usize::try_from(*length_ref)?;
-
-        // check that we're not going to panic during `copy_within`
-        if old_length < length {
-            let new_end_index = end_index.saturating_add(length.saturating_sub(old_length));
-            if new_end_index > data_len {
-                return Err(ProgramError::InvalidAccountData);
-            }
-        }
-
-        // write new length after the check, to avoid getting into a bad situation
-        // if trying to recover from an error
-        *length_ref = Length::try_from(length)?;
-
-        let old_value_end = value_start.saturating_add(old_length);
-        let new_value_end = value_start.saturating_add(length);
-        self.data
-            .copy_within(old_value_end..end_index, new_value_end);
-        match old_length.cmp(&length) {
-            Ordering::Greater => {
-                // realloc to smaller, fill the end
-                let new_end_index = end_index.saturating_sub(old_length.saturating_sub(length));
-                self.data[new_end_index..end_index].fill(0);
-            }
-            Ordering::Less => {
-                // realloc to bigger, fill the moved part
-                self.data[old_value_end..new_value_end].fill(0);
-            }
-            Ordering::Equal => {} // nothing needed!
-        }
-
-        Ok(&mut self.data[value_start..new_value_end])
-    }
-
-    /// Reallocate the given number of bytes for the given SplDiscriminate,
-    /// where no repeating discriminators are allowed
-    pub fn realloc_first<V: SplDiscriminate>(
-        &mut self,
-        length: usize,
-    ) -> Result<&mut [u8], ProgramError> {
-        self.realloc_with_repetition::<V>(length, 0)
-    }
-}
-
-impl<'a> TlvState for TlvStateMut<'a> {
-    fn get_data(&self) -> &[u8] {
-        self.data
-    }
-}
-
-/// Packs a variable-length value into an existing TLV space, reallocating
-/// the account and TLV as needed to accommodate for any change in space
-pub fn realloc_and_pack_variable_len_with_repetition<V: SplDiscriminate + VariableLenPack>(
-    account_info: &AccountInfo,
-    value: &V,
-    repetition_number: usize,
-) -> Result<(), ProgramError> {
-    let previous_length = {
-        let data = account_info.try_borrow_data()?;
-        let TlvIndices {
-            type_start: _,
-            length_start,
-            value_start,
-            value_repetition_number: _,
-        } = get_indices(&data, V::SPL_DISCRIMINATOR, false, Some(repetition_number))?;
-        usize::try_from(*pod_from_bytes::<Length>(&data[length_start..value_start])?)?
-    };
-    let new_length = value.get_packed_len()?;
-    let previous_account_size = account_info.try_data_len()?;
-    if previous_length < new_length {
-        // size increased, so realloc the account, then the TLV entry, then write data
-        let additional_bytes = new_length
-            .checked_sub(previous_length)
-            .ok_or(ProgramError::AccountDataTooSmall)?;
-        account_info.realloc(previous_account_size.saturating_add(additional_bytes), true)?;
-        let mut buffer = account_info.try_borrow_mut_data()?;
-        let mut state = TlvStateMut::unpack(&mut buffer)?;
-        state.realloc_with_repetition::<V>(new_length, repetition_number)?;
-        state.pack_variable_len_value_with_repetition(value, repetition_number)?;
-    } else {
-        // do it backwards otherwise, write the state, realloc TLV, then the account
-        let mut buffer = account_info.try_borrow_mut_data()?;
-        let mut state = TlvStateMut::unpack(&mut buffer)?;
-        state.pack_variable_len_value_with_repetition(value, repetition_number)?;
-        let removed_bytes = previous_length
-            .checked_sub(new_length)
-            .ok_or(ProgramError::AccountDataTooSmall)?;
-        if removed_bytes > 0 {
-            // we decreased the size, so need to realloc the TLV, then the account
-            state.realloc_with_repetition::<V>(new_length, repetition_number)?;
-            // this is probably fine, but be safe and avoid invalidating references
-            drop(buffer);
-            account_info.realloc(previous_account_size.saturating_sub(removed_bytes), false)?;
-        }
-    }
-    Ok(())
-}
-
-/// Packs a variable-length value into an existing TLV space, where no repeating
-/// discriminators are allowed
-pub fn realloc_and_pack_first_variable_len<V: SplDiscriminate + VariableLenPack>(
-    account_info: &AccountInfo,
-    value: &V,
-) -> Result<(), ProgramError> {
-    realloc_and_pack_variable_len_with_repetition::<V>(account_info, value, 0)
-}
-
-/// Get the base size required for TLV data
-const fn get_base_len() -> usize {
-    get_indices_unchecked(0, 0).value_start
-}
-
-fn check_data(tlv_data: &[u8]) -> Result<(), ProgramError> {
-    // should be able to iterate through all entries in the TLV structure
-    let _ = get_discriminators_and_end_index(tlv_data)?;
-    Ok(())
-}
-
-#[cfg(test)]
-mod test {
-    use {
-        super::*,
-        bytemuck::{Pod, Zeroable},
-    };
-
-    const TEST_BUFFER: &[u8] = &[
-        1, 1, 1, 1, 1, 1, 1, 1, // discriminator
-        32, 0, 0, 0, // length
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, // value
-        0, 0, // empty, not enough for a discriminator
-    ];
-
-    const TEST_BIG_BUFFER: &[u8] = &[
-        1, 1, 1, 1, 1, 1, 1, 1, // discriminator
-        32, 0, 0, 0, // length
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, // value
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, // empty, but enough for a discriminator and empty value
-    ];
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-    struct TestValue {
-        data: [u8; 32],
-    }
-    impl SplDiscriminate for TestValue {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([1; ArrayDiscriminator::LENGTH]);
-    }
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-    struct TestSmallValue {
-        data: [u8; 3],
-    }
-    impl SplDiscriminate for TestSmallValue {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([2; ArrayDiscriminator::LENGTH]);
-    }
-
-    #[repr(transparent)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-    struct TestEmptyValue;
-    impl SplDiscriminate for TestEmptyValue {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([3; ArrayDiscriminator::LENGTH]);
-    }
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-    struct TestNonZeroDefault {
-        data: [u8; 5],
-    }
-    const TEST_NON_ZERO_DEFAULT_DATA: [u8; 5] = [4; 5];
-    impl SplDiscriminate for TestNonZeroDefault {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([4; ArrayDiscriminator::LENGTH]);
-    }
-    impl Default for TestNonZeroDefault {
-        fn default() -> Self {
-            Self {
-                data: TEST_NON_ZERO_DEFAULT_DATA,
-            }
-        }
-    }
-
-    #[test]
-    fn unpack_opaque_buffer() {
-        let state = TlvStateBorrowed::unpack(TEST_BUFFER).unwrap();
-        let value = state.get_first_value::<TestValue>().unwrap();
-        assert_eq!(value.data, [1; 32]);
-        assert_eq!(
-            state.get_first_value::<TestEmptyValue>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        let mut test_buffer = TEST_BUFFER.to_vec();
-        let state = TlvStateMut::unpack(&mut test_buffer).unwrap();
-        let value = state.get_first_value::<TestValue>().unwrap();
-        assert_eq!(value.data, [1; 32]);
-        let state = TlvStateOwned::unpack(test_buffer).unwrap();
-        let value = state.get_first_value::<TestValue>().unwrap();
-        assert_eq!(value.data, [1; 32]);
-    }
-
-    #[test]
-    fn fail_unpack_opaque_buffer() {
-        // input buffer too small
-        let mut buffer = vec![0, 3];
-        assert_eq!(
-            TlvStateBorrowed::unpack(&buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-        assert_eq!(
-            TlvStateMut::unpack(&mut buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-        assert_eq!(
-            TlvStateMut::unpack(&mut buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the discriminator
-        let mut buffer = TEST_BUFFER.to_vec();
-        buffer[0] += 1;
-        let state = TlvStateMut::unpack(&mut buffer).unwrap();
-        assert_eq!(
-            state.get_first_value::<TestValue>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the length, too big
-        let mut buffer = TEST_BUFFER.to_vec();
-        buffer[ArrayDiscriminator::LENGTH] += 10;
-        assert_eq!(
-            TlvStateMut::unpack(&mut buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the length, too small
-        let mut buffer = TEST_BIG_BUFFER.to_vec();
-        buffer[ArrayDiscriminator::LENGTH] -= 1;
-        let state = TlvStateMut::unpack(&mut buffer).unwrap();
-        assert_eq!(
-            state.get_first_value::<TestValue>(),
-            Err(ProgramError::InvalidArgument)
-        );
-
-        // data buffer is too small for type
-        let buffer = &TEST_BUFFER[..TEST_BUFFER.len() - 5];
-        assert_eq!(
-            TlvStateBorrowed::unpack(buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-    }
-
-    #[test]
-    fn get_discriminators_with_opaque_buffer() {
-        // incorrect due to the length
-        assert_eq!(
-            get_discriminators_and_end_index(&[1, 0, 1, 1]).unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-        // correct due to the good discriminator length and zero length
-        assert_eq!(
-            get_discriminators_and_end_index(&[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
-            (vec![ArrayDiscriminator::try_from(1).unwrap()], 12)
-        );
-        // correct since it's just uninitialized data
-        assert_eq!(
-            get_discriminators_and_end_index(&[0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
-            (vec![], 0)
-        );
-    }
-
-    #[test]
-    fn value_pack_unpack() {
-        let account_size =
-            get_base_len() + size_of::<TestValue>() + get_base_len() + size_of::<TestSmallValue>();
-        let mut buffer = vec![0; account_size];
-
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        // success init and write value
-        let value = state.init_value::<TestValue>(false).unwrap().0;
-        let data = [100; 32];
-        value.data = data;
-        assert_eq!(
-            &state.get_discriminators().unwrap(),
-            &[TestValue::SPL_DISCRIMINATOR],
-        );
-        assert_eq!(&state.get_first_value::<TestValue>().unwrap().data, &data,);
-
-        // fail init extension when already initialized
-        assert_eq!(
-            state.init_value::<TestValue>(false).unwrap_err(),
-            TlvError::TypeAlreadyExists.into(),
-        );
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(TestValue::SPL_DISCRIMINATOR.as_ref());
-        expect.extend_from_slice(&u32::try_from(size_of::<TestValue>()).unwrap().to_le_bytes());
-        expect.extend_from_slice(&data);
-        expect.extend_from_slice(&[0; size_of::<ArrayDiscriminator>()]);
-        expect.extend_from_slice(&[0; size_of::<Length>()]);
-        expect.extend_from_slice(&[0; size_of::<TestSmallValue>()]);
-        assert_eq!(expect, buffer);
-
-        // check unpacking
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        let unpacked = state.get_first_value_mut::<TestValue>().unwrap();
-        assert_eq!(*unpacked, TestValue { data });
-
-        // update extension
-        let new_data = [101; 32];
-        unpacked.data = new_data;
-
-        // check updates are propagated
-        let state = TlvStateBorrowed::unpack(&buffer).unwrap();
-        let unpacked = state.get_first_value::<TestValue>().unwrap();
-        assert_eq!(*unpacked, TestValue { data: new_data });
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(TestValue::SPL_DISCRIMINATOR.as_ref());
-        expect.extend_from_slice(&u32::try_from(size_of::<TestValue>()).unwrap().to_le_bytes());
-        expect.extend_from_slice(&new_data);
-        expect.extend_from_slice(&[0; size_of::<ArrayDiscriminator>()]);
-        expect.extend_from_slice(&[0; size_of::<Length>()]);
-        expect.extend_from_slice(&[0; size_of::<TestSmallValue>()]);
-        assert_eq!(expect, buffer);
-
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        // init one more value
-        let new_value = state.init_value::<TestSmallValue>(false).unwrap().0;
-        let small_data = [102; 3];
-        new_value.data = small_data;
-
-        assert_eq!(
-            &state.get_discriminators().unwrap(),
-            &[
-                TestValue::SPL_DISCRIMINATOR,
-                TestSmallValue::SPL_DISCRIMINATOR
-            ]
-        );
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(TestValue::SPL_DISCRIMINATOR.as_ref());
-        expect.extend_from_slice(&u32::try_from(size_of::<TestValue>()).unwrap().to_le_bytes());
-        expect.extend_from_slice(&new_data);
-        expect.extend_from_slice(TestSmallValue::SPL_DISCRIMINATOR.as_ref());
-        expect.extend_from_slice(
-            &u32::try_from(size_of::<TestSmallValue>())
-                .unwrap()
-                .to_le_bytes(),
-        );
-        expect.extend_from_slice(&small_data);
-        assert_eq!(expect, buffer);
-
-        // fail to init one more extension that does not fit
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        assert_eq!(
-            state.init_value::<TestEmptyValue>(false),
-            Err(ProgramError::InvalidAccountData),
-        );
-    }
-
-    #[test]
-    fn value_any_order() {
-        let account_size =
-            get_base_len() + size_of::<TestValue>() + get_base_len() + size_of::<TestSmallValue>();
-        let mut buffer = vec![0; account_size];
-
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        let data = [99; 32];
-        let small_data = [98; 3];
-
-        // write values
-        let value = state.init_value::<TestValue>(false).unwrap().0;
-        value.data = data;
-        let value = state.init_value::<TestSmallValue>(false).unwrap().0;
-        value.data = small_data;
-
-        assert_eq!(
-            &state.get_discriminators().unwrap(),
-            &[
-                TestValue::SPL_DISCRIMINATOR,
-                TestSmallValue::SPL_DISCRIMINATOR,
-            ]
-        );
-
-        // write values in a different order
-        let mut other_buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut other_buffer).unwrap();
-
-        let value = state.init_value::<TestSmallValue>(false).unwrap().0;
-        value.data = small_data;
-        let value = state.init_value::<TestValue>(false).unwrap().0;
-        value.data = data;
-
-        assert_eq!(
-            &state.get_discriminators().unwrap(),
-            &[
-                TestSmallValue::SPL_DISCRIMINATOR,
-                TestValue::SPL_DISCRIMINATOR,
-            ]
-        );
-
-        // buffers are NOT the same because written in a different order
-        assert_ne!(buffer, other_buffer);
-        let state = TlvStateBorrowed::unpack(&buffer).unwrap();
-        let other_state = TlvStateBorrowed::unpack(&other_buffer).unwrap();
-
-        // BUT values are the same
-        assert_eq!(
-            state.get_first_value::<TestValue>().unwrap(),
-            other_state.get_first_value::<TestValue>().unwrap()
-        );
-        assert_eq!(
-            state.get_first_value::<TestSmallValue>().unwrap(),
-            other_state.get_first_value::<TestSmallValue>().unwrap()
-        );
-    }
-
-    #[test]
-    fn init_nonzero_default() {
-        let account_size = get_base_len() + size_of::<TestNonZeroDefault>();
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        let value = state.init_value::<TestNonZeroDefault>(false).unwrap().0;
-        assert_eq!(value.data, TEST_NON_ZERO_DEFAULT_DATA);
-    }
-
-    #[test]
-    fn init_buffer_too_small() {
-        let account_size = get_base_len() + size_of::<TestValue>();
-        let mut buffer = vec![0; account_size - 1];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        let err = state.init_value::<TestValue>(false).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        // hack the buffer to look like it was initialized, still fails
-        let discriminator_ref = &mut state.data[0..ArrayDiscriminator::LENGTH];
-        discriminator_ref.copy_from_slice(TestValue::SPL_DISCRIMINATOR.as_ref());
-        state.data[ArrayDiscriminator::LENGTH] = 32;
-        let err = state.get_first_value::<TestValue>().unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        assert_eq!(
-            state.get_discriminators().unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-    }
-
-    #[test]
-    fn value_with_no_data() {
-        let account_size = get_base_len() + size_of::<TestEmptyValue>();
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        assert_eq!(
-            state.get_first_value::<TestEmptyValue>().unwrap_err(),
-            TlvError::TypeNotFound.into(),
-        );
-
-        state.init_value::<TestEmptyValue>(false).unwrap();
-        state.get_first_value::<TestEmptyValue>().unwrap();
-
-        // re-init fails
-        assert_eq!(
-            state.init_value::<TestEmptyValue>(false).unwrap_err(),
-            TlvError::TypeAlreadyExists.into(),
-        );
-    }
-
-    #[test]
-    fn alloc_first() {
-        let tlv_size = 1;
-        let account_size = get_base_len() + tlv_size;
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        // not enough room
-        let data = state.alloc::<TestValue>(tlv_size, false).unwrap().0;
-        assert_eq!(
-            pod_from_bytes_mut::<TestValue>(data).unwrap_err(),
-            ProgramError::InvalidArgument,
-        );
-
-        // can't double alloc
-        assert_eq!(
-            state.alloc::<TestValue>(tlv_size, false).unwrap_err(),
-            TlvError::TypeAlreadyExists.into(),
-        );
-    }
-
-    #[test]
-    fn alloc_with_repetition() {
-        let tlv_size = 1;
-        let account_size = (get_base_len() + tlv_size) * 2;
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        let (data, repetition_number) = state.alloc::<TestValue>(tlv_size, true).unwrap();
-        assert_eq!(repetition_number, 0);
-
-        // not enough room
-        assert_eq!(
-            pod_from_bytes_mut::<TestValue>(data).unwrap_err(),
-            ProgramError::InvalidArgument,
-        );
-
-        // Can alloc again!
-        let (_data, repetition_number) = state.alloc::<TestValue>(tlv_size, true).unwrap();
-        assert_eq!(repetition_number, 1);
-    }
-
-    #[test]
-    fn realloc_first() {
-        const TLV_SIZE: usize = 10;
-        const EXTRA_SPACE: usize = 5;
-        const SMALL_SIZE: usize = 2;
-        const ACCOUNT_SIZE: usize = get_base_len()
-            + TLV_SIZE
-            + EXTRA_SPACE
-            + get_base_len()
-            + size_of::<TestNonZeroDefault>();
-        let mut buffer = vec![0; ACCOUNT_SIZE];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        // alloc both types
-        let _ = state.alloc::<TestValue>(TLV_SIZE, false).unwrap();
-        let _ = state.init_value::<TestNonZeroDefault>(false).unwrap();
-
-        // realloc first entry to larger, all 0
-        let data = state
-            .realloc_first::<TestValue>(TLV_SIZE + EXTRA_SPACE)
-            .unwrap();
-        assert_eq!(data, [0; TLV_SIZE + EXTRA_SPACE]);
-        let value = state.get_first_value::<TestNonZeroDefault>().unwrap();
-        assert_eq!(*value, TestNonZeroDefault::default());
-
-        // realloc to smaller, still all 0
-        let data = state.realloc_first::<TestValue>(SMALL_SIZE).unwrap();
-        assert_eq!(data, [0; SMALL_SIZE]);
-        let value = state.get_first_value::<TestNonZeroDefault>().unwrap();
-        assert_eq!(*value, TestNonZeroDefault::default());
-        let (_, end_index) = get_discriminators_and_end_index(&buffer).unwrap();
-        assert_eq!(
-            &buffer[end_index..ACCOUNT_SIZE],
-            [0; TLV_SIZE + EXTRA_SPACE - SMALL_SIZE]
-        );
-
-        // unpack again since we dropped the last `state`
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        // realloc too much, fails
-        assert_eq!(
-            state
-                .realloc_first::<TestValue>(TLV_SIZE + EXTRA_SPACE + 1)
-                .unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-    }
-
-    #[test]
-    fn realloc_with_repeating_entries() {
-        const TLV_SIZE: usize = 10;
-        const EXTRA_SPACE: usize = 5;
-        const SMALL_SIZE: usize = 2;
-        const ACCOUNT_SIZE: usize = get_base_len()
-            + TLV_SIZE
-            + EXTRA_SPACE
-            + get_base_len()
-            + TLV_SIZE
-            + get_base_len()
-            + size_of::<TestNonZeroDefault>();
-        let mut buffer = vec![0; ACCOUNT_SIZE];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        // alloc both types, two for the first type and one for the second
-        let _ = state.alloc::<TestValue>(TLV_SIZE, true).unwrap();
-        let _ = state.alloc::<TestValue>(TLV_SIZE, true).unwrap();
-        let _ = state.init_value::<TestNonZeroDefault>(true).unwrap();
-
-        // realloc first entry to larger, all 0
-        let data = state
-            .realloc_with_repetition::<TestValue>(TLV_SIZE + EXTRA_SPACE, 0)
-            .unwrap();
-        assert_eq!(data, [0; TLV_SIZE + EXTRA_SPACE]);
-        let value = state.get_bytes_with_repetition::<TestValue>(0).unwrap();
-        assert_eq!(*value, [0; TLV_SIZE + EXTRA_SPACE]);
-        let value = state.get_bytes_with_repetition::<TestValue>(1).unwrap();
-        assert_eq!(*value, [0; TLV_SIZE]);
-        let value = state.get_first_value::<TestNonZeroDefault>().unwrap();
-        assert_eq!(*value, TestNonZeroDefault::default());
-
-        // realloc to smaller, still all 0
-        let data = state
-            .realloc_with_repetition::<TestValue>(SMALL_SIZE, 0)
-            .unwrap();
-        assert_eq!(data, [0; SMALL_SIZE]);
-        let value = state.get_bytes_with_repetition::<TestValue>(0).unwrap();
-        assert_eq!(*value, [0; SMALL_SIZE]);
-        let value = state.get_bytes_with_repetition::<TestValue>(1).unwrap();
-        assert_eq!(*value, [0; TLV_SIZE]);
-        let value = state.get_first_value::<TestNonZeroDefault>().unwrap();
-        assert_eq!(*value, TestNonZeroDefault::default());
-        let (_, end_index) = get_discriminators_and_end_index(&buffer).unwrap();
-        assert_eq!(
-            &buffer[end_index..ACCOUNT_SIZE],
-            [0; TLV_SIZE + EXTRA_SPACE - SMALL_SIZE]
-        );
-
-        // unpack again since we dropped the last `state`
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-        // realloc too much, fails
-        assert_eq!(
-            state
-                .realloc_with_repetition::<TestValue>(TLV_SIZE + EXTRA_SPACE + 1, 0)
-                .unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-    }
-
-    #[derive(Clone, Debug, PartialEq)]
-    struct TestVariableLen {
-        data: String, // test with a variable length type
-    }
-    impl SplDiscriminate for TestVariableLen {
-        const SPL_DISCRIMINATOR: ArrayDiscriminator =
-            ArrayDiscriminator::new([5; ArrayDiscriminator::LENGTH]);
-    }
-    impl VariableLenPack for TestVariableLen {
-        fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-            let bytes = self.data.as_bytes();
-            let end = 8 + bytes.len();
-            if dst.len() < end {
-                Err(ProgramError::InvalidAccountData)
-            } else {
-                dst[..8].copy_from_slice(&self.data.len().to_le_bytes());
-                dst[8..end].copy_from_slice(bytes);
-                Ok(())
-            }
-        }
-        fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-            let length = u64::from_le_bytes(src[..8].try_into().unwrap()) as usize;
-            if src[8..8 + length].len() != length {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            let data = std::str::from_utf8(&src[8..8 + length])
-                .unwrap()
-                .to_string();
-            Ok(Self { data })
-        }
-        fn get_packed_len(&self) -> Result<usize, ProgramError> {
-            Ok(size_of::<u64>().saturating_add(self.data.len()))
-        }
-    }
-
-    #[test]
-    fn first_variable_len_value() {
-        let initial_data = "This is a pretty cool test!";
-        // exactly the right size
-        let tlv_size = 8 + initial_data.len();
-        let account_size = get_base_len() + tlv_size;
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        // don't actually need to hold onto the data!
-        let _ = state.alloc::<TestVariableLen>(tlv_size, false).unwrap();
-        let test_variable_len = TestVariableLen {
-            data: initial_data.to_string(),
-        };
-        state
-            .pack_first_variable_len_value(&test_variable_len)
-            .unwrap();
-        let deser = state
-            .get_first_variable_len_value::<TestVariableLen>()
-            .unwrap();
-        assert_eq!(deser, test_variable_len);
-
-        // writing too much data fails
-        let too_much_data = "This is a pretty cool test!?";
-        assert_eq!(
-            state
-                .pack_first_variable_len_value(&TestVariableLen {
-                    data: too_much_data.to_string(),
-                })
-                .unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-    }
-
-    #[test]
-    fn variable_len_value_with_repetition() {
-        let variable_len_1 = TestVariableLen {
-            data: "Let's see if we can pack multiple variable length values".to_string(),
-        };
-        let tlv_size_1 = 8 + variable_len_1.data.len();
-
-        let variable_len_2 = TestVariableLen {
-            data: "I think we can".to_string(),
-        };
-        let tlv_size_2 = 8 + variable_len_2.data.len();
-
-        let variable_len_3 = TestVariableLen {
-            data: "In fact, I know we can!".to_string(),
-        };
-        let tlv_size_3 = 8 + variable_len_3.data.len();
-
-        let variable_len_4 = TestVariableLen {
-            data: "How cool is this?".to_string(),
-        };
-        let tlv_size_4 = 8 + variable_len_4.data.len();
-
-        let account_size = get_base_len()
-            + tlv_size_1
-            + get_base_len()
-            + tlv_size_2
-            + get_base_len()
-            + tlv_size_3
-            + get_base_len()
-            + tlv_size_4;
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        let (_, repetition_number) = state.alloc::<TestVariableLen>(tlv_size_1, true).unwrap();
-        state
-            .pack_variable_len_value_with_repetition(&variable_len_1, repetition_number)
-            .unwrap();
-        assert_eq!(repetition_number, 0);
-        assert_eq!(
-            state
-                .get_first_variable_len_value::<TestVariableLen>()
-                .unwrap(),
-            variable_len_1,
-        );
-
-        let (_, repetition_number) = state.alloc::<TestVariableLen>(tlv_size_2, true).unwrap();
-        state
-            .pack_variable_len_value_with_repetition(&variable_len_2, repetition_number)
-            .unwrap();
-        assert_eq!(repetition_number, 1);
-        assert_eq!(
-            state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap(),
-            variable_len_2,
-        );
-
-        let (_, repetition_number) = state.alloc::<TestVariableLen>(tlv_size_3, true).unwrap();
-        state
-            .pack_variable_len_value_with_repetition(&variable_len_3, repetition_number)
-            .unwrap();
-        assert_eq!(repetition_number, 2);
-        assert_eq!(
-            state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap(),
-            variable_len_3,
-        );
-
-        let (_, repetition_number) = state.alloc::<TestVariableLen>(tlv_size_4, true).unwrap();
-        state
-            .pack_variable_len_value_with_repetition(&variable_len_4, repetition_number)
-            .unwrap();
-        assert_eq!(repetition_number, 3);
-        assert_eq!(
-            state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap(),
-            variable_len_4,
-        );
-    }
-
-    #[test]
-    fn add_entry_mix_and_match() {
-        let mut buffer = vec![];
-
-        // Add an entry for a fixed length value
-        let fixed_data = TestValue { data: [1; 32] };
-        let tlv_size = get_base_len() + size_of::<TestValue>();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let (value, repetition_number) = state.init_value::<TestValue>(true).unwrap();
-            value.data = fixed_data.data;
-            assert_eq!(repetition_number, 0);
-            assert_eq!(*value, fixed_data);
-        }
-
-        // Add an entry for a variable length value
-        let variable_data = TestVariableLen {
-            data: "This is my first variable length entry!".to_string(),
-        };
-        let tlv_size = get_base_len() + 8 + variable_data.data.len();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let repetition_number = state
-                .alloc_and_pack_variable_len_entry(&variable_data, true)
-                .unwrap();
-            let value = state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap();
-            assert_eq!(repetition_number, 0);
-            assert_eq!(value, variable_data);
-        }
-
-        // Add another entry for a variable length value
-        let variable_data = TestVariableLen {
-            data: "This is actually my second variable length entry!".to_string(),
-        };
-        let tlv_size = get_base_len() + 8 + variable_data.data.len();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let repetition_number = state
-                .alloc_and_pack_variable_len_entry(&variable_data, true)
-                .unwrap();
-            let value = state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap();
-            assert_eq!(repetition_number, 1);
-            assert_eq!(value, variable_data);
-        }
-
-        // Add another entry for a fixed length value
-        let fixed_data = TestValue { data: [2; 32] };
-        let tlv_size = get_base_len() + size_of::<TestValue>();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let (value, repetition_number) = state.init_value::<TestValue>(true).unwrap();
-            value.data = fixed_data.data;
-            assert_eq!(repetition_number, 1);
-            assert_eq!(*value, fixed_data);
-        }
-
-        // Add another entry for a fixed length value
-        let fixed_data = TestValue { data: [3; 32] };
-        let tlv_size = get_base_len() + size_of::<TestValue>();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let (value, repetition_number) = state.init_value::<TestValue>(true).unwrap();
-            value.data = fixed_data.data;
-            assert_eq!(repetition_number, 2);
-            assert_eq!(*value, fixed_data);
-        }
-
-        // Add another entry for a variable length value
-        let variable_data = TestVariableLen {
-            data: "Wow! My third variable length entry!".to_string(),
-        };
-        let tlv_size = get_base_len() + 8 + variable_data.data.len();
-        buffer.extend(vec![0; tlv_size]);
-        {
-            let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-            let repetition_number = state
-                .alloc_and_pack_variable_len_entry(&variable_data, true)
-                .unwrap();
-            let value = state
-                .get_variable_len_value_with_repetition::<TestVariableLen>(repetition_number)
-                .unwrap();
-            assert_eq!(repetition_number, 2);
-            assert_eq!(value, variable_data);
-        }
-    }
-}
diff --git a/libraries/type-length-value/src/variable_len_pack.rs b/libraries/type-length-value/src/variable_len_pack.rs
deleted file mode 100644
index 1840298e5ac..00000000000
--- a/libraries/type-length-value/src/variable_len_pack.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//! The [`VariableLenPack`] serialization trait.
-
-use solana_program::program_error::ProgramError;
-
-/// Trait that mimics a lot of the functionality of
-/// `solana_program::program_pack::Pack` but specifically works for
-/// variable-size types.
-pub trait VariableLenPack {
-    /// Writes the serialized form of the instance into the given slice
-    fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), ProgramError>;
-
-    /// Deserializes the type from the given slice
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError>
-    where
-        Self: Sized;
-
-    /// Gets the packed length for a given instance of the type
-    fn get_packed_len(&self) -> Result<usize, ProgramError>;
-
-    /// Safely write the contents to the type into the given slice
-    fn pack(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-        if dst.len() != self.get_packed_len()? {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        self.pack_into_slice(dst)
-    }
-}
diff --git a/managed-token/program/Cargo.toml b/managed-token/program/Cargo.toml
index bba91a1f40b..e7ce24bfad2 100644
--- a/managed-token/program/Cargo.toml
+++ b/managed-token/program/Cargo.toml
@@ -22,17 +22,18 @@ default = []
 test = []
 
 [dependencies]
-borsh = "1.5.1"
+borsh = "1.5.3"
 shank = "^0.4.2"
-solana-program = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
+solana-program = "2.1.0"
+spl-associated-token-account = { version = "6.0.0", features = [
   "no-entrypoint",
 ] }
-spl-token = { version = "4.0", path = "../../token/program", features = [
+spl-associated-token-account-client = { version = "2.0.0" }
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-thiserror = "^1.0.61"
+thiserror = "^2.0.9"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
diff --git a/managed-token/program/src/accounts.rs b/managed-token/program/src/accounts.rs
index 01bc6b44f7f..94f980aa6ef 100644
--- a/managed-token/program/src/accounts.rs
+++ b/managed-token/program/src/accounts.rs
@@ -116,7 +116,7 @@ impl<'a, 'info> InitializeAccount<'a, 'info> {
             "Invalid key supplied for System Program",
         )?;
         assert_with_msg(
-            ctx.associated_token_program.key == &spl_associated_token_account::id(),
+            ctx.associated_token_program.key == &spl_associated_token_account_client::program::id(),
             ProgramError::InvalidInstructionData,
             "Invalid key supplied for Associataed Token Program",
         )?;
diff --git a/managed-token/program/src/instruction.rs b/managed-token/program/src/instruction.rs
index d6dd8e46e76..bf22c82c817 100644
--- a/managed-token/program/src/instruction.rs
+++ b/managed-token/program/src/instruction.rs
@@ -8,7 +8,7 @@ use {
         pubkey::Pubkey,
         system_program,
     },
-    spl_associated_token_account::get_associated_token_address,
+    spl_associated_token_account_client::address::get_associated_token_address,
 };
 
 #[derive(Debug, Clone, ShankInstruction, BorshSerialize, BorshDeserialize)]
@@ -127,7 +127,7 @@ pub fn create_initialize_account_instruction(
             AccountMeta::new_readonly(freeze_authority, false),
             AccountMeta::new_readonly(*mint, false),
             AccountMeta::new_readonly(system_program::id(), false),
-            AccountMeta::new_readonly(spl_associated_token_account::id(), false),
+            AccountMeta::new_readonly(spl_associated_token_account_client::program::id(), false),
             AccountMeta::new_readonly(spl_token::id(), false),
         ],
         data: borsh::to_vec(&ManagedTokenInstruction::InitializeAccount)?,
diff --git a/managed-token/program/tests/test.rs b/managed-token/program/tests/test.rs
index 7ddaf49ca09..3d7600d0237 100644
--- a/managed-token/program/tests/test.rs
+++ b/managed-token/program/tests/test.rs
@@ -10,9 +10,8 @@ use {
         system_instruction,
         transaction::Transaction,
     },
-    spl_associated_token_account::{
-        get_associated_token_address, instruction::create_associated_token_account,
-    },
+    spl_associated_token_account::instruction::create_associated_token_account,
+    spl_associated_token_account_client::address::get_associated_token_address,
     spl_managed_token::instruction::*,
     spl_token::state::Account as TokenAccount,
 };
diff --git a/managed-token/sdk/.solitarc.js b/managed-token/sdk/.solitarc.js
index 899a10ebde8..c759620a057 100644
--- a/managed-token/sdk/.solitarc.js
+++ b/managed-token/sdk/.solitarc.js
@@ -1,14 +1,14 @@
-const path = require("path");
-const programDir = path.join(__dirname, "..", "program");
-const idlDir = path.join(__dirname, "idl");
-const sdkDir = path.join(__dirname, "src", "generated");
-const binaryInstallDir = path.join(__dirname, "..", "..", "target", "solita");
+const path = require('path');
+const programDir = path.join(__dirname, '..', 'program');
+const idlDir = path.join(__dirname, 'idl');
+const sdkDir = path.join(__dirname, 'src', 'generated');
+const binaryInstallDir = path.join(__dirname, '..', '..', 'target', 'solita');
 
 module.exports = {
-  idlGenerator: "shank",
-  programName: "spl_managed_token",
-  idlDir,
-  sdkDir,
-  binaryInstallDir,
-  programDir,
+    idlGenerator: 'shank',
+    programName: 'spl_managed_token',
+    idlDir,
+    sdkDir,
+    binaryInstallDir,
+    programDir,
 };
diff --git a/managed-token/sdk/yarn.lock b/managed-token/sdk/yarn.lock
index 9bb3707ceef..5cb1a78cdf3 100644
--- a/managed-token/sdk/yarn.lock
+++ b/managed-token/sdk/yarn.lock
@@ -522,14 +522,14 @@ whatwg-url@^5.0.0:
     webidl-conversions "^3.0.0"
 
 ws@^7.4.5:
-  version "7.5.9"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
-  integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
+  version "7.5.10"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.10.tgz#58b5c20dc281633f6c19113f39b349bd8bd558d9"
+  integrity sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==
 
 ws@^8.5.0:
-  version "8.8.1"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-8.8.1.tgz#5dbad0feb7ade8ecc99b830c1d77c913d4955ff0"
-  integrity sha512-bGy2JzvzkPowEJV++hF07hAD6niYSr0JzBNo/J29WsB57A2r7Wlc1UFcTR9IzrPvuNVO4B8LGqF8qcpsVOhJCA==
+  version "8.17.1"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.17.1.tgz#9293da530bb548febc95371d90f9c878727d919b"
+  integrity sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==
 
 yallist@^4.0.0:
   version "4.0.0"
diff --git a/memo/README.md b/memo/README.md
index e195553d405..71ece75d71f 100644
--- a/memo/README.md
+++ b/memo/README.md
@@ -1,3 +1,6 @@
+NOTE: The memo program and clients are now maintained at
+[solana-program/memo](https://github.com/solana-program/memo).
+
 # Memo Program
 
 A simple program that validates a string of UTF-8 encoded characters and logs it
diff --git a/memo/js/.editorconfig b/memo/js/.editorconfig
deleted file mode 100644
index 3e10c03d05b..00000000000
--- a/memo/js/.editorconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 4
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
\ No newline at end of file
diff --git a/memo/js/.eslintignore b/memo/js/.eslintignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/memo/js/.eslintignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/memo/js/.eslintrc b/memo/js/.eslintrc
deleted file mode 100644
index 0a82d0c7b1a..00000000000
--- a/memo/js/.eslintrc
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-    "root": true,
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended",
-        "plugin:require-extensions/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier",
-        "require-extensions"
-    ],
-    "rules": {
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/consistent-type-imports": "error"
-    },
-    "overrides": [
-        {
-            "files": [
-                "test/**/*"
-            ],
-            "rules": {
-                "require-extensions/require-extensions": "off"
-            }
-        }
-    ]
-}
diff --git a/memo/js/.gitignore b/memo/js/.gitignore
deleted file mode 100644
index 21f33db819c..00000000000
--- a/memo/js/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.idea
-.vscode
-.DS_Store
-
-node_modules
-
-pnpm-lock.yaml
-yarn.lock
-
-docs
-lib
-test-ledger
-*.tsbuildinfo
diff --git a/memo/js/.nojekyll b/memo/js/.nojekyll
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/memo/js/.prettierignore b/memo/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/memo/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/memo/js/.prettierrc b/memo/js/.prettierrc
deleted file mode 100644
index b9ce4c1923a..00000000000
--- a/memo/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "printWidth": 120,
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}
\ No newline at end of file
diff --git a/memo/js/LICENSE b/memo/js/LICENSE
deleted file mode 100644
index 6b0b1270ff0..00000000000
--- a/memo/js/LICENSE
+++ /dev/null
@@ -1,203 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
diff --git a/memo/js/README.md b/memo/js/README.md
deleted file mode 100644
index 1622cff7678..00000000000
--- a/memo/js/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# `@solana/spl-memo`
-
-A TypeScript library for interacting with the SPL Memo program.
-
-## Links
-
-- [TypeScript Docs](https://solana-labs.github.io/solana-program-library/memo/js/)
-- [Install](#install)
-- [Build from Source](#build-from-source)
-
-## Install
-
-```shell
-npm install --save @solana/spl-memo @solana/web3.js
-```
-_OR_
-```shell
-yarn add @solana/spl-memo @solana/web3.js
-```
-
-## Build from Source
-
-0. Prerequisites
-
-* Node 16+
-* NPM 8+
-
-1. Clone the project:
-```shell
-git clone https://github.com/solana-labs/solana-program-library.git
-```
-
-2. Navigate to the library:
-```shell
-cd solana-program-library/memo/js
-```
-
-3. Install the dependencies:
-```shell
-npm install
-```
-
-4. Build the library:
-```shell
-npm run build
-```
-
-5. Run the tests:
-```shell
-npm run test
-```
diff --git a/memo/js/jest.config.ts b/memo/js/jest.config.ts
deleted file mode 100644
index 586fb9fe3d1..00000000000
--- a/memo/js/jest.config.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import type { JestConfigWithTsJest } from 'ts-jest';
-
-const jestConfig: JestConfigWithTsJest = {
-    preset: 'ts-jest/presets/default-esm',
-};
-
-export default jestConfig;
diff --git a/memo/js/package.json b/memo/js/package.json
deleted file mode 100644
index 478427bd14b..00000000000
--- a/memo/js/package.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
-    "name": "@solana/spl-memo",
-    "description": "SPL Memo Program JS API",
-    "version": "0.2.4",
-    "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "repository": "https://github.com/solana-labs/solana-program-library",
-    "license": "Apache-2.0",
-    "type": "module",
-    "sideEffects": false,
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "lib",
-        "src",
-        "LICENSE",
-        "README.md"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "./lib/cjs/index.js",
-    "module": "./lib/esm/index.js",
-    "types": "./lib/types/index.d.ts",
-    "exports": {
-        "types": "./lib/types/index.d.ts",
-        "require": "./lib/cjs/index.js",
-        "import": "./lib/esm/index.js"
-    },
-    "scripts": {
-        "nuke": "shx rm -rf node_modules package-lock.json || true",
-        "reinstall": "npm run nuke && npm install",
-        "clean": "shx rm -rf lib **/*.tsbuildinfo || true",
-        "build": "tsc --build --verbose tsconfig.all.json",
-        "postbuild": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json",
-        "watch": "tsc --build --verbose --watch tsconfig.all.json",
-        "release": "npm run clean && npm run build",
-        "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-        "lint": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}' && eslint --max-warnings 0 .",
-        "lint:fix": "npm run fmt && eslint --fix .",
-        "test": "npm run test:unit && npm run test:e2e",
-        "test:unit": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest test/unit",
-        "test:e2e": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" start-server-and-test 'solana-test-validator -r -q' http://127.0.0.1:8899/health 'jest test/e2e'",
-        "deploy": "npm run deploy:docs",
-        "docs": "shx rm -rf docs && typedoc && shx cp .nojekyll docs/",
-        "deploy:docs": "npm run docs && gh-pages --dest memo/js --dist docs --dotfiles"
-    },
-    "peerDependencies": {
-        "@solana/web3.js": "^1.93.0"
-    },
-    "dependencies": {
-        "buffer": "^6.0.3"
-    },
-    "devDependencies": {
-        "@solana/web3.js": "^1.93.0",
-        "@types/chai": "^4.3.16",
-        "@types/jest": "^29.5.12",
-        "@types/node": "^20.14.5",
-        "@types/node-fetch": "^2.6.11",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
-        "chai": "^5.1.1",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "eslint-plugin-require-extensions": "^0.1.1",
-        "gh-pages": "^6.1.1",
-        "jest": "^29.0.0",
-        "prettier": "^3.3.2",
-        "process": "^0.11.10",
-        "shx": "^0.3.4",
-        "start-server-and-test": "^2.0.4",
-        "ts-jest": "^29.1.5",
-        "ts-node": "^10.9.2",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
-    }
-}
diff --git a/memo/js/src/index.ts b/memo/js/src/index.ts
deleted file mode 100644
index 67f2c12aa43..00000000000
--- a/memo/js/src/index.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { Buffer } from 'buffer';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-
-export const MEMO_PROGRAM_ID: PublicKey = new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr');
-
-/**
- * Creates and returns an instruction which validates a string of UTF-8
- * encoded characters and verifies that any accounts provided are signers of
- * the transaction.  The program also logs the memo, as well as any verified
- * signer addresses, to the transaction log, so that anyone can easily observe
- * memos and know they were approved by zero or more addresses by inspecting
- * the transaction log from a trusted provider.
- *
- * Public keys passed in via the signerPubkeys will identify Signers which
- * must subsequently sign the Transaction including the returned
- * TransactionInstruction in order for the transaction to be valid.
- *
- * @param memo The UTF-8 encoded memo string to validate
- * @param signerPubkeys An array of public keys which must sign the
- *        Transaction including the returned TransactionInstruction in order
- *        for the transaction to be valid and the memo verification to
- *        succeed.  null is allowed if there are no signers for the memo
- *        verification.
- **/
-export function createMemoInstruction(memo: string, signerPubkeys?: Array<PublicKey>): TransactionInstruction {
-    const keys =
-        signerPubkeys == null
-            ? []
-            : signerPubkeys.map(function (key) {
-                  return { pubkey: key, isSigner: true, isWritable: false };
-              });
-
-    return new TransactionInstruction({
-        keys: keys,
-        programId: MEMO_PROGRAM_ID,
-        data: Buffer.from(memo, 'utf8'),
-    });
-}
diff --git a/memo/js/test/e2e/transaction.test.ts b/memo/js/test/e2e/transaction.test.ts
deleted file mode 100644
index 0d7cd62871c..00000000000
--- a/memo/js/test/e2e/transaction.test.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { createMemoInstruction } from '../../src/index';
-import { Connection, Keypair, Transaction, LAMPORTS_PER_SOL, sendAndConfirmTransaction } from '@solana/web3.js';
-
-test('transaction: live', async () => {
-    const url = 'http://127.0.0.1:8899';
-    const connection = new Connection(url, 'confirmed');
-    await connection.getVersion();
-    const signer = new Keypair(); // also fee-payer
-
-    const airdropSignature = await connection.requestAirdrop(signer.publicKey, LAMPORTS_PER_SOL / 10);
-    await connection.confirmTransaction(airdropSignature, 'confirmed');
-
-    const memoTx = new Transaction().add(createMemoInstruction('this is a test memo', [signer.publicKey]));
-    await sendAndConfirmTransaction(connection, memoTx, [signer], {
-        preflightCommitment: 'confirmed',
-    });
-});
diff --git a/memo/js/test/unit/index.test.ts b/memo/js/test/unit/index.test.ts
deleted file mode 100644
index 94f3309056a..00000000000
--- a/memo/js/test/unit/index.test.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { createMemoInstruction, MEMO_PROGRAM_ID } from '../../src/index';
-import { expect } from 'chai';
-import { Keypair } from '@solana/web3.js';
-
-test('instruction: no signers', () => {
-    const ix = createMemoInstruction('this is a test memo', []);
-    expect(ix.programId).to.eql(MEMO_PROGRAM_ID);
-    expect(ix.keys).to.have.length(0);
-    expect(ix.data).to.have.length(19);
-
-    const ix2 = createMemoInstruction('this is a test');
-    expect(ix2.programId).to.eql(MEMO_PROGRAM_ID);
-    expect(ix2.keys).to.have.length(0);
-    expect(ix2.data).to.have.length(14);
-});
-
-test('instruction: one signer', () => {
-    const signer = new Keypair();
-    const ix = createMemoInstruction('this is a test memo', [signer.publicKey]);
-    expect(ix.programId).to.eql(MEMO_PROGRAM_ID);
-    expect(ix.keys).to.have.length(1);
-    expect(ix.data).to.have.length(19);
-});
-
-test('instruction: many signers', () => {
-    const signer0 = new Keypair();
-    const signer1 = new Keypair();
-    const signer2 = new Keypair();
-    const signer3 = new Keypair();
-    const signer4 = new Keypair();
-    const ix = createMemoInstruction('this is a test memo', [
-        signer0.publicKey,
-        signer1.publicKey,
-        signer2.publicKey,
-        signer3.publicKey,
-        signer4.publicKey,
-    ]);
-    expect(ix.programId).to.eql(MEMO_PROGRAM_ID);
-    expect(ix.keys).to.have.length(5);
-    expect(ix.data).to.have.length(19);
-});
diff --git a/memo/js/tsconfig.all.json b/memo/js/tsconfig.all.json
deleted file mode 100644
index 985513259e2..00000000000
--- a/memo/js/tsconfig.all.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.root.json",
-    "references": [
-        {
-            "path": "./tsconfig.cjs.json"
-        },
-        {
-            "path": "./tsconfig.esm.json"
-        }
-    ]
-}
diff --git a/memo/js/tsconfig.base.json b/memo/js/tsconfig.base.json
deleted file mode 100644
index 90620c4e485..00000000000
--- a/memo/js/tsconfig.base.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "include": [],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "stripInternal": true
-    }
-}
diff --git a/memo/js/tsconfig.cjs.json b/memo/js/tsconfig.cjs.json
deleted file mode 100644
index 2db9b71569e..00000000000
--- a/memo/js/tsconfig.cjs.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/cjs",
-        "target": "ES2016",
-        "module": "CommonJS",
-        "sourceMap": true
-    }
-}
diff --git a/memo/js/tsconfig.esm.json b/memo/js/tsconfig.esm.json
deleted file mode 100644
index 25e7e25e751..00000000000
--- a/memo/js/tsconfig.esm.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/esm",
-        "declarationDir": "lib/types",
-        "target": "ES2020",
-        "module": "ES2020",
-        "sourceMap": true,
-        "declaration": true,
-        "declarationMap": true
-    }
-}
diff --git a/memo/js/tsconfig.json b/memo/js/tsconfig.json
deleted file mode 100644
index 2f9b239bfca..00000000000
--- a/memo/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig.all.json",
-    "include": ["src", "test"],
-    "compilerOptions": {
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
diff --git a/memo/js/tsconfig.root.json b/memo/js/tsconfig.root.json
deleted file mode 100644
index fadf294ab43..00000000000
--- a/memo/js/tsconfig.root.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "compilerOptions": {
-        "composite": true
-    }
-}
diff --git a/memo/js/typedoc.json b/memo/js/typedoc.json
deleted file mode 100644
index c39fc53aee1..00000000000
--- a/memo/js/typedoc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md"
-}
diff --git a/memo/program/Cargo.toml b/memo/program/Cargo.toml
deleted file mode 100644
index a7d401ebd65..00000000000
--- a/memo/program/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[package]
-name = "spl-memo"
-version = "4.0.1"
-description = "Solana Program Library Memo"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-solana-program = ">=1.18.11,<=2"
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/memo/program/Xargo.toml b/memo/program/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/memo/program/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/memo/program/program-id.md b/memo/program/program-id.md
deleted file mode 100644
index 284ff6d8137..00000000000
--- a/memo/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr
diff --git a/memo/program/src/entrypoint.rs b/memo/program/src/entrypoint.rs
deleted file mode 100644
index 8876e45b78b..00000000000
--- a/memo/program/src/entrypoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Program entrypoint
-
-#![cfg(not(feature = "no-entrypoint"))]
-
-use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    crate::processor::process_instruction(program_id, accounts, instruction_data)
-}
diff --git a/memo/program/src/lib.rs b/memo/program/src/lib.rs
deleted file mode 100644
index fa792b8bb81..00000000000
--- a/memo/program/src/lib.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-#![deny(missing_docs)]
-
-//! A program that accepts a string of encoded characters and verifies that it
-//! parses, while verifying and logging signers. Currently handles UTF-8
-//! characters.
-
-mod entrypoint;
-pub mod processor;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-use solana_program::{
-    instruction::{AccountMeta, Instruction},
-    pubkey::Pubkey,
-};
-
-/// Legacy symbols from Memo v1
-pub mod v1 {
-    solana_program::declare_id!("Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo");
-}
-
-solana_program::declare_id!("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
-
-/// Build a memo instruction, possibly signed
-///
-/// Accounts expected by this instruction:
-///
-///   0. ..0+N. `[signer]` Expected signers; if zero provided, instruction will
-///     be processed as a normal, unsigned spl-memo
-pub fn build_memo(memo: &[u8], signer_pubkeys: &[&Pubkey]) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: signer_pubkeys
-            .iter()
-            .map(|&pubkey| AccountMeta::new_readonly(*pubkey, true))
-            .collect(),
-        data: memo.to_vec(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_build_memo() {
-        let signer_pubkey = Pubkey::new_unique();
-        let memo = "🐆".as_bytes();
-        let instruction = build_memo(memo, &[&signer_pubkey]);
-        assert_eq!(memo, instruction.data);
-        assert_eq!(instruction.accounts.len(), 1);
-        assert_eq!(instruction.accounts[0].pubkey, signer_pubkey);
-    }
-}
diff --git a/memo/program/src/processor.rs b/memo/program/src/processor.rs
deleted file mode 100644
index 57ca6ba382a..00000000000
--- a/memo/program/src/processor.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! Program state processor
-
-use {
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, msg, program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    std::str::from_utf8,
-};
-
-/// Instruction processor
-pub fn process_instruction(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mut missing_required_signature = false;
-    for account_info in account_info_iter {
-        if let Some(address) = account_info.signer_key() {
-            msg!("Signed by {:?}", address);
-        } else {
-            missing_required_signature = true;
-        }
-    }
-    if missing_required_signature {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    let memo = from_utf8(input).map_err(|err| {
-        msg!("Invalid UTF-8, from byte {}", err.valid_up_to());
-        ProgramError::InvalidInstructionData
-    })?;
-    msg!("Memo (len {}): {:?}", memo.len(), memo);
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        solana_program::{
-            account_info::IntoAccountInfo, program_error::ProgramError, pubkey::Pubkey,
-        },
-        solana_sdk::account::Account,
-    };
-
-    #[test]
-    fn test_utf8_memo() {
-        let program_id = Pubkey::new_from_array([0; 32]);
-
-        let string = b"letters and such";
-        assert_eq!(Ok(()), process_instruction(&program_id, &[], string));
-
-        let emoji = "🐆".as_bytes();
-        let bytes = [0xF0, 0x9F, 0x90, 0x86];
-        assert_eq!(emoji, bytes);
-        assert_eq!(Ok(()), process_instruction(&program_id, &[], emoji));
-
-        let mut bad_utf8 = bytes;
-        bad_utf8[3] = 0xFF; // Invalid UTF-8 byte
-        assert_eq!(
-            Err(ProgramError::InvalidInstructionData),
-            process_instruction(&program_id, &[], &bad_utf8)
-        );
-    }
-
-    #[test]
-    fn test_signers() {
-        let program_id = Pubkey::new_from_array([0; 32]);
-        let memo = "🐆".as_bytes();
-
-        let pubkey0 = Pubkey::new_unique();
-        let pubkey1 = Pubkey::new_unique();
-        let pubkey2 = Pubkey::new_unique();
-        let mut account0 = Account::default();
-        let mut account1 = Account::default();
-        let mut account2 = Account::default();
-
-        let signed_account_infos = vec![
-            (&pubkey0, true, &mut account0).into_account_info(),
-            (&pubkey1, true, &mut account1).into_account_info(),
-            (&pubkey2, true, &mut account2).into_account_info(),
-        ];
-        assert_eq!(
-            Ok(()),
-            process_instruction(&program_id, &signed_account_infos, memo)
-        );
-
-        assert_eq!(Ok(()), process_instruction(&program_id, &[], memo));
-
-        let unsigned_account_infos = vec![
-            (&pubkey0, false, &mut account0).into_account_info(),
-            (&pubkey1, false, &mut account1).into_account_info(),
-            (&pubkey2, false, &mut account2).into_account_info(),
-        ];
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            process_instruction(&program_id, &unsigned_account_infos, memo)
-        );
-
-        let partially_signed_account_infos = vec![
-            (&pubkey0, true, &mut account0).into_account_info(),
-            (&pubkey1, false, &mut account1).into_account_info(),
-            (&pubkey2, true, &mut account2).into_account_info(),
-        ];
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            process_instruction(&program_id, &partially_signed_account_infos, memo)
-        );
-    }
-}
diff --git a/memo/program/tests/functional.rs b/memo/program/tests/functional.rs
deleted file mode 100644
index 91fef7e12ab..00000000000
--- a/memo/program/tests/functional.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program::{
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_memo::*,
-};
-
-fn program_test() -> ProgramTest {
-    ProgramTest::new("spl_memo", id(), processor!(processor::process_instruction))
-}
-
-#[tokio::test]
-async fn test_memo_signing() {
-    let memo = "🐆".as_bytes();
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-
-    let keypairs = vec![Keypair::new(), Keypair::new(), Keypair::new()];
-    let pubkeys: Vec<Pubkey> = keypairs.iter().map(|keypair| keypair.pubkey()).collect();
-
-    // Test complete signing
-    let signer_key_refs: Vec<&Pubkey> = pubkeys.iter().collect();
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(memo, &signer_key_refs)], Some(&payer.pubkey()));
-    let mut signers = vec![&payer];
-    for keypair in keypairs.iter() {
-        signers.push(keypair);
-    }
-    transaction.sign(&signers, recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Test unsigned memo
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(memo, &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Demonstrate success on signature provided, regardless of specific memo
-    // AccountMeta
-    let mut transaction = Transaction::new_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new_readonly(keypairs[0].pubkey(), true),
-                AccountMeta::new_readonly(keypairs[1].pubkey(), true),
-                AccountMeta::new_readonly(payer.pubkey(), false),
-            ],
-            data: memo.to_vec(),
-        }],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &keypairs[0], &keypairs[1]], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Test missing signer(s)
-    let mut transaction = Transaction::new_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new_readonly(keypairs[0].pubkey(), true),
-                AccountMeta::new_readonly(keypairs[1].pubkey(), false),
-                AccountMeta::new_readonly(keypairs[2].pubkey(), true),
-            ],
-            data: memo.to_vec(),
-        }],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &keypairs[0], &keypairs[2]], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-
-    let mut transaction = Transaction::new_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new_readonly(keypairs[0].pubkey(), false),
-                AccountMeta::new_readonly(keypairs[1].pubkey(), false),
-                AccountMeta::new_readonly(keypairs[2].pubkey(), false),
-            ],
-            data: memo.to_vec(),
-        }],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-
-    // Test invalid utf-8; demonstrate log
-    let invalid_utf8 = [0xF0, 0x9F, 0x90, 0x86, 0xF0, 0x9F, 0xFF, 0x86];
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(&invalid_utf8, &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    assert_eq!(
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidInstructionData)
-    );
-}
-
-#[tokio::test]
-#[ignore]
-async fn test_memo_compute_limits() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-
-    // Test memo length
-    let mut memo = vec![];
-    for _ in 0..1000 {
-        let mut vec = vec![0x53, 0x4F, 0x4C];
-        memo.append(&mut vec);
-    }
-
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(&memo[..450], &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(&memo[..600], &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    let err = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    let failed_to_complete =
-        TransactionError::InstructionError(0, InstructionError::ProgramFailedToComplete);
-    let computational_budget_exceeded =
-        TransactionError::InstructionError(0, InstructionError::ComputationalBudgetExceeded);
-    assert!(err == failed_to_complete || err == computational_budget_exceeded);
-
-    let mut memo = vec![];
-    for _ in 0..100 {
-        let mut vec = vec![0xE2, 0x97, 0x8E];
-        memo.append(&mut vec);
-    }
-
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(&memo[..60], &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let mut transaction =
-        Transaction::new_with_payer(&[build_memo(&memo[..63], &[])], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    let err = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert!(err == failed_to_complete || err == computational_budget_exceeded);
-
-    // Test num signers with 32-byte memo
-    let memo = Pubkey::new_unique().to_bytes();
-    let mut keypairs = vec![];
-    for _ in 0..20 {
-        keypairs.push(Keypair::new());
-    }
-    let pubkeys: Vec<Pubkey> = keypairs.iter().map(|keypair| keypair.pubkey()).collect();
-    let signer_key_refs: Vec<&Pubkey> = pubkeys.iter().collect();
-
-    let mut signers = vec![&payer];
-    for keypair in keypairs[..12].iter() {
-        signers.push(keypair);
-    }
-    let mut transaction = Transaction::new_with_payer(
-        &[build_memo(&memo, &signer_key_refs[..12])],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&signers, recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let mut signers = vec![&payer];
-    for keypair in keypairs[..15].iter() {
-        signers.push(keypair);
-    }
-    let mut transaction = Transaction::new_with_payer(
-        &[build_memo(&memo, &signer_key_refs[..15])],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&signers, recent_blockhash);
-    let err = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert!(err == failed_to_complete || err == computational_budget_exceeded);
-}
diff --git a/name-service/js/.prettierignore b/name-service/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/name-service/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/name-service/js/jest.config.ts b/name-service/js/jest.config.ts
index 56a444ea2d5..e584adb3225 100644
--- a/name-service/js/jest.config.ts
+++ b/name-service/js/jest.config.ts
@@ -1,7 +1,7 @@
 import type { JestConfigWithTsJest } from 'ts-jest';
 
 const jestConfig: JestConfigWithTsJest = {
-  preset: 'ts-jest/presets/default-esm',
+    preset: 'ts-jest',
 };
 
 export default jestConfig;
diff --git a/name-service/js/package.json b/name-service/js/package.json
index e22282c6d94..430b70d689c 100644
--- a/name-service/js/package.json
+++ b/name-service/js/package.json
@@ -34,40 +34,33 @@
     "build": "tsc --build --verbose tsconfig.all.json",
     "build:program": "cargo build-sbf --manifest-path=../program/Cargo.toml",
     "prepublish": "tsc",
-    "lint": "npm run pretty && eslint --max-warnings 0 'src/*.ts'",
-    "lint:fix": "npm run pretty:fix && eslint 'src/*.ts' --fix",
-    "pretty": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}'",
-    "pretty:fix": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
+    "lint": "eslint --max-warnings 0 'src/*.ts'",
+    "lint:fix": "eslint 'src/*.ts' --fix",
     "doc": "npm run typedoc src/index.ts",
     "test": "npm run test:unit && npm run test:e2e",
     "test:unit": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest test/unit",
     "test:e2e": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" start-server-and-test 'solana-test-validator --bpf-program namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX ../../target/deploy/spl_name_service.so --reset --quiet' http://127.0.0.1:8899/health 'jest test/e2e'"
   },
-  "prettier": {
-    "singleQuote": true
-  },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
-    "@types/bn.js": "^5.1.1",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.5",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
+    "@types/bn.js": "^5.1.6",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.5",
+    "@typescript-eslint/eslint-plugin": "^8.4.0",
+    "@typescript-eslint/parser": "^8.4.0",
     "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-functional": "^6.5.1",
-    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-functional": "^7.2.1",
+    "eslint-plugin-import": "^2.31.0",
     "jest": "^29.7.0",
-    "prettier": "^3.3.2",
-    "start-server-and-test": "^2.0.4",
-    "ts-jest": "^29.1.5",
+    "start-server-and-test": "^2.0.9",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.25.13",
-    "typescript": "^5.4.5"
+    "typedoc": "^0.27.6",
+    "typescript": "^5.7.2"
   },
   "dependencies": {
-    "@solana/web3.js": "^1.93.0",
+    "@solana/web3.js": "^1.95.5",
     "bn.js": "^5.1.3",
     "borsh": "^2.0.0"
   }
diff --git a/name-service/js/src/bindings.ts b/name-service/js/src/bindings.ts
index b0f9a095b84..b2377c51967 100644
--- a/name-service/js/src/bindings.ts
+++ b/name-service/js/src/bindings.ts
@@ -1,31 +1,19 @@
-import {
-  Connection,
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-} from '@solana/web3.js';
+import { Connection, PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
 
 import {
-  createInstruction,
-  deleteInstruction,
-  reallocInstruction,
-  transferInstruction,
-  updateInstruction,
+    createInstruction,
+    deleteInstruction,
+    reallocInstruction,
+    transferInstruction,
+    updateInstruction,
 } from './instructions';
 import { NameRegistryState } from './state';
 import { Numberu64 } from './utils';
-import {
-  getHashedName,
-  getNameAccountKey,
-  getNameOwner,
-  Numberu32,
-} from './utils';
+import { getHashedName, getNameAccountKey, getNameOwner, Numberu32 } from './utils';
 
 ////////////////////////////////////////////////////////////
 
-export const NAME_PROGRAM_ID = new PublicKey(
-  'namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX',
-);
+export const NAME_PROGRAM_ID = new PublicKey('namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX');
 export const HASH_PREFIX = 'SPL Name Service';
 
 ////////////////////////////////////////////////////////////
@@ -43,47 +31,41 @@ export const HASH_PREFIX = 'SPL Name Service';
  * @returns
  */
 export async function createNameRegistry(
-  connection: Connection,
-  name: string,
-  space: number,
-  payerKey: PublicKey,
-  nameOwner: PublicKey,
-  lamports?: number,
-  nameClass?: PublicKey,
-  parentName?: PublicKey,
+    connection: Connection,
+    name: string,
+    space: number,
+    payerKey: PublicKey,
+    nameOwner: PublicKey,
+    lamports?: number,
+    nameClass?: PublicKey,
+    parentName?: PublicKey,
 ): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    parentName,
-  );
-
-  const balance = lamports
-    ? lamports
-    : await connection.getMinimumBalanceForRentExemption(space);
-
-  let nameParentOwner: PublicKey | undefined;
-  if (parentName) {
-    const parentAccount = await getNameOwner(connection, parentName);
-    nameParentOwner = parentAccount.owner;
-  }
-
-  const createNameInstr = createInstruction(
-    NAME_PROGRAM_ID,
-    SystemProgram.programId,
-    nameAccountKey,
-    nameOwner,
-    payerKey,
-    hashed_name,
-    new Numberu64(balance),
-    new Numberu32(space),
-    nameClass,
-    parentName,
-    nameParentOwner,
-  );
-
-  return createNameInstr;
+    const hashed_name = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashed_name, nameClass, parentName);
+
+    const balance = lamports ? lamports : await connection.getMinimumBalanceForRentExemption(space);
+
+    let nameParentOwner: PublicKey | undefined;
+    if (parentName) {
+        const parentAccount = await getNameOwner(connection, parentName);
+        nameParentOwner = parentAccount.owner;
+    }
+
+    const createNameInstr = createInstruction(
+        NAME_PROGRAM_ID,
+        SystemProgram.programId,
+        nameAccountKey,
+        nameOwner,
+        payerKey,
+        hashed_name,
+        new Numberu64(balance),
+        new Numberu32(space),
+        nameClass,
+        parentName,
+        nameParentOwner,
+    );
+
+    return createNameInstr;
 }
 
 /**
@@ -97,38 +79,33 @@ export async function createNameRegistry(
  * @param nameParent The parent name of this name, if it exists
  */
 export async function updateNameRegistryData(
-  connection: Connection,
-  name: string,
-  offset: number,
-  input_data: Buffer,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
+    connection: Connection,
+    name: string,
+    offset: number,
+    input_data: Buffer,
+    nameClass?: PublicKey,
+    nameParent?: PublicKey,
 ): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent,
-  );
-
-  let signer: PublicKey;
-  if (nameClass) {
-    signer = nameClass;
-  } else {
-    signer = (await NameRegistryState.retrieve(connection, nameAccountKey))
-      .owner;
-  }
-
-  const updateInstr = updateInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    new Numberu32(offset),
-    input_data,
-    signer,
-    nameParent,
-  );
-
-  return updateInstr;
+    const hashed_name = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashed_name, nameClass, nameParent);
+
+    let signer: PublicKey;
+    if (nameClass) {
+        signer = nameClass;
+    } else {
+        signer = (await NameRegistryState.retrieve(connection, nameAccountKey)).owner;
+    }
+
+    const updateInstr = updateInstruction(
+        NAME_PROGRAM_ID,
+        nameAccountKey,
+        new Numberu32(offset),
+        input_data,
+        signer,
+        nameParent,
+    );
+
+    return updateInstr;
 }
 
 /**
@@ -143,38 +120,32 @@ export async function updateNameRegistryData(
  * @returns
  */
 export async function transferNameOwnership(
-  connection: Connection,
-  name: string,
-  newOwner: PublicKey,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
+    connection: Connection,
+    name: string,
+    newOwner: PublicKey,
+    nameClass?: PublicKey,
+    nameParent?: PublicKey,
 ): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent,
-  );
-
-  let curentNameOwner: PublicKey;
-  if (nameClass) {
-    curentNameOwner = nameClass;
-  } else {
-    curentNameOwner = (
-      await NameRegistryState.retrieve(connection, nameAccountKey)
-    ).owner;
-  }
-
-  const transferInstr = transferInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    newOwner,
-    curentNameOwner,
-    nameClass,
-    nameParent,
-  );
-
-  return transferInstr;
+    const hashed_name = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashed_name, nameClass, nameParent);
+
+    let curentNameOwner: PublicKey;
+    if (nameClass) {
+        curentNameOwner = nameClass;
+    } else {
+        curentNameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey)).owner;
+    }
+
+    const transferInstr = transferInstruction(
+        NAME_PROGRAM_ID,
+        nameAccountKey,
+        newOwner,
+        curentNameOwner,
+        nameClass,
+        nameParent,
+    );
+
+    return transferInstr;
 }
 
 /**
@@ -188,35 +159,25 @@ export async function transferNameOwnership(
  * @returns
  */
 export async function deleteNameRegistry(
-  connection: Connection,
-  name: string,
-  refundTargetKey: PublicKey,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
+    connection: Connection,
+    name: string,
+    refundTargetKey: PublicKey,
+    nameClass?: PublicKey,
+    nameParent?: PublicKey,
 ): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent,
-  );
+    const hashed_name = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashed_name, nameClass, nameParent);
 
-  let nameOwner: PublicKey;
-  if (nameClass) {
-    nameOwner = nameClass;
-  } else {
-    nameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey))
-      .owner;
-  }
+    let nameOwner: PublicKey;
+    if (nameClass) {
+        nameOwner = nameClass;
+    } else {
+        nameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey)).owner;
+    }
 
-  const changeAuthoritiesInstr = deleteInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    refundTargetKey,
-    nameOwner,
-  );
+    const changeAuthoritiesInstr = deleteInstruction(NAME_PROGRAM_ID, nameAccountKey, refundTargetKey, nameOwner);
 
-  return changeAuthoritiesInstr;
+    return changeAuthoritiesInstr;
 }
 
 /**
@@ -231,36 +192,31 @@ export async function deleteNameRegistry(
  * @returns
  */
 export async function reallocNameAccount(
-  connection: Connection,
-  name: string,
-  space: number,
-  payerKey: PublicKey,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
+    connection: Connection,
+    name: string,
+    space: number,
+    payerKey: PublicKey,
+    nameClass?: PublicKey,
+    nameParent?: PublicKey,
 ): Promise<TransactionInstruction> {
-  const hashedName = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashedName,
-    nameClass,
-    nameParent,
-  );
-
-  let nameOwner: PublicKey;
-  if (nameClass) {
-    nameOwner = nameClass;
-  } else {
-    nameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey))
-      .owner;
-  }
-
-  const reallocInstr = reallocInstruction(
-    NAME_PROGRAM_ID,
-    SystemProgram.programId,
-    payerKey,
-    nameAccountKey,
-    nameOwner,
-    new Numberu32(space),
-  );
-
-  return reallocInstr;
+    const hashedName = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashedName, nameClass, nameParent);
+
+    let nameOwner: PublicKey;
+    if (nameClass) {
+        nameOwner = nameClass;
+    } else {
+        nameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey)).owner;
+    }
+
+    const reallocInstr = reallocInstruction(
+        NAME_PROGRAM_ID,
+        SystemProgram.programId,
+        payerKey,
+        nameAccountKey,
+        nameOwner,
+        new Numberu32(space),
+    );
+
+    return reallocInstr;
 }
diff --git a/name-service/js/src/instructions.ts b/name-service/js/src/instructions.ts
index 9d48d60bb0f..e7e709f5bdf 100644
--- a/name-service/js/src/instructions.ts
+++ b/name-service/js/src/instructions.ts
@@ -3,255 +3,255 @@ import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { Numberu32, Numberu64 } from './utils';
 
 export function createInstruction(
-  nameProgramId: PublicKey,
-  systemProgramId: PublicKey,
-  nameKey: PublicKey,
-  nameOwnerKey: PublicKey,
-  payerKey: PublicKey,
-  hashed_name: Buffer,
-  lamports: Numberu64,
-  space: Numberu32,
-  nameClassKey?: PublicKey,
-  nameParent?: PublicKey,
-  nameParentOwner?: PublicKey,
+    nameProgramId: PublicKey,
+    systemProgramId: PublicKey,
+    nameKey: PublicKey,
+    nameOwnerKey: PublicKey,
+    payerKey: PublicKey,
+    hashed_name: Buffer,
+    lamports: Numberu64,
+    space: Numberu32,
+    nameClassKey?: PublicKey,
+    nameParent?: PublicKey,
+    nameParentOwner?: PublicKey,
 ): TransactionInstruction {
-  const buffers = [
-    Buffer.from(Int8Array.from([0])),
-    new Numberu32(hashed_name.length).toBuffer(),
-    hashed_name,
-    lamports.toBuffer(),
-    space.toBuffer(),
-  ];
+    const buffers = [
+        Buffer.from(Uint8Array.from([0])),
+        new Numberu32(hashed_name.length).toBuffer(),
+        hashed_name,
+        lamports.toBuffer(),
+        space.toBuffer(),
+    ];
 
-  const data = Buffer.concat(buffers);
+    const data = Buffer.concat(buffers);
 
-  const keys = [
-    {
-      pubkey: systemProgramId,
-      isSigner: false,
-      isWritable: false,
-    },
-    {
-      pubkey: payerKey,
-      isSigner: true,
-      isWritable: true,
-    },
-    {
-      pubkey: nameKey,
-      isSigner: false,
-      isWritable: true,
-    },
-    {
-      pubkey: nameOwnerKey,
-      isSigner: false,
-      isWritable: false,
-    },
-  ];
+    const keys = [
+        {
+            pubkey: systemProgramId,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: payerKey,
+            isSigner: true,
+            isWritable: true,
+        },
+        {
+            pubkey: nameKey,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: nameOwnerKey,
+            isSigner: false,
+            isWritable: false,
+        },
+    ];
 
-  if (nameClassKey) {
-    keys.push({
-      pubkey: nameClassKey,
-      isSigner: true,
-      isWritable: false,
-    });
-  } else {
-    keys.push({
-      pubkey: new PublicKey(Buffer.alloc(32)),
-      isSigner: false,
-      isWritable: false,
-    });
-  }
-  if (nameParent) {
-    keys.push({
-      pubkey: nameParent,
-      isSigner: false,
-      isWritable: false,
-    });
-  } else {
-    keys.push({
-      pubkey: new PublicKey(Buffer.alloc(32)),
-      isSigner: false,
-      isWritable: false,
-    });
-  }
-  if (nameParentOwner) {
-    keys.push({
-      pubkey: nameParentOwner,
-      isSigner: true,
-      isWritable: false,
-    });
-  }
+    if (nameClassKey) {
+        keys.push({
+            pubkey: nameClassKey,
+            isSigner: true,
+            isWritable: false,
+        });
+    } else {
+        keys.push({
+            pubkey: new PublicKey(Buffer.alloc(32)),
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+    if (nameParent) {
+        keys.push({
+            pubkey: nameParent,
+            isSigner: false,
+            isWritable: false,
+        });
+    } else {
+        keys.push({
+            pubkey: new PublicKey(Buffer.alloc(32)),
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+    if (nameParentOwner) {
+        keys.push({
+            pubkey: nameParentOwner,
+            isSigner: true,
+            isWritable: false,
+        });
+    }
 
-  return new TransactionInstruction({
-    keys,
-    programId: nameProgramId,
-    data,
-  });
+    return new TransactionInstruction({
+        keys,
+        programId: nameProgramId,
+        data,
+    });
 }
 
 export function updateInstruction(
-  nameProgramId: PublicKey,
-  nameAccountKey: PublicKey,
-  offset: Numberu32,
-  input_data: Buffer,
-  nameUpdateSigner: PublicKey,
-  parentNameKey: PublicKey | undefined,
+    nameProgramId: PublicKey,
+    nameAccountKey: PublicKey,
+    offset: Numberu32,
+    input_data: Buffer,
+    nameUpdateSigner: PublicKey,
+    parentNameKey: PublicKey | undefined,
 ): TransactionInstruction {
-  const buffers = [
-    Buffer.from(Int8Array.from([1])),
-    offset.toBuffer(),
-    new Numberu32(input_data.length).toBuffer(),
-    input_data,
-  ];
+    const buffers = [
+        Buffer.from(Uint8Array.from([1])),
+        offset.toBuffer(),
+        new Numberu32(input_data.length).toBuffer(),
+        input_data,
+    ];
 
-  const data = Buffer.concat(buffers);
-  const keys = [
-    {
-      pubkey: nameAccountKey,
-      isSigner: false,
-      isWritable: true,
-    },
-    {
-      pubkey: nameUpdateSigner,
-      isSigner: true,
-      isWritable: false,
-    },
-  ];
+    const data = Buffer.concat(buffers);
+    const keys = [
+        {
+            pubkey: nameAccountKey,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: nameUpdateSigner,
+            isSigner: true,
+            isWritable: false,
+        },
+    ];
 
-  if (parentNameKey) {
-    keys.push({
-      pubkey: parentNameKey,
-      isSigner: false,
-      isWritable: false,
-    });
-  }
+    if (parentNameKey) {
+        keys.push({
+            pubkey: parentNameKey,
+            isSigner: false,
+            isWritable: false,
+        });
+    }
 
-  return new TransactionInstruction({
-    keys,
-    programId: nameProgramId,
-    data,
-  });
+    return new TransactionInstruction({
+        keys,
+        programId: nameProgramId,
+        data,
+    });
 }
 
 export function transferInstruction(
-  nameProgramId: PublicKey,
-  nameAccountKey: PublicKey,
-  newOwnerKey: PublicKey,
-  currentNameOwnerKey: PublicKey,
-  nameClassKey?: PublicKey,
-  nameParent?: PublicKey,
+    nameProgramId: PublicKey,
+    nameAccountKey: PublicKey,
+    newOwnerKey: PublicKey,
+    currentNameOwnerKey: PublicKey,
+    nameClassKey?: PublicKey,
+    nameParent?: PublicKey,
 ): TransactionInstruction {
-  const buffers = [Buffer.from(Int8Array.from([2])), newOwnerKey.toBuffer()];
+    const buffers = [Buffer.from(Uint8Array.from([2])), newOwnerKey.toBuffer()];
 
-  const data = Buffer.concat(buffers);
+    const data = Buffer.concat(buffers);
 
-  const keys = [
-    {
-      pubkey: nameAccountKey,
-      isSigner: false,
-      isWritable: true,
-    },
-    {
-      pubkey: currentNameOwnerKey,
-      isSigner: true,
-      isWritable: false,
-    },
-  ];
+    const keys = [
+        {
+            pubkey: nameAccountKey,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: currentNameOwnerKey,
+            isSigner: true,
+            isWritable: false,
+        },
+    ];
 
-  if (nameClassKey) {
-    keys.push({
-      pubkey: nameClassKey,
-      isSigner: true,
-      isWritable: false,
-    });
-  }
+    if (nameClassKey) {
+        keys.push({
+            pubkey: nameClassKey,
+            isSigner: true,
+            isWritable: false,
+        });
+    }
 
-  if (nameParent) {
-    keys.push({
-      pubkey: nameParent,
-      isSigner: false,
-      isWritable: false,
-    });
-  }
+    if (nameParent) {
+        keys.push({
+            pubkey: nameParent,
+            isSigner: false,
+            isWritable: false,
+        });
+    }
 
-  return new TransactionInstruction({
-    keys,
-    programId: nameProgramId,
-    data,
-  });
+    return new TransactionInstruction({
+        keys,
+        programId: nameProgramId,
+        data,
+    });
 }
 
 export function deleteInstruction(
-  nameProgramId: PublicKey,
-  nameAccountKey: PublicKey,
-  refundTargetKey: PublicKey,
-  nameOwnerKey: PublicKey,
+    nameProgramId: PublicKey,
+    nameAccountKey: PublicKey,
+    refundTargetKey: PublicKey,
+    nameOwnerKey: PublicKey,
 ): TransactionInstruction {
-  const buffers = [Buffer.from(Int8Array.from([3]))];
+    const buffers = [Buffer.from(Uint8Array.from([3]))];
 
-  const data = Buffer.concat(buffers);
-  const keys = [
-    {
-      pubkey: nameAccountKey,
-      isSigner: false,
-      isWritable: true,
-    },
-    {
-      pubkey: nameOwnerKey,
-      isSigner: true,
-      isWritable: false,
-    },
-    {
-      pubkey: refundTargetKey,
-      isSigner: false,
-      isWritable: true,
-    },
-  ];
+    const data = Buffer.concat(buffers);
+    const keys = [
+        {
+            pubkey: nameAccountKey,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: nameOwnerKey,
+            isSigner: true,
+            isWritable: false,
+        },
+        {
+            pubkey: refundTargetKey,
+            isSigner: false,
+            isWritable: true,
+        },
+    ];
 
-  return new TransactionInstruction({
-    keys,
-    programId: nameProgramId,
-    data,
-  });
+    return new TransactionInstruction({
+        keys,
+        programId: nameProgramId,
+        data,
+    });
 }
 
 export function reallocInstruction(
-  nameProgramId: PublicKey,
-  systemProgramId: PublicKey,
-  payerKey: PublicKey,
-  nameAccountKey: PublicKey,
-  nameOwnerKey: PublicKey,
-  space: Numberu32,
+    nameProgramId: PublicKey,
+    systemProgramId: PublicKey,
+    payerKey: PublicKey,
+    nameAccountKey: PublicKey,
+    nameOwnerKey: PublicKey,
+    space: Numberu32,
 ): TransactionInstruction {
-  const buffers = [Buffer.from(Int8Array.from([4])), space.toBuffer()];
+    const buffers = [Buffer.from(Uint8Array.from([4])), space.toBuffer()];
 
-  const data = Buffer.concat(buffers);
-  const keys = [
-    {
-      pubkey: systemProgramId,
-      isSigner: false,
-      isWritable: false,
-    },
-    {
-      pubkey: payerKey,
-      isSigner: true,
-      isWritable: true,
-    },
-    {
-      pubkey: nameAccountKey,
-      isSigner: false,
-      isWritable: true,
-    },
-    {
-      pubkey: nameOwnerKey,
-      isSigner: true,
-      isWritable: false,
-    },
-  ];
+    const data = Buffer.concat(buffers);
+    const keys = [
+        {
+            pubkey: systemProgramId,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: payerKey,
+            isSigner: true,
+            isWritable: true,
+        },
+        {
+            pubkey: nameAccountKey,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: nameOwnerKey,
+            isSigner: true,
+            isWritable: false,
+        },
+    ];
 
-  return new TransactionInstruction({
-    keys,
-    programId: nameProgramId,
-    data,
-  });
+    return new TransactionInstruction({
+        keys,
+        programId: nameProgramId,
+        data,
+    });
 }
diff --git a/name-service/js/src/state.ts b/name-service/js/src/state.ts
index 88b72809018..e7b6c306508 100644
--- a/name-service/js/src/state.ts
+++ b/name-service/js/src/state.ts
@@ -2,48 +2,42 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { deserialize, Schema } from 'borsh';
 
 type InitArgs = {
-  parentName: Uint8Array;
-  owner: Uint8Array;
-  class: Uint8Array;
+    parentName: Uint8Array;
+    owner: Uint8Array;
+    class: Uint8Array;
 };
 
 export class NameRegistryState {
-  static HEADER_LEN = 96;
-  parentName: PublicKey;
-  owner: PublicKey;
-  class: PublicKey;
-  data: Buffer | undefined;
+    static HEADER_LEN = 96;
+    parentName: PublicKey;
+    owner: PublicKey;
+    class: PublicKey;
+    data: Buffer | undefined;
 
-  static schema: Schema = {
-    struct: {
-      parentName: { array: { type: 'u8', len: 32 } },
-      owner: { array: { type: 'u8', len: 32 } },
-      class: { array: { type: 'u8', len: 32 } },
-    },
-  };
-  constructor(obj: InitArgs) {
-    this.parentName = new PublicKey(obj.parentName);
-    this.owner = new PublicKey(obj.owner);
-    this.class = new PublicKey(obj.class);
-  }
-
-  public static async retrieve(
-    connection: Connection,
-    nameAccountKey: PublicKey,
-  ): Promise<NameRegistryState> {
-    const nameAccount = await connection.getAccountInfo(
-      nameAccountKey,
-      'processed',
-    );
-    if (!nameAccount) {
-      throw new Error('Invalid name account provided');
+    static schema: Schema = {
+        struct: {
+            parentName: { array: { type: 'u8', len: 32 } },
+            owner: { array: { type: 'u8', len: 32 } },
+            class: { array: { type: 'u8', len: 32 } },
+        },
+    };
+    constructor(obj: InitArgs) {
+        this.parentName = new PublicKey(obj.parentName);
+        this.owner = new PublicKey(obj.owner);
+        this.class = new PublicKey(obj.class);
     }
 
-    const deserialized = deserialize(this.schema, nameAccount.data) as InitArgs;
-    const res = new NameRegistryState(deserialized);
+    public static async retrieve(connection: Connection, nameAccountKey: PublicKey): Promise<NameRegistryState> {
+        const nameAccount = await connection.getAccountInfo(nameAccountKey, 'processed');
+        if (!nameAccount) {
+            throw new Error('Invalid name account provided');
+        }
+
+        const deserialized = deserialize(this.schema, nameAccount.data) as InitArgs;
+        const res = new NameRegistryState(deserialized);
 
-    res.data = nameAccount.data?.slice(this.HEADER_LEN);
+        res.data = nameAccount.data?.slice(this.HEADER_LEN);
 
-    return res;
-  }
+        return res;
+    }
 }
diff --git a/name-service/js/src/twitter.ts b/name-service/js/src/twitter.ts
index f0a420dbc3a..05f3a212a23 100644
--- a/name-service/js/src/twitter.ts
+++ b/name-service/js/src/twitter.ts
@@ -1,433 +1,362 @@
-import {
-  Connection,
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-} from '@solana/web3.js';
+import { Connection, PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
 import { deserialize, Schema, serialize } from 'borsh';
 
 import { deleteNameRegistry, NAME_PROGRAM_ID } from './bindings';
-import {
-  createInstruction,
-  deleteInstruction,
-  transferInstruction,
-  updateInstruction,
-} from './instructions';
+import { createInstruction, deleteInstruction, transferInstruction, updateInstruction } from './instructions';
 import { NameRegistryState } from './state';
-import {
-  getFilteredProgramAccounts,
-  getHashedName,
-  getNameAccountKey,
-  Numberu32,
-  Numberu64,
-} from './utils';
+import { getFilteredProgramAccounts, getHashedName, getNameAccountKey, Numberu32, Numberu64 } from './utils';
 
 ////////////////////////////////////////////////////
 // Global Variables
 
-export const TWITTER_VERIFICATION_AUTHORITY = new PublicKey(
-  'FvPH7PrVrLGKPfqaf3xJodFTjZriqrAXXLTVWEorTFBi',
-);
+export const TWITTER_VERIFICATION_AUTHORITY = new PublicKey('FvPH7PrVrLGKPfqaf3xJodFTjZriqrAXXLTVWEorTFBi');
 // The address of the name registry that will be a parent to all twitter handle registries,
 // it should be owned by the TWITTER_VERIFICATION_AUTHORITY and its name is irrelevant
-export const TWITTER_ROOT_PARENT_REGISTRY_KEY = new PublicKey(
-  '4YcexoW3r78zz16J2aqmukBLRwGq6rAvWzJpkYAXqebv',
-);
+export const TWITTER_ROOT_PARENT_REGISTRY_KEY = new PublicKey('4YcexoW3r78zz16J2aqmukBLRwGq6rAvWzJpkYAXqebv');
 
 ////////////////////////////////////////////////////
 // Bindings
 
 // Signed by the authority, the payer and the verified pubkey
 export async function createVerifiedTwitterRegistry(
-  connection: Connection,
-  twitterHandle: string,
-  verifiedPubkey: PublicKey,
-  space: number, // The space that the user will have to write data into the verified registry
-  payerKey: PublicKey,
+    connection: Connection,
+    twitterHandle: string,
+    verifiedPubkey: PublicKey,
+    space: number, // The space that the user will have to write data into the verified registry
+    payerKey: PublicKey,
 ): Promise<TransactionInstruction[]> {
-  // Create user facing registry
-  const hashedTwitterHandle = await getHashedName(twitterHandle);
-  const twitterHandleRegistryKey = await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  let instructions = [
-    createInstruction(
-      NAME_PROGRAM_ID,
-      SystemProgram.programId,
-      twitterHandleRegistryKey,
-      verifiedPubkey,
-      payerKey,
-      hashedTwitterHandle,
-      new Numberu64(await connection.getMinimumBalanceForRentExemption(space)),
-      new Numberu32(space),
-      undefined,
-      TWITTER_ROOT_PARENT_REGISTRY_KEY,
-      TWITTER_VERIFICATION_AUTHORITY, // Twitter authority acts as owner of the parent for all user-facing registries
-    ),
-  ];
-
-  instructions = instructions.concat(
-    await createReverseTwitterRegistry(
-      connection,
-      twitterHandle,
-      twitterHandleRegistryKey,
-      verifiedPubkey,
-      payerKey,
-    ),
-  );
-
-  return instructions;
+    // Create user facing registry
+    const hashedTwitterHandle = await getHashedName(twitterHandle);
+    const twitterHandleRegistryKey = await getNameAccountKey(
+        hashedTwitterHandle,
+        undefined,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    let instructions = [
+        createInstruction(
+            NAME_PROGRAM_ID,
+            SystemProgram.programId,
+            twitterHandleRegistryKey,
+            verifiedPubkey,
+            payerKey,
+            hashedTwitterHandle,
+            new Numberu64(await connection.getMinimumBalanceForRentExemption(space)),
+            new Numberu32(space),
+            undefined,
+            TWITTER_ROOT_PARENT_REGISTRY_KEY,
+            TWITTER_VERIFICATION_AUTHORITY, // Twitter authority acts as owner of the parent for all user-facing registries
+        ),
+    ];
+
+    instructions = instructions.concat(
+        await createReverseTwitterRegistry(
+            connection,
+            twitterHandle,
+            twitterHandleRegistryKey,
+            verifiedPubkey,
+            payerKey,
+        ),
+    );
+
+    return instructions;
 }
 
 // Overwrite the data that is written in the user facing registry
 // Signed by the verified pubkey
 export async function changeTwitterRegistryData(
-  twitterHandle: string,
-  verifiedPubkey: PublicKey,
-  offset: number, // The offset at which to write the input data into the NameRegistryData
-  input_data: Buffer,
+    twitterHandle: string,
+    verifiedPubkey: PublicKey,
+    offset: number, // The offset at which to write the input data into the NameRegistryData
+    input_data: Buffer,
 ): Promise<TransactionInstruction[]> {
-  const hashedTwitterHandle = await getHashedName(twitterHandle);
-  const twitterHandleRegistryKey = await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  const instructions = [
-    updateInstruction(
-      NAME_PROGRAM_ID,
-      twitterHandleRegistryKey,
-      new Numberu32(offset),
-      input_data,
-      verifiedPubkey,
-      undefined,
-    ),
-  ];
-
-  return instructions;
+    const hashedTwitterHandle = await getHashedName(twitterHandle);
+    const twitterHandleRegistryKey = await getNameAccountKey(
+        hashedTwitterHandle,
+        undefined,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    const instructions = [
+        updateInstruction(
+            NAME_PROGRAM_ID,
+            twitterHandleRegistryKey,
+            new Numberu32(offset),
+            input_data,
+            verifiedPubkey,
+            undefined,
+        ),
+    ];
+
+    return instructions;
 }
 
 // Change the verified pubkey for a given twitter handle
 // Signed by the Authority, the verified pubkey and the payer
 export async function changeVerifiedPubkey(
-  connection: Connection,
-  twitterHandle: string,
-  currentVerifiedPubkey: PublicKey,
-  newVerifiedPubkey: PublicKey,
-  payerKey: PublicKey,
+    connection: Connection,
+    twitterHandle: string,
+    currentVerifiedPubkey: PublicKey,
+    newVerifiedPubkey: PublicKey,
+    payerKey: PublicKey,
 ): Promise<TransactionInstruction[]> {
-  const hashedTwitterHandle = await getHashedName(twitterHandle);
-  const twitterHandleRegistryKey = await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  // Transfer the user-facing registry ownership
-  let instructions = [
-    transferInstruction(
-      NAME_PROGRAM_ID,
-      twitterHandleRegistryKey,
-      newVerifiedPubkey,
-      currentVerifiedPubkey,
-      undefined,
-    ),
-  ];
-
-  // Delete the current reverse registry
-  instructions.push(
-    await deleteNameRegistry(
-      connection,
-      currentVerifiedPubkey.toString(),
-      payerKey,
-      TWITTER_VERIFICATION_AUTHORITY,
-      TWITTER_ROOT_PARENT_REGISTRY_KEY,
-    ),
-  );
-
-  // Create the new reverse registry
-  instructions = instructions.concat(
-    await createReverseTwitterRegistry(
-      connection,
-      twitterHandle,
-      twitterHandleRegistryKey,
-      newVerifiedPubkey,
-      payerKey,
-    ),
-  );
-
-  return instructions;
+    const hashedTwitterHandle = await getHashedName(twitterHandle);
+    const twitterHandleRegistryKey = await getNameAccountKey(
+        hashedTwitterHandle,
+        undefined,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    // Transfer the user-facing registry ownership
+    let instructions = [
+        transferInstruction(
+            NAME_PROGRAM_ID,
+            twitterHandleRegistryKey,
+            newVerifiedPubkey,
+            currentVerifiedPubkey,
+            undefined,
+        ),
+    ];
+
+    // Delete the current reverse registry
+    instructions.push(
+        await deleteNameRegistry(
+            connection,
+            currentVerifiedPubkey.toString(),
+            payerKey,
+            TWITTER_VERIFICATION_AUTHORITY,
+            TWITTER_ROOT_PARENT_REGISTRY_KEY,
+        ),
+    );
+
+    // Create the new reverse registry
+    instructions = instructions.concat(
+        await createReverseTwitterRegistry(
+            connection,
+            twitterHandle,
+            twitterHandleRegistryKey,
+            newVerifiedPubkey,
+            payerKey,
+        ),
+    );
+
+    return instructions;
 }
 
 // Delete the verified registry for a given twitter handle
 // Signed by the verified pubkey
 export async function deleteTwitterRegistry(
-  twitterHandle: string,
-  verifiedPubkey: PublicKey,
+    twitterHandle: string,
+    verifiedPubkey: PublicKey,
 ): Promise<TransactionInstruction[]> {
-  const hashedTwitterHandle = await getHashedName(twitterHandle);
-  const twitterHandleRegistryKey = await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
-  const reverseRegistryKey = await getNameAccountKey(
-    hashedVerifiedPubkey,
-    TWITTER_VERIFICATION_AUTHORITY,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  const instructions = [
-    // Delete the user facing registry
-    deleteInstruction(
-      NAME_PROGRAM_ID,
-      twitterHandleRegistryKey,
-      verifiedPubkey,
-      verifiedPubkey,
-    ),
-    // Delete the reverse registry
-    deleteInstruction(
-      NAME_PROGRAM_ID,
-      reverseRegistryKey,
-      verifiedPubkey,
-      verifiedPubkey,
-    ),
-  ];
-
-  return instructions;
+    const hashedTwitterHandle = await getHashedName(twitterHandle);
+    const twitterHandleRegistryKey = await getNameAccountKey(
+        hashedTwitterHandle,
+        undefined,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
+    const reverseRegistryKey = await getNameAccountKey(
+        hashedVerifiedPubkey,
+        TWITTER_VERIFICATION_AUTHORITY,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    const instructions = [
+        // Delete the user facing registry
+        deleteInstruction(NAME_PROGRAM_ID, twitterHandleRegistryKey, verifiedPubkey, verifiedPubkey),
+        // Delete the reverse registry
+        deleteInstruction(NAME_PROGRAM_ID, reverseRegistryKey, verifiedPubkey, verifiedPubkey),
+    ];
+
+    return instructions;
 }
 
 //////////////////////////////////////////
 // Getter Functions
 
 // Returns the key of the user-facing registry
-export async function getTwitterRegistryKey(
-  twitter_handle: string,
-): Promise<PublicKey> {
-  const hashedTwitterHandle = await getHashedName(twitter_handle);
-  return await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
+export async function getTwitterRegistryKey(twitter_handle: string): Promise<PublicKey> {
+    const hashedTwitterHandle = await getHashedName(twitter_handle);
+    return await getNameAccountKey(hashedTwitterHandle, undefined, TWITTER_ROOT_PARENT_REGISTRY_KEY);
 }
 
-export async function getTwitterRegistry(
-  connection: Connection,
-  twitter_handle: string,
-): Promise<NameRegistryState> {
-  const hashedTwitterHandle = await getHashedName(twitter_handle);
-  const twitterHandleRegistryKey = await getNameAccountKey(
-    hashedTwitterHandle,
-    undefined,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-  const registry = NameRegistryState.retrieve(
-    connection,
-    twitterHandleRegistryKey,
-  );
-  return registry;
+export async function getTwitterRegistry(connection: Connection, twitter_handle: string): Promise<NameRegistryState> {
+    const hashedTwitterHandle = await getHashedName(twitter_handle);
+    const twitterHandleRegistryKey = await getNameAccountKey(
+        hashedTwitterHandle,
+        undefined,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+    const registry = NameRegistryState.retrieve(connection, twitterHandleRegistryKey);
+    return registry;
 }
 
 export async function getHandleAndRegistryKey(
-  connection: Connection,
-  verifiedPubkey: PublicKey,
+    connection: Connection,
+    verifiedPubkey: PublicKey,
 ): Promise<[string, PublicKey]> {
-  const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
-  const reverseRegistryKey = await getNameAccountKey(
-    hashedVerifiedPubkey,
-    TWITTER_VERIFICATION_AUTHORITY,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-
-  const reverseRegistryState = await ReverseTwitterRegistryState.retrieve(
-    connection,
-    reverseRegistryKey,
-  );
-  return [
-    reverseRegistryState.twitterHandle,
-    new PublicKey(reverseRegistryState.twitterRegistryKey),
-  ];
+    const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
+    const reverseRegistryKey = await getNameAccountKey(
+        hashedVerifiedPubkey,
+        TWITTER_VERIFICATION_AUTHORITY,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+
+    const reverseRegistryState = await ReverseTwitterRegistryState.retrieve(connection, reverseRegistryKey);
+    return [reverseRegistryState.twitterHandle, new PublicKey(reverseRegistryState.twitterRegistryKey)];
 }
 
 // Uses the RPC node filtering feature, execution speed may vary
 export async function getTwitterHandleandRegistryKeyViaFilters(
-  connection: Connection,
-  verifiedPubkey: PublicKey,
+    connection: Connection,
+    verifiedPubkey: PublicKey,
 ): Promise<[string, PublicKey]> {
-  const filters = [
-    {
-      memcmp: {
-        offset: 0,
-        bytes: TWITTER_ROOT_PARENT_REGISTRY_KEY.toBase58(),
-      },
-    },
-    {
-      memcmp: {
-        offset: 32,
-        bytes: verifiedPubkey.toBase58(),
-      },
-    },
-    {
-      memcmp: {
-        offset: 64,
-        bytes: TWITTER_VERIFICATION_AUTHORITY.toBase58(),
-      },
-    },
-  ];
-
-  const filteredAccounts = await getFilteredProgramAccounts(
-    connection,
-    NAME_PROGRAM_ID,
-    filters,
-  );
-
-  for (const f of filteredAccounts) {
-    if (f.accountInfo.data.length > NameRegistryState.HEADER_LEN + 32) {
-      const data = f.accountInfo.data.slice(NameRegistryState.HEADER_LEN);
-      const state = deserialize(
-        ReverseTwitterRegistryState.schema,
-        data,
-      ) as ReverseTwitterRegistryState;
-      return [state.twitterHandle, new PublicKey(state.twitterRegistryKey)];
+    const filters = [
+        {
+            memcmp: {
+                offset: 0,
+                bytes: TWITTER_ROOT_PARENT_REGISTRY_KEY.toBase58(),
+            },
+        },
+        {
+            memcmp: {
+                offset: 32,
+                bytes: verifiedPubkey.toBase58(),
+            },
+        },
+        {
+            memcmp: {
+                offset: 64,
+                bytes: TWITTER_VERIFICATION_AUTHORITY.toBase58(),
+            },
+        },
+    ];
+
+    const filteredAccounts = await getFilteredProgramAccounts(connection, NAME_PROGRAM_ID, filters);
+
+    for (const f of filteredAccounts) {
+        if (f.accountInfo.data.length > NameRegistryState.HEADER_LEN + 32) {
+            const data = f.accountInfo.data.slice(NameRegistryState.HEADER_LEN);
+            const state = deserialize(ReverseTwitterRegistryState.schema, data) as ReverseTwitterRegistryState;
+            return [state.twitterHandle, new PublicKey(state.twitterRegistryKey)];
+        }
     }
-  }
-  throw new Error('Registry not found.');
+    throw new Error('Registry not found.');
 }
 
 // Uses the RPC node filtering feature, execution speed may vary
 // Does not give you the handle, but is an alternative to getHandlesAndKeysFromVerifiedPubkey + getTwitterRegistry to get the data
-export async function getTwitterRegistryData(
-  connection: Connection,
-  verifiedPubkey: PublicKey,
-): Promise<Buffer> {
-  const filters = [
-    {
-      memcmp: {
-        offset: 0,
-        bytes: TWITTER_ROOT_PARENT_REGISTRY_KEY.toBase58(),
-      },
-    },
-    {
-      memcmp: {
-        offset: 32,
-        bytes: verifiedPubkey.toBase58(),
-      },
-    },
-    {
-      memcmp: {
-        offset: 64,
-        bytes: new PublicKey(Buffer.alloc(32, 0)).toBase58(),
-      },
-    },
-  ];
-
-  const filteredAccounts = await getFilteredProgramAccounts(
-    connection,
-    NAME_PROGRAM_ID,
-    filters,
-  );
-
-  if (filteredAccounts.length > 1) {
-    throw new Error('Found more than one registry.');
-  }
-
-  return filteredAccounts[0].accountInfo.data.slice(
-    NameRegistryState.HEADER_LEN,
-  );
+export async function getTwitterRegistryData(connection: Connection, verifiedPubkey: PublicKey): Promise<Buffer> {
+    const filters = [
+        {
+            memcmp: {
+                offset: 0,
+                bytes: TWITTER_ROOT_PARENT_REGISTRY_KEY.toBase58(),
+            },
+        },
+        {
+            memcmp: {
+                offset: 32,
+                bytes: verifiedPubkey.toBase58(),
+            },
+        },
+        {
+            memcmp: {
+                offset: 64,
+                bytes: new PublicKey(Buffer.alloc(32, 0)).toBase58(),
+            },
+        },
+    ];
+
+    const filteredAccounts = await getFilteredProgramAccounts(connection, NAME_PROGRAM_ID, filters);
+
+    if (filteredAccounts.length > 1) {
+        throw new Error('Found more than one registry.');
+    }
+
+    return filteredAccounts[0].accountInfo.data.slice(NameRegistryState.HEADER_LEN);
 }
 
 //////////////////////////////////////////////
 // Utils
 
 export class ReverseTwitterRegistryState {
-  twitterRegistryKey: Uint8Array;
-  twitterHandle: string;
-
-  static schema: Schema = {
-    struct: {
-      twitterRegistryKey: { array: { type: 'u8', len: 32 } },
-      twitterHandle: 'string',
-    },
-  };
-  constructor(obj: { twitterRegistryKey: Uint8Array; twitterHandle: string }) {
-    this.twitterRegistryKey = obj.twitterRegistryKey;
-    this.twitterHandle = obj.twitterHandle;
-  }
-
-  public static async retrieve(
-    connection: Connection,
-    reverseTwitterAccountKey: PublicKey,
-  ): Promise<ReverseTwitterRegistryState> {
-    const reverseTwitterAccount = await connection.getAccountInfo(
-      reverseTwitterAccountKey,
-      'processed',
-    );
-    if (!reverseTwitterAccount) {
-      throw new Error('Invalid reverse Twitter account provided');
+    twitterRegistryKey: Uint8Array;
+    twitterHandle: string;
+
+    static schema: Schema = {
+        struct: {
+            twitterRegistryKey: { array: { type: 'u8', len: 32 } },
+            twitterHandle: 'string',
+        },
+    };
+    constructor(obj: { twitterRegistryKey: Uint8Array; twitterHandle: string }) {
+        this.twitterRegistryKey = obj.twitterRegistryKey;
+        this.twitterHandle = obj.twitterHandle;
     }
 
-    const res = deserialize(
-      this.schema,
-      reverseTwitterAccount.data.slice(NameRegistryState.HEADER_LEN),
-    ) as ReverseTwitterRegistryState;
-
-    return res;
-  }
+    public static async retrieve(
+        connection: Connection,
+        reverseTwitterAccountKey: PublicKey,
+    ): Promise<ReverseTwitterRegistryState> {
+        const reverseTwitterAccount = await connection.getAccountInfo(reverseTwitterAccountKey, 'processed');
+        if (!reverseTwitterAccount) {
+            throw new Error('Invalid reverse Twitter account provided');
+        }
+
+        const res = deserialize(
+            this.schema,
+            reverseTwitterAccount.data.slice(NameRegistryState.HEADER_LEN),
+        ) as ReverseTwitterRegistryState;
+
+        return res;
+    }
 }
 
 export async function createReverseTwitterRegistry(
-  connection: Connection,
-  twitterHandle: string,
-  twitterRegistryKey: PublicKey,
-  verifiedPubkey: PublicKey,
-  payerKey: PublicKey,
+    connection: Connection,
+    twitterHandle: string,
+    twitterRegistryKey: PublicKey,
+    verifiedPubkey: PublicKey,
+    payerKey: PublicKey,
 ): Promise<TransactionInstruction[]> {
-  // Create the reverse lookup registry
-  const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
-  const reverseRegistryKey = await getNameAccountKey(
-    hashedVerifiedPubkey,
-    TWITTER_VERIFICATION_AUTHORITY,
-    TWITTER_ROOT_PARENT_REGISTRY_KEY,
-  );
-  const reverseTwitterRegistryStateBuff = serialize(
-    ReverseTwitterRegistryState.schema,
-    new ReverseTwitterRegistryState({
-      twitterRegistryKey: twitterRegistryKey.toBytes(),
-      twitterHandle,
-    }),
-  );
-  return [
-    createInstruction(
-      NAME_PROGRAM_ID,
-      SystemProgram.programId,
-      reverseRegistryKey,
-      verifiedPubkey,
-      payerKey,
-      hashedVerifiedPubkey,
-      new Numberu64(
-        await connection.getMinimumBalanceForRentExemption(
-          reverseTwitterRegistryStateBuff.length,
+    // Create the reverse lookup registry
+    const hashedVerifiedPubkey = await getHashedName(verifiedPubkey.toString());
+    const reverseRegistryKey = await getNameAccountKey(
+        hashedVerifiedPubkey,
+        TWITTER_VERIFICATION_AUTHORITY,
+        TWITTER_ROOT_PARENT_REGISTRY_KEY,
+    );
+    const reverseTwitterRegistryStateBuff = serialize(
+        ReverseTwitterRegistryState.schema,
+        new ReverseTwitterRegistryState({
+            twitterRegistryKey: twitterRegistryKey.toBytes(),
+            twitterHandle,
+        }),
+    );
+    return [
+        createInstruction(
+            NAME_PROGRAM_ID,
+            SystemProgram.programId,
+            reverseRegistryKey,
+            verifiedPubkey,
+            payerKey,
+            hashedVerifiedPubkey,
+            new Numberu64(await connection.getMinimumBalanceForRentExemption(reverseTwitterRegistryStateBuff.length)),
+            new Numberu32(reverseTwitterRegistryStateBuff.length),
+            TWITTER_VERIFICATION_AUTHORITY, // Twitter authority acts as class for all reverse-lookup registries
+            TWITTER_ROOT_PARENT_REGISTRY_KEY, // Reverse registries are also children of the root
+            TWITTER_VERIFICATION_AUTHORITY,
+        ),
+        updateInstruction(
+            NAME_PROGRAM_ID,
+            reverseRegistryKey,
+            new Numberu32(0),
+            Buffer.from(reverseTwitterRegistryStateBuff),
+            TWITTER_VERIFICATION_AUTHORITY,
+            undefined,
         ),
-      ),
-      new Numberu32(reverseTwitterRegistryStateBuff.length),
-      TWITTER_VERIFICATION_AUTHORITY, // Twitter authority acts as class for all reverse-lookup registries
-      TWITTER_ROOT_PARENT_REGISTRY_KEY, // Reverse registries are also children of the root
-      TWITTER_VERIFICATION_AUTHORITY,
-    ),
-    updateInstruction(
-      NAME_PROGRAM_ID,
-      reverseRegistryKey,
-      new Numberu32(0),
-      Buffer.from(reverseTwitterRegistryStateBuff),
-      TWITTER_VERIFICATION_AUTHORITY,
-      undefined,
-    ),
-  ];
+    ];
 }
diff --git a/name-service/js/src/utils.ts b/name-service/js/src/utils.ts
index 1210512b517..29f0779662e 100644
--- a/name-service/js/src/utils.ts
+++ b/name-service/js/src/utils.ts
@@ -2,13 +2,13 @@ import assert from 'assert';
 import { createHash } from 'crypto';
 
 import {
-  AccountInfo,
-  Connection,
-  GetProgramAccountsFilter,
-  Keypair,
-  PublicKey,
-  Transaction,
-  TransactionInstruction,
+    AccountInfo,
+    Connection,
+    GetProgramAccountsFilter,
+    Keypair,
+    PublicKey,
+    Transaction,
+    TransactionInstruction,
 } from '@solana/web3.js';
 import BN from 'bn.js';
 
@@ -16,142 +16,134 @@ import { HASH_PREFIX, NAME_PROGRAM_ID } from './bindings';
 import { NameRegistryState } from './state';
 
 export class Numberu32 extends BN {
-  /**
-   * Convert to Buffer representation
-   */
-  toBuffer(): Buffer {
-    const a = super.toArray().reverse();
-    const b = Buffer.from(a);
-    if (b.length === 4) {
-      return b;
-    }
-    assert(b.length < 4, 'Numberu32 too large');
+    /**
+     * Convert to Buffer representation
+     */
+    toBuffer(): Buffer {
+        const a = super.toArray().reverse();
+        const b = Buffer.from(a);
+        if (b.length === 4) {
+            return b;
+        }
+        assert(b.length < 4, 'Numberu32 too large');
 
-    const zeroPad = Buffer.alloc(4);
-    b.copy(zeroPad);
-    return zeroPad;
-  }
+        const zeroPad = Buffer.alloc(4);
+        b.copy(zeroPad);
+        return zeroPad;
+    }
 
-  /**
-   * Construct a Numberu64 from Buffer representation
-   */
-  static fromBuffer(buffer: Buffer): BN {
-    assert(buffer.length === 4, `Invalid buffer length: ${buffer.length}`);
-    return new BN(
-      [...buffer]
-        .reverse()
-        .map((i) => `00${i.toString(16)}`.slice(-2))
-        .join(''),
-      16,
-    );
-  }
+    /**
+     * Construct a Numberu64 from Buffer representation
+     */
+    static fromBuffer(buffer: Buffer): BN {
+        assert(buffer.length === 4, `Invalid buffer length: ${buffer.length}`);
+        return new BN(
+            [...buffer]
+                .reverse()
+                .map(i => `00${i.toString(16)}`.slice(-2))
+                .join(''),
+            16,
+        );
+    }
 }
 
 export class Numberu64 extends BN {
-  /**
-   * Convert to Buffer representation
-   */
-  toBuffer(): Buffer {
-    const a = super.toArray().reverse();
-    const b = Buffer.from(a);
-    if (b.length === 8) {
-      return b;
-    }
-    assert(b.length < 8, 'Numberu64 too large');
+    /**
+     * Convert to Buffer representation
+     */
+    toBuffer(): Buffer {
+        const a = super.toArray().reverse();
+        const b = Buffer.from(a);
+        if (b.length === 8) {
+            return b;
+        }
+        assert(b.length < 8, 'Numberu64 too large');
 
-    const zeroPad = Buffer.alloc(8);
-    b.copy(zeroPad);
-    return zeroPad;
-  }
+        const zeroPad = Buffer.alloc(8);
+        b.copy(zeroPad);
+        return zeroPad;
+    }
 
-  /**
-   * Construct a Numberu64 from Buffer representation
-   */
-  static fromBuffer(buffer: Buffer): BN {
-    assert(buffer.length === 8, `Invalid buffer length: ${buffer.length}`);
-    return new BN(
-      [...buffer]
-        .reverse()
-        .map((i) => `00${i.toString(16)}`.slice(-2))
-        .join(''),
-      16,
-    );
-  }
+    /**
+     * Construct a Numberu64 from Buffer representation
+     */
+    static fromBuffer(buffer: Buffer): BN {
+        assert(buffer.length === 8, `Invalid buffer length: ${buffer.length}`);
+        return new BN(
+            [...buffer]
+                .reverse()
+                .map(i => `00${i.toString(16)}`.slice(-2))
+                .join(''),
+            16,
+        );
+    }
 }
 
 export const signAndSendTransactionInstructions = async (
-  // sign and send transaction
-  connection: Connection,
-  signers: Array<Keypair>,
-  feePayer: Keypair,
-  txInstructions: Array<TransactionInstruction>,
+    // sign and send transaction
+    connection: Connection,
+    signers: Array<Keypair>,
+    feePayer: Keypair,
+    txInstructions: Array<TransactionInstruction>,
 ): Promise<string> => {
-  const tx = new Transaction();
-  tx.feePayer = feePayer.publicKey;
-  signers.push(feePayer);
-  tx.add(...txInstructions);
-  return await connection.sendTransaction(tx, signers);
+    const tx = new Transaction();
+    tx.feePayer = feePayer.publicKey;
+    signers.push(feePayer);
+    tx.add(...txInstructions);
+    return await connection.sendTransaction(tx, signers);
 };
 
 export async function getHashedName(name: string): Promise<Buffer> {
-  const input = HASH_PREFIX + name;
-  const buffer = createHash('sha256').update(input, 'utf8').digest();
-  return buffer;
+    const input = HASH_PREFIX + name;
+    const buffer = createHash('sha256').update(input, 'utf8').digest();
+    return buffer;
 }
 
 export async function getNameAccountKey(
-  hashed_name: Buffer,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
+    hashed_name: Buffer,
+    nameClass?: PublicKey,
+    nameParent?: PublicKey,
 ): Promise<PublicKey> {
-  const seeds = [hashed_name];
-  if (nameClass) {
-    seeds.push(nameClass.toBuffer());
-  } else {
-    seeds.push(Buffer.alloc(32));
-  }
-  if (nameParent) {
-    seeds.push(nameParent.toBuffer());
-  } else {
-    seeds.push(Buffer.alloc(32));
-  }
-  const [nameAccountKey] = await PublicKey.findProgramAddress(
-    seeds,
-    NAME_PROGRAM_ID,
-  );
-  return nameAccountKey;
+    const seeds = [hashed_name];
+    if (nameClass) {
+        seeds.push(nameClass.toBuffer());
+    } else {
+        seeds.push(Buffer.alloc(32));
+    }
+    if (nameParent) {
+        seeds.push(nameParent.toBuffer());
+    } else {
+        seeds.push(Buffer.alloc(32));
+    }
+    const [nameAccountKey] = await PublicKey.findProgramAddress(seeds, NAME_PROGRAM_ID);
+    return nameAccountKey;
 }
 
-export async function getNameOwner(
-  connection: Connection,
-  nameAccountKey: PublicKey,
-): Promise<NameRegistryState> {
-  const nameAccount = await connection.getAccountInfo(nameAccountKey);
-  if (!nameAccount) {
-    throw new Error('Unable to find the given account.');
-  }
-  return NameRegistryState.retrieve(connection, nameAccountKey);
+export async function getNameOwner(connection: Connection, nameAccountKey: PublicKey): Promise<NameRegistryState> {
+    const nameAccount = await connection.getAccountInfo(nameAccountKey);
+    if (!nameAccount) {
+        throw new Error('Unable to find the given account.');
+    }
+    return NameRegistryState.retrieve(connection, nameAccountKey);
 }
 
 export async function getFilteredProgramAccounts(
-  connection: Connection,
-  programId: PublicKey,
-  filters: GetProgramAccountsFilter[],
+    connection: Connection,
+    programId: PublicKey,
+    filters: GetProgramAccountsFilter[],
 ): Promise<{ publicKey: PublicKey; accountInfo: AccountInfo<Buffer> }[]> {
-  const resp = await connection.getProgramAccounts(programId, {
-    commitment: connection.commitment,
-    filters,
-    encoding: 'base64',
-  });
-  return resp.map(
-    ({ pubkey, account: { data, executable, owner, lamports } }) => ({
-      publicKey: pubkey,
-      accountInfo: {
-        data: data,
-        executable,
-        owner: owner,
-        lamports,
-      },
-    }),
-  );
+    const resp = await connection.getProgramAccounts(programId, {
+        commitment: connection.commitment,
+        filters,
+        encoding: 'base64',
+    });
+    return resp.map(({ pubkey, account: { data, executable, owner, lamports } }) => ({
+        publicKey: pubkey,
+        accountInfo: {
+            data: data,
+            executable,
+            owner: owner,
+            lamports,
+        },
+    }));
 }
diff --git a/name-service/js/test/e2e/index.test.ts b/name-service/js/test/e2e/index.test.ts
index 570dc04eb6b..3f84ff9b109 100644
--- a/name-service/js/test/e2e/index.test.ts
+++ b/name-service/js/test/e2e/index.test.ts
@@ -1,22 +1,22 @@
 import {
-  Connection,
-  Keypair,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  sendAndConfirmTransaction,
-  Transaction,
+    Connection,
+    Keypair,
+    LAMPORTS_PER_SOL,
+    PublicKey,
+    sendAndConfirmTransaction,
+    Transaction,
 } from '@solana/web3.js';
 import { beforeAll, beforeEach, describe, expect, test } from '@jest/globals';
 
 import {
-  createNameRegistry,
-  deleteNameRegistry,
-  getHashedName,
-  getNameAccountKey,
-  NameRegistryState,
-  reallocNameAccount,
-  transferNameOwnership,
-  updateNameRegistryData,
+    createNameRegistry,
+    deleteNameRegistry,
+    getHashedName,
+    getNameAccountKey,
+    NameRegistryState,
+    reallocNameAccount,
+    transferNameOwnership,
+    updateNameRegistryData,
 } from '../../src';
 
 const url = 'http://127.0.0.1:8899';
@@ -27,101 +27,67 @@ const space = 20;
 let nameKey: PublicKey;
 let name: string;
 beforeAll(async () => {
-  const airdropSignature = await connection.requestAirdrop(
-    payer.publicKey,
-    LAMPORTS_PER_SOL,
-  );
-  await connection.confirmTransaction({
-    signature: airdropSignature,
-    ...(await connection.getLatestBlockhash()),
-  });
+    const airdropSignature = await connection.requestAirdrop(payer.publicKey, LAMPORTS_PER_SOL);
+    await connection.confirmTransaction({
+        signature: airdropSignature,
+        ...(await connection.getLatestBlockhash()),
+    });
 });
 
 beforeEach(async () => {
-  name = Math.random().toString() + '.sol';
-  nameKey = await getNameKey(name);
-  const lamports = await connection.getMinimumBalanceForRentExemption(
-    space + NameRegistryState.HEADER_LEN,
-  );
-  const inst = await createNameRegistry(
-    connection,
-    name,
-    space,
-    payer.publicKey,
-    owner.publicKey,
-    lamports,
-  );
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer]);
+    name = Math.random().toString() + '.sol';
+    nameKey = await getNameKey(name);
+    const lamports = await connection.getMinimumBalanceForRentExemption(space + NameRegistryState.HEADER_LEN);
+    const inst = await createNameRegistry(connection, name, space, payer.publicKey, owner.publicKey, lamports);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer]);
 });
 
 test('Create Name Registery', async () => {
-  const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
-  nameAccount.owner.equals(owner.publicKey);
-  expect(nameAccount.data?.length).toEqual(space);
+    const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
+    nameAccount.owner.equals(owner.publicKey);
+    expect(nameAccount.data?.length).toEqual(space);
 });
 test('Update Name Registery', async () => {
-  const data = Buffer.from('@Dudl');
-  const inst = await updateNameRegistryData(connection, name, 0, data);
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer, owner]);
-  const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
-  nameAccount.data?.equals(data);
+    const data = Buffer.from('@Dudl');
+    const inst = await updateNameRegistryData(connection, name, 0, data);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer, owner]);
+    const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
+    nameAccount.data?.equals(data);
 });
 test('Transfer Name Ownership', async () => {
-  const newOwner = Keypair.generate();
-  const inst = await transferNameOwnership(
-    connection,
-    name,
-    newOwner.publicKey,
-  );
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer, owner]);
-  const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
-  nameAccount.owner.equals(newOwner.publicKey);
+    const newOwner = Keypair.generate();
+    const inst = await transferNameOwnership(connection, name, newOwner.publicKey);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer, owner]);
+    const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
+    nameAccount.owner.equals(newOwner.publicKey);
 });
 test('Realloc Name Account to bigger space', async () => {
-  const inst = await reallocNameAccount(
-    connection,
-    name,
-    space + 10,
-    payer.publicKey,
-  );
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer, owner]);
-  const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
-  expect(nameAccount.data?.length).toEqual(space + 10);
+    const inst = await reallocNameAccount(connection, name, space + 10, payer.publicKey);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer, owner]);
+    const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
+    expect(nameAccount.data?.length).toEqual(space + 10);
 });
 test('Realloc Name Account to smaller space', async () => {
-  const inst = await reallocNameAccount(
-    connection,
-    name,
-    space - 10,
-    payer.publicKey,
-  );
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer, owner]);
-  const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
-  expect(nameAccount.data?.length).toEqual(space - 10);
+    const inst = await reallocNameAccount(connection, name, space - 10, payer.publicKey);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer, owner]);
+    const nameAccount = await NameRegistryState.retrieve(connection, nameKey);
+    expect(nameAccount.data?.length).toEqual(space - 10);
 });
 test('Delete Name Registry', async () => {
-  const inst = await deleteNameRegistry(connection, name, payer.publicKey);
-  const tx = new Transaction().add(inst);
-  await sendAndConfirmTransaction(connection, tx, [payer, owner]);
-  const nameAccount = await connection.getAccountInfo(nameKey);
-  expect(nameAccount).toBeNull;
+    const inst = await deleteNameRegistry(connection, name, payer.publicKey);
+    const tx = new Transaction().add(inst);
+    await sendAndConfirmTransaction(connection, tx, [payer, owner]);
+    const nameAccount = await connection.getAccountInfo(nameKey);
+    expect(nameAccount).toBeNull;
 });
 
-const getNameKey = async (
-  name: string,
-  nameClass?: PublicKey,
-  parentName?: PublicKey,
-) => {
-  const hashedName = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashedName,
-    nameClass,
-    parentName,
-  );
-  return nameAccountKey;
+const getNameKey = async (name: string, nameClass?: PublicKey, parentName?: PublicKey) => {
+    const hashedName = await getHashedName(name);
+    const nameAccountKey = await getNameAccountKey(hashedName, nameClass, parentName);
+    return nameAccountKey;
 };
diff --git a/name-service/js/test/unit/index.test.ts b/name-service/js/test/unit/index.test.ts
index 5ae8f81a721..87d3d67de03 100644
--- a/name-service/js/test/unit/index.test.ts
+++ b/name-service/js/test/unit/index.test.ts
@@ -1,137 +1,120 @@
-import {
-  Keypair,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-} from '@solana/web3.js';
+import { Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram } from '@solana/web3.js';
 
 import {
-  createInstruction,
-  deleteInstruction,
-  reallocInstruction,
-  transferInstruction,
-  updateInstruction,
+    createInstruction,
+    deleteInstruction,
+    reallocInstruction,
+    transferInstruction,
+    updateInstruction,
 } from '../../src';
 import { Numberu32, Numberu64 } from '../../src/utils';
 
 import { describe, expect, test } from '@jest/globals';
 
 describe('SplNameService Instructions', () => {
-  const nameServiceAddress = new PublicKey(
-    'namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX',
-  );
-  const nameAccountKey = Keypair.generate().publicKey;
-  const nameOwnerKey = Keypair.generate().publicKey;
-  const payerKey = Keypair.generate().publicKey;
-  const nameClassKey = Keypair.generate().publicKey;
-  const nameParent = Keypair.generate().publicKey;
-  const nameParentOwner = Keypair.generate().publicKey;
-  const name = Buffer.from('hello');
+    const nameServiceAddress = new PublicKey('namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX');
+    const nameAccountKey = Keypair.generate().publicKey;
+    const nameOwnerKey = Keypair.generate().publicKey;
+    const payerKey = Keypair.generate().publicKey;
+    const nameClassKey = Keypair.generate().publicKey;
+    const nameParent = Keypair.generate().publicKey;
+    const nameParentOwner = Keypair.generate().publicKey;
+    const name = Buffer.from('hello');
 
-  test('createInstruction without class and parent name key', () => {
-    const instruction = createInstruction(
-      nameServiceAddress,
-      SystemProgram.programId,
-      nameAccountKey,
-      nameOwnerKey,
-      payerKey,
-      name,
-      new Numberu64(LAMPORTS_PER_SOL),
-      new Numberu64(10),
-    );
+    test('createInstruction without class and parent name key', () => {
+        const instruction = createInstruction(
+            nameServiceAddress,
+            SystemProgram.programId,
+            nameAccountKey,
+            nameOwnerKey,
+            payerKey,
+            name,
+            new Numberu64(LAMPORTS_PER_SOL),
+            new Numberu64(10),
+        );
 
-    expect(instruction.keys).toHaveLength(6);
-    instruction.keys[0].pubkey.equals(SystemProgram.programId);
-    instruction.keys[1].pubkey.equals(payerKey);
-    instruction.keys[2].pubkey.equals(nameAccountKey);
-    instruction.keys[3].pubkey.equals(nameOwnerKey);
-    instruction.keys[4].pubkey.equals(new PublicKey(Buffer.alloc(32)));
-    instruction.keys[5].pubkey.equals(new PublicKey(Buffer.alloc(32)));
-  });
+        expect(instruction.keys).toHaveLength(6);
+        instruction.keys[0].pubkey.equals(SystemProgram.programId);
+        instruction.keys[1].pubkey.equals(payerKey);
+        instruction.keys[2].pubkey.equals(nameAccountKey);
+        instruction.keys[3].pubkey.equals(nameOwnerKey);
+        instruction.keys[4].pubkey.equals(new PublicKey(Buffer.alloc(32)));
+        instruction.keys[5].pubkey.equals(new PublicKey(Buffer.alloc(32)));
+    });
 
-  test('createInstruction with class and parent name key', () => {
-    const instruction = createInstruction(
-      nameServiceAddress,
-      SystemProgram.programId,
-      nameAccountKey,
-      nameOwnerKey,
-      payerKey,
-      name,
-      new Numberu64(LAMPORTS_PER_SOL),
-      new Numberu64(10),
-      nameClassKey,
-      nameParent,
-      nameParentOwner,
-    );
+    test('createInstruction with class and parent name key', () => {
+        const instruction = createInstruction(
+            nameServiceAddress,
+            SystemProgram.programId,
+            nameAccountKey,
+            nameOwnerKey,
+            payerKey,
+            name,
+            new Numberu64(LAMPORTS_PER_SOL),
+            new Numberu64(10),
+            nameClassKey,
+            nameParent,
+            nameParentOwner,
+        );
 
-    expect(instruction.keys).toHaveLength(7);
-    instruction.keys[0].pubkey.equals(SystemProgram.programId);
-    instruction.keys[1].pubkey.equals(payerKey);
-    instruction.keys[2].pubkey.equals(nameAccountKey);
-    instruction.keys[3].pubkey.equals(nameOwnerKey);
-    instruction.keys[4].pubkey.equals(nameClassKey);
-    instruction.keys[5].pubkey.equals(nameParent);
-    instruction.keys[6].pubkey.equals(nameParentOwner);
-  });
+        expect(instruction.keys).toHaveLength(7);
+        instruction.keys[0].pubkey.equals(SystemProgram.programId);
+        instruction.keys[1].pubkey.equals(payerKey);
+        instruction.keys[2].pubkey.equals(nameAccountKey);
+        instruction.keys[3].pubkey.equals(nameOwnerKey);
+        instruction.keys[4].pubkey.equals(nameClassKey);
+        instruction.keys[5].pubkey.equals(nameParent);
+        instruction.keys[6].pubkey.equals(nameParentOwner);
+    });
 
-  test('updateInstruction', () => {
-    const data = Buffer.from('@Dudl');
-    const instruction = updateInstruction(
-      nameServiceAddress,
-      nameAccountKey,
-      new Numberu32(0),
-      data,
-      nameOwnerKey,
-      undefined,
-    );
+    test('updateInstruction', () => {
+        const data = Buffer.from('@Dudl');
+        const instruction = updateInstruction(
+            nameServiceAddress,
+            nameAccountKey,
+            new Numberu32(0),
+            data,
+            nameOwnerKey,
+            undefined,
+        );
 
-    expect(instruction.keys).toHaveLength(2);
-    instruction.keys[0].pubkey.equals(nameAccountKey);
-    instruction.keys[1].pubkey.equals(nameOwnerKey);
-  });
+        expect(instruction.keys).toHaveLength(2);
+        instruction.keys[0].pubkey.equals(nameAccountKey);
+        instruction.keys[1].pubkey.equals(nameOwnerKey);
+    });
 
-  test('transferInstruction', () => {
-    const newOwner = Keypair.generate().publicKey;
-    const instruction = transferInstruction(
-      nameServiceAddress,
-      nameAccountKey,
-      newOwner,
-      nameOwnerKey,
-    );
+    test('transferInstruction', () => {
+        const newOwner = Keypair.generate().publicKey;
+        const instruction = transferInstruction(nameServiceAddress, nameAccountKey, newOwner, nameOwnerKey);
 
-    expect(instruction.keys).toHaveLength(2);
-    instruction.keys[0].pubkey.equals(nameAccountKey);
-    instruction.keys[1].pubkey.equals(nameOwnerKey);
-  });
+        expect(instruction.keys).toHaveLength(2);
+        instruction.keys[0].pubkey.equals(nameAccountKey);
+        instruction.keys[1].pubkey.equals(nameOwnerKey);
+    });
 
-  test('deleteInstruction', () => {
-    const instruction = deleteInstruction(
-      nameServiceAddress,
-      nameAccountKey,
-      payerKey,
-      nameOwnerKey,
-    );
+    test('deleteInstruction', () => {
+        const instruction = deleteInstruction(nameServiceAddress, nameAccountKey, payerKey, nameOwnerKey);
 
-    expect(instruction.keys).toHaveLength(3);
-    instruction.keys[0].pubkey.equals(nameAccountKey);
-    instruction.keys[1].pubkey.equals(nameOwnerKey);
-    instruction.keys[2].pubkey.equals(payerKey);
-  });
+        expect(instruction.keys).toHaveLength(3);
+        instruction.keys[0].pubkey.equals(nameAccountKey);
+        instruction.keys[1].pubkey.equals(nameOwnerKey);
+        instruction.keys[2].pubkey.equals(payerKey);
+    });
 
-  test('reallocInstruction', () => {
-    const instruction = reallocInstruction(
-      nameServiceAddress,
-      SystemProgram.programId,
-      payerKey,
-      nameAccountKey,
-      nameOwnerKey,
-      new Numberu32(30),
-    );
+    test('reallocInstruction', () => {
+        const instruction = reallocInstruction(
+            nameServiceAddress,
+            SystemProgram.programId,
+            payerKey,
+            nameAccountKey,
+            nameOwnerKey,
+            new Numberu32(30),
+        );
 
-    expect(instruction.keys).toHaveLength(4);
-    instruction.keys[0].pubkey.equals(SystemProgram.programId);
-    instruction.keys[1].pubkey.equals(payerKey);
-    instruction.keys[2].pubkey.equals(nameAccountKey);
-    instruction.keys[3].pubkey.equals(nameOwnerKey);
-  });
+        expect(instruction.keys).toHaveLength(4);
+        instruction.keys[0].pubkey.equals(SystemProgram.programId);
+        instruction.keys[1].pubkey.equals(payerKey);
+        instruction.keys[2].pubkey.equals(nameAccountKey);
+        instruction.keys[3].pubkey.equals(nameOwnerKey);
+    });
 });
diff --git a/name-service/program/Cargo.toml b/name-service/program/Cargo.toml
index 67b21014980..977b2e99698 100644
--- a/name-service/program/Cargo.toml
+++ b/name-service/program/Cargo.toml
@@ -17,15 +17,15 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
+solana-program = "2.1.0"
 num-traits = "0.2"
-borsh = "1.5.1"
+borsh = "1.5.3"
 num-derive = "0.4.2"
-thiserror = "1.0.61"
+thiserror = "2.0.9"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/package.json b/package.json
index 21da664edb6..8369712d241 100644
--- a/package.json
+++ b/package.json
@@ -2,14 +2,7 @@
     "private": true,
     "workspaces": [
         "account-compression/sdk",
-        "libraries/type-length-value/js",
-        "memo/js",
-        "single-pool/js",
-        "stake-pool/js",
-        "token/js",
-        "token-group/js",
         "token-lending/js",
-        "token-metadata/js",
         "token-swap/js"
     ],
     "scripts": {
@@ -17,14 +10,18 @@
         "build:program": "turbo run build:program",
         "clean": "turbo run clean",
         "lint": "turbo run lint",
-        "lint:fix": "turbo run lint:fix",
+        "format": "prettier --check .",
+        "format:fix": "prettier --write .",
         "test": "turbo run test"
     },
     "devDependencies": {
-        "@solana/eslint-config-solana": "^3.0.3",
+        "@solana/eslint-config-solana": "^4.0.0",
         "@solana/prettier-config-solana": "^0.0.5",
-        "eslint-config-turbo": "^2.0.4",
-        "turbo": "^2.0.4"
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-config-turbo": "^2.3.3",
+        "eslint-plugin-prettier": "^5.2.1",
+        "prettier": "^3.4.2",
+        "turbo": "^2.3.3"
     },
     "engines": {
         "node": ">=14.0.0"
diff --git a/patch.crates-io.sh b/patch.crates-io.sh
index f3b99723dfe..d7374fc32d0 100755
--- a/patch.crates-io.sh
+++ b/patch.crates-io.sh
@@ -51,27 +51,30 @@ solana_ver=${solana_ver:-$(readCargoVariable version "$solana_dir"/sdk/Cargo.tom
 
 crates_map=()
 crates_map+=("solana-account-decoder account-decoder")
+crates_map+=("solana-account-decoder-client-types account-decoder-client-types")
 crates_map+=("solana-banks-client banks-client")
 crates_map+=("solana-banks-interface banks-interface")
 crates_map+=("solana-banks-server banks-server")
 crates_map+=("solana-bloom bloom")
 crates_map+=("solana-bucket-map bucket_map")
+crates_map+=("solana-builtins-default-costs builtins-default-costs")
 crates_map+=("solana-clap-utils clap-utils")
 crates_map+=("solana-clap-v3-utils clap-v3-utils")
 crates_map+=("solana-cli-config cli-config")
 crates_map+=("solana-cli-output cli-output")
 crates_map+=("solana-client client")
+crates_map+=("solana-compute-budget compute-budget")
 crates_map+=("solana-connection-cache connection-cache")
 crates_map+=("solana-core core")
 crates_map+=("solana-entry entry")
 crates_map+=("solana-faucet faucet")
-crates_map+=("solana-frozen-abi frozen-abi")
-crates_map+=("solana-frozen-abi-macro frozen-abi/macro")
-crates_map+=("solana-geyser-plugin-interface geyser-plugin-interface")
+crates_map+=("solana-fee fee")
+crates_map+=("agave-geyser-plugin-interface geyser-plugin-interface")
 crates_map+=("solana-geyser-plugin-manager geyser-plugin-manager")
 crates_map+=("solana-gossip gossip")
+crates_map+=("solana-lattice-hash lattice-hash")
 crates_map+=("solana-ledger ledger")
-crates_map+=("solana-logger logger")
+crates_map+=("solana-log-collector log-collector")
 crates_map+=("solana-measure measure")
 crates_map+=("solana-merkle-tree merkle-tree")
 crates_map+=("solana-metrics metrics")
@@ -85,7 +88,9 @@ crates_map+=("solana-bpf-loader-program programs/bpf_loader")
 crates_map+=("solana-compute-budget-program programs/compute-budget")
 crates_map+=("solana-config-program programs/config")
 crates_map+=("solana-stake-program programs/stake")
+crates_map+=("solana-system-program programs/system")
 crates_map+=("solana-vote-program programs/vote")
+crates_map+=("solana-zk-elgamal-proof-program programs/zk-elgamal-proof")
 crates_map+=("solana-zk-token-proof-program programs/zk-token-proof")
 crates_map+=("solana-pubsub-client pubsub-client")
 crates_map+=("solana-quic-client quic-client")
@@ -96,6 +101,7 @@ crates_map+=("solana-rpc-client rpc-client")
 crates_map+=("solana-rpc-client-api rpc-client-api")
 crates_map+=("solana-rpc-client-nonce-utils rpc-client-nonce-utils")
 crates_map+=("solana-runtime runtime")
+crates_map+=("solana-runtime-transaction runtime-transaction")
 crates_map+=("solana-sdk sdk")
 crates_map+=("solana-sdk-macro sdk/macro")
 crates_map+=("solana-program sdk/program")
@@ -103,13 +109,61 @@ crates_map+=("solana-send-transaction-service send-transaction-service")
 crates_map+=("solana-storage-bigtable storage-bigtable")
 crates_map+=("solana-storage-proto storage-proto")
 crates_map+=("solana-streamer streamer")
+crates_map+=("solana-svm-rent-collector svm-rent-collector")
+crates_map+=("solana-svm-transaction svm-transaction")
 crates_map+=("solana-test-validator test-validator")
 crates_map+=("solana-thin-client thin-client")
 crates_map+=("solana-tpu-client tpu-client")
 crates_map+=("solana-transaction-status transaction-status")
+crates_map+=("solana-transaction-status-client-types transaction-status-client-types")
 crates_map+=("solana-udp-client udp-client")
 crates_map+=("solana-version version")
 crates_map+=("solana-zk-token-sdk zk-token-sdk")
+crates_map+=("solana-zk-sdk zk-sdk")
+crates_map+=("solana-bn254 curves/bn254")
+crates_map+=("solana-curve25519 curves/curve25519")
+crates_map+=("solana-secp256k1-recover curves/secp256k1-recover")
+crates_map+=("solana-account sdk/account")
+crates_map+=("solana-account-info sdk/account-info")
+crates_map+=("solana-atomic-u64 sdk/atomic-u64")
+crates_map+=("solana-bincode sdk/bincode")
+crates_map+=("solana-borsh sdk/borsh")
+crates_map+=("solana-clock sdk/clock")
+crates_map+=("solana-cpi sdk/cpi")
+crates_map+=("solana-decode-error sdk/decode-error")
+crates_map+=("solana-define-syscall sdk/define-syscall")
+crates_map+=("solana-derivation-path sdk/derivation-path")
+crates_map+=("solana-epoch-schedule sdk/epoch-schedule")
+crates_map+=("solana-feature-set sdk/feature-set")
+crates_map+=("solana-fee-calculator sdk/fee-calculator")
+crates_map+=("solana-frozen-abi sdk/frozen-abi")
+crates_map+=("solana-frozen-abi-macro sdk/frozen-abi/macro")
+crates_map+=("solana-hash sdk/hash")
+crates_map+=("solana-inflation sdk/inflation")
+crates_map+=("solana-instruction sdk/instruction")
+crates_map+=("solana-last-restart-slot sdk/last-restart-slot")
+crates_map+=("solana-logger sdk/logger")
+crates_map+=("solana-msg sdk/msg")
+crates_map+=("solana-native-token sdk/native-token")
+crates_map+=("solana-packet sdk/packet")
+crates_map+=("solana-precompile-error sdk/precompile-error")
+crates_map+=("solana-program-entrypoint sdk/program-entrypoint")
+crates_map+=("solana-program-error sdk/program-error")
+crates_map+=("solana-program-memory sdk/program-memory")
+crates_map+=("solana-program-option sdk/program-option")
+crates_map+=("solana-program-pack sdk/program-pack")
+crates_map+=("solana-pubkey sdk/pubkey")
+crates_map+=("solana-rent sdk/rent")
+crates_map+=("solana-sanitize sdk/sanitize")
+crates_map+=("solana-serde-varint sdk/serde-varint")
+crates_map+=("solana-serialize-utils sdk/serialize-utils")
+crates_map+=("solana-sha256-hasher sdk/sha256-hasher")
+crates_map+=("solana-short-vec sdk/short-vec")
+crates_map+=("solana-signature sdk/signature")
+crates_map+=("solana-slot-hashes sdk/slot-hashes")
+crates_map+=("solana-stable-layout sdk/stable-layout")
+crates_map+=("solana-timings sdk/timings")
+crates_map+=("solana-transaction-error sdk/transaction-error")
 
 patch_crates=()
 for map_entry in "${crates_map[@]}"; do
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e488c3fce1f..b139175ded3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -9,17 +9,26 @@ importers:
   .:
     devDependencies:
       '@solana/eslint-config-solana':
-        specifier: ^3.0.3
-        version: 3.0.3(@typescript-eslint/eslint-plugin@6.21.0)(@typescript-eslint/parser@6.21.0)(eslint-plugin-jest@27.9.0)(eslint-plugin-react-hooks@4.6.0)(eslint-plugin-simple-import-sort@10.0.0)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.2.0)(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^4.0.0
+        version: 4.0.0(@eslint/js@9.13.0)(@types/eslint__js@8.42.3)(eslint-plugin-jest@28.10.0)(eslint-plugin-react-hooks@5.0.0)(eslint-plugin-simple-import-sort@12.1.1)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.3.0)(eslint@9.13.0)(globals@15.11.0)(jest@30.0.0-alpha.6)(typescript-eslint@8.12.2)(typescript@5.7.2)
       '@solana/prettier-config-solana':
         specifier: ^0.0.5
-        version: 0.0.5(prettier@3.3.2)
+        version: 0.0.5(prettier@3.4.2)
+      eslint-config-prettier:
+        specifier: ^9.1.0
+        version: 9.1.0(eslint@9.13.0)
       eslint-config-turbo:
-        specifier: ^2.0.4
-        version: 2.0.4(eslint@8.57.0)
+        specifier: ^2.3.3
+        version: 2.3.3(eslint@9.13.0)
+      eslint-plugin-prettier:
+        specifier: ^5.2.1
+        version: 5.2.1(eslint-config-prettier@9.1.0)(eslint@9.13.0)(prettier@3.4.2)
+      prettier:
+        specifier: ^3.4.2
+        version: 3.4.2
       turbo:
-        specifier: ^2.0.4
-        version: 2.0.4
+        specifier: ^2.3.3
+        version: 2.3.3
 
   account-compression/sdk:
     dependencies:
@@ -30,8 +39,8 @@ importers:
         specifier: ^0.4.1
         version: 0.4.1
       '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
+        specifier: ^1.95.4
+        version: 1.95.4
       bn.js:
         specifier: ^5.2.1
         version: 5.2.1
@@ -42,230 +51,90 @@ importers:
         specifier: ^1.3.3
         version: 1.3.3
     devDependencies:
+      '@coral-xyz/anchor':
+        specifier: ^0.29.0
+        version: 0.29.0
       '@metaplex-foundation/rustbin':
         specifier: ^0.3.5
         version: 0.3.5
       '@metaplex-foundation/solita':
         specifier: 0.20.1
         version: 0.20.1
-      '@project-serum/anchor':
-        specifier: ^0.26.0
-        version: 0.26.0
       '@solana/eslint-config-solana':
         specifier: ^3.0.3
-        version: 3.0.3(@typescript-eslint/eslint-plugin@7.13.1)(@typescript-eslint/parser@7.13.1)(eslint-plugin-jest@28.6.0)(eslint-plugin-react-hooks@4.6.0)(eslint-plugin-simple-import-sort@12.1.0)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.2.0)(eslint@8.57.0)(typescript@5.4.5)
-      '@solana/prettier-config-solana':
-        specifier: ^0.0.5
-        version: 0.0.5(prettier@3.3.2)
+        version: 3.0.6(@typescript-eslint/eslint-plugin@8.12.2)(@typescript-eslint/parser@8.12.2)(eslint-plugin-jest@28.10.0)(eslint-plugin-react-hooks@4.6.2)(eslint-plugin-simple-import-sort@12.1.1)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.3.0)(eslint@8.57.0)(typescript@5.7.2)
       '@types/bn.js':
-        specifier: ^5.1.0
-        version: 5.1.5
+        specifier: ^5.1.6
+        version: 5.1.6
       '@types/jest':
-        specifier: ^29.5.12
-        version: 29.5.12
+        specifier: ^29.5.14
+        version: 29.5.14
+      '@types/node':
+        specifier: ^22.10.5
+        version: 22.10.5
       '@types/node-fetch':
-        specifier: ^2.6.11
-        version: 2.6.11
+        specifier: ^2.6.12
+        version: 2.6.12
       '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.12.2(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2)
       '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.12.2(eslint@8.57.0)(typescript@5.7.2)
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
       eslint-config-turbo:
-        specifier: ^2.0.4
-        version: 2.0.4(eslint@8.57.0)
+        specifier: ^2.3.3
+        version: 2.3.3(eslint@8.57.0)
       eslint-plugin-import:
-        specifier: ^2.29.1
-        version: 2.29.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)
+        specifier: ^2.31.0
+        version: 2.31.0(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)
       eslint-plugin-jest:
-        specifier: ^28.6.0
-        version: 28.6.0(@typescript-eslint/eslint-plugin@7.13.1)(eslint@8.57.0)(jest@29.7.0)(typescript@5.4.5)
+        specifier: ^28.10.0
+        version: 28.10.0(@typescript-eslint/eslint-plugin@8.12.2)(eslint@8.57.0)(jest@29.7.0)(typescript@5.7.2)
       eslint-plugin-mocha:
-        specifier: ^10.4.3
-        version: 10.4.3(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
+        specifier: ^10.5.0
+        version: 10.5.0(eslint@8.57.0)
       eslint-plugin-simple-import-sort:
-        specifier: ^12.1.0
-        version: 12.1.0(eslint@8.57.0)
+        specifier: ^12.1.1
+        version: 12.1.1(eslint@8.57.0)
       eslint-plugin-sort-keys-fix:
         specifier: ^1.1.2
         version: 1.1.2
       gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
+        specifier: ^6.3.0
+        version: 6.3.0
       jest:
         specifier: ^29.0.1
-        version: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+        version: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       jest-config:
         specifier: ^29.0.1
-        version: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
+        version: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       start-server-and-test:
-        specifier: ^2.0.4
-        version: 2.0.4
+        specifier: ^2.0.9
+        version: 2.0.9
       ts-jest:
-        specifier: ^29.1.5
-        version: 29.1.5(@babel/core@7.23.2)(jest@29.7.0)(typescript@5.4.5)
+        specifier: ^29.2.5
+        version: 29.2.5(@babel/core@7.26.0)(jest@29.7.0)(typescript@5.7.2)
       ts-jest-resolver:
         specifier: ^2.0.1
         version: 2.0.1
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
-      typescript:
-        specifier: 5.4.5
-        version: 5.4.5
-
-  libraries/type-length-value/js:
-    dependencies:
-      buffer:
-        specifier: ^6.0.3
-        version: 6.0.3
-    devDependencies:
-      '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
-      '@types/mocha':
-        specifier: ^10.0.6
-        version: 10.0.6
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      chai:
-        specifier: ^5.1.1
-        version: 5.1.1
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      eslint-plugin-require-extensions:
-        specifier: ^0.1.1
-        version: 0.1.3(eslint@8.57.0)
-      gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
-      mocha:
-        specifier: ^10.4.0
-        version: 10.4.0
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      shx:
-        specifier: ^0.3.4
-        version: 0.3.4
-      ts-node:
-        specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  memo/js:
-    dependencies:
-      buffer:
-        specifier: ^6.0.3
-        version: 6.0.3
-    devDependencies:
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-      '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
-      '@types/jest':
-        specifier: ^29.5.12
-        version: 29.5.12
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@types/node-fetch':
-        specifier: ^2.6.11
-        version: 2.6.11
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      chai:
-        specifier: ^5.1.1
-        version: 5.1.1
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      eslint-plugin-require-extensions:
-        specifier: ^0.1.1
-        version: 0.1.3(eslint@8.57.0)
-      gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
-      jest:
-        specifier: ^29.0.0
-        version: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      process:
-        specifier: ^0.11.10
-        version: 0.11.10
-      shx:
-        specifier: ^0.3.4
-        version: 0.3.4
-      start-server-and-test:
-        specifier: ^2.0.4
-        version: 2.0.4
-      ts-jest:
-        specifier: ^29.1.5
-        version: 29.1.5(@babel/core@7.23.2)(jest@29.7.0)(typescript@5.4.5)
-      ts-node:
-        specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
+        version: 10.9.2(@types/node@22.10.5)(typescript@5.7.2)
       typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
+        specifier: ^0.27.6
+        version: 0.27.6(typescript@5.7.2)
       typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
+        specifier: 5.7.2
+        version: 5.7.2
 
   name-service/js:
     dependencies:
       '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
+        specifier: ^1.95.5
+        version: 1.95.5
       bn.js:
         specifier: ^5.1.3
         version: 5.2.1
@@ -277,285 +146,50 @@ importers:
         specifier: ^29.7.0
         version: 29.7.0
       '@types/bn.js':
-        specifier: ^5.1.1
-        version: 5.1.5
+        specifier: ^5.1.6
+        version: 5.1.6
       '@types/jest':
-        specifier: ^29.5.12
-        version: 29.5.12
+        specifier: ^29.5.14
+        version: 29.5.14
       '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
+        specifier: ^22.10.5
+        version: 22.10.5
       '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)(typescript@5.7.2)
       '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(eslint@8.57.0)(typescript@5.7.2)
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
       eslint-plugin-eslint-comments:
         specifier: ^3.2.0
         version: 3.2.0(eslint@8.57.0)
       eslint-plugin-functional:
-        specifier: ^6.5.1
-        version: 6.5.1(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^7.2.1
+        version: 7.2.1(eslint@8.57.0)(typescript@5.7.2)
       eslint-plugin-import:
-        specifier: ^2.29.1
-        version: 2.29.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)
+        specifier: ^2.31.0
+        version: 2.31.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)
       jest:
         specifier: ^29.7.0
-        version: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
+        version: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       start-server-and-test:
-        specifier: ^2.0.4
-        version: 2.0.4
+        specifier: ^2.0.9
+        version: 2.0.9
       ts-jest:
-        specifier: ^29.1.5
-        version: 29.1.5(@babel/core@7.23.2)(jest@29.7.0)(typescript@5.4.5)
+        specifier: ^29.2.5
+        version: 29.2.5(@babel/core@7.26.0)(jest@29.7.0)(typescript@5.7.2)
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
+        version: 10.9.2(@types/node@22.10.5)(typescript@5.7.2)
       typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  single-pool/js/packages/classic:
-    dependencies:
-      '@solana/spl-single-pool':
-        specifier: 1.0.0
-        version: link:../modern
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-    devDependencies:
-      '@ava/typescript':
-        specifier: ^5.0.0
-        version: 5.0.0
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      ava:
-        specifier: ^6.1.3
-        version: 6.1.3(@ava/typescript@5.0.0)
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      solana-bankrun:
-        specifier: ^0.2.0
-        version: 0.2.0
-      tsx:
-        specifier: ^4.15.6
-        version: 4.15.6
+        specifier: ^0.27.6
+        version: 0.27.6(typescript@5.7.2)
       typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  single-pool/js/packages/modern:
-    dependencies:
-      '@solana/web3.js':
-        specifier: '=2.0.0-experimental.21e994f'
-        version: 2.0.0-experimental.21e994f(node-fetch@2.7.0)(ws@8.14.2)
-    devDependencies:
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  stake-pool/js:
-    dependencies:
-      '@solana/buffer-layout':
-        specifier: ^4.0.1
-        version: 4.0.1
-      '@solana/spl-token':
-        specifier: 0.4.6
-        version: 0.4.6(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-      bn.js:
-        specifier: ^5.2.0
-        version: 5.2.1
-      buffer:
-        specifier: ^6.0.3
-        version: 6.0.3
-      buffer-layout:
-        specifier: ^1.2.2
-        version: 1.2.2
-      superstruct:
-        specifier: ^1.0.4
-        version: 1.0.4
-    devDependencies:
-      '@rollup/plugin-alias':
-        specifier: ^5.1.0
-        version: 5.1.0(rollup@4.18.0)
-      '@rollup/plugin-commonjs':
-        specifier: ^26.0.1
-        version: 26.0.1(rollup@4.18.0)
-      '@rollup/plugin-json':
-        specifier: ^6.1.0
-        version: 6.1.0(rollup@4.18.0)
-      '@rollup/plugin-multi-entry':
-        specifier: ^6.0.0
-        version: 6.0.1(rollup@4.18.0)
-      '@rollup/plugin-node-resolve':
-        specifier: ^15.0.2
-        version: 15.2.3(rollup@4.18.0)
-      '@rollup/plugin-terser':
-        specifier: ^0.4.4
-        version: 0.4.4(rollup@4.18.0)
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.6
-        version: 11.1.6(rollup@4.18.0)(tslib@2.6.3)(typescript@5.4.5)
-      '@types/bn.js':
-        specifier: ^5.1.0
-        version: 5.1.5
-      '@types/jest':
-        specifier: ^29.5.12
-        version: 29.5.12
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@types/node-fetch':
-        specifier: ^2.6.11
-        version: 2.6.11
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      cross-env:
-        specifier: ^7.0.3
-        version: 7.0.3
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      jest:
-        specifier: ^29.0.0
-        version: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      rimraf:
-        specifier: ^5.0.7
-        version: 5.0.7
-      rollup:
-        specifier: ^4.18.0
-        version: 4.18.0
-      rollup-plugin-dts:
-        specifier: ^6.1.1
-        version: 6.1.1(rollup@4.18.0)(typescript@5.4.5)
-      ts-jest:
-        specifier: ^29.1.5
-        version: 29.1.5(@babel/core@7.23.2)(jest@29.7.0)(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  token-group/js:
-    dependencies:
-      '@solana/codecs':
-        specifier: 2.0.0-preview.3
-        version: 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-type-length-value':
-        specifier: 0.1.0
-        version: link:../../libraries/type-length-value/js
-    devDependencies:
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-      '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
-      '@types/mocha':
-        specifier: ^10.0.6
-        version: 10.0.6
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      chai:
-        specifier: ^5.1.1
-        version: 5.1.1
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      eslint-plugin-require-extensions:
-        specifier: ^0.1.1
-        version: 0.1.3(eslint@8.57.0)
-      gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
-      mocha:
-        specifier: ^10.4.0
-        version: 10.4.0
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      shx:
-        specifier: ^0.3.4
-        version: 0.3.4
-      ts-node:
-        specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      tslib:
-        specifier: ^2.6.3
-        version: 2.6.3
-      typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
+        specifier: ^5.7.2
+        version: 5.7.2
 
   token-lending/js:
     dependencies:
@@ -573,132 +207,53 @@ importers:
         version: 9.1.2
     devDependencies:
       '@rollup/plugin-commonjs':
-        specifier: ^26.0.1
-        version: 26.0.1(rollup@4.18.0)
+        specifier: ^28.0.2
+        version: 28.0.2(rollup@4.30.1)
       '@rollup/plugin-node-resolve':
-        specifier: ^15.0.2
-        version: 15.2.3(rollup@4.18.0)
+        specifier: ^16.0.0
+        version: 16.0.0(rollup@4.30.1)
       '@rollup/plugin-typescript':
-        specifier: ^11.1.6
-        version: 11.1.6(rollup@4.18.0)(tslib@2.6.3)(typescript@5.4.5)
+        specifier: ^12.1.2
+        version: 12.1.2(rollup@4.30.1)(tslib@2.8.1)(typescript@5.7.2)
       '@solana/spl-token':
-        specifier: 0.4.6
-        version: 0.4.6(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
+        specifier: 0.4.9
+        version: 0.4.9(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
       '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
+        specifier: ^1.95.5
+        version: 1.95.5
       '@types/eslint':
         specifier: ^8.56.7
         version: 8.56.7
-      '@types/eslint-plugin-prettier':
-        specifier: ^3.1.0
-        version: 3.1.3
       '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
+        specifier: ^22.10.5
+        version: 22.10.5
       '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)(typescript@5.7.2)
       '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(eslint@8.57.0)(typescript@5.7.2)
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
       gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
+        specifier: ^6.3.0
+        version: 6.3.0
       rollup:
-        specifier: ^4.18.0
-        version: 4.18.0
+        specifier: ^4.30.1
+        version: 4.30.1
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
+        version: 10.9.2(@types/node@22.10.5)(typescript@5.7.2)
       tslib:
-        specifier: ^2.6.3
-        version: 2.6.3
+        specifier: ^2.8.1
+        version: 2.8.1
       typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
+        specifier: ^0.27.6
+        version: 0.27.6(typescript@5.7.2)
       typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  token-metadata/js:
-    dependencies:
-      '@solana/codecs':
-        specifier: 2.0.0-preview.3
-        version: 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-type-length-value':
-        specifier: 0.1.0
-        version: link:../../libraries/type-length-value/js
-    devDependencies:
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-      '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
-      '@types/mocha':
-        specifier: ^10.0.6
-        version: 10.0.6
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      chai:
-        specifier: ^5.1.1
-        version: 5.1.1
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      eslint-plugin-require-extensions:
-        specifier: ^0.1.1
-        version: 0.1.3(eslint@8.57.0)
-      gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
-      mocha:
-        specifier: ^10.4.0
-        version: 10.4.0
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      shx:
-        specifier: ^0.3.4
-        version: 0.3.4
-      ts-node:
-        specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      tslib:
-        specifier: ^2.6.3
-        version: 2.6.3
-      typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
+        specifier: ^5.7.2
+        version: 5.7.2
 
   token-swap/js:
     dependencies:
@@ -710,153 +265,50 @@ importers:
         version: 0.2.0
     devDependencies:
       '@solana/spl-token':
-        specifier: 0.4.6
-        version: 0.4.6(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
+        specifier: 0.4.9
+        version: 0.4.9(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
       '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
+        specifier: ^1.95.5
+        version: 1.95.5
       '@types/bn.js':
-        specifier: ^5.1.0
-        version: 5.1.5
+        specifier: ^5.1.6
+        version: 5.1.6
       '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
+        specifier: ^5.0.1
+        version: 5.0.1
       '@types/chai-as-promised':
-        specifier: ^7.1.4
-        version: 7.1.8
+        specifier: ^8.0.1
+        version: 8.0.1
       '@types/mocha':
-        specifier: ^10.0.6
-        version: 10.0.6
+        specifier: ^10.0.10
+        version: 10.0.10
       '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)(typescript@5.7.2)
       '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+        specifier: ^8.4.0
+        version: 8.4.0(eslint@8.57.0)(typescript@5.7.2)
       eslint:
         specifier: ^8.57.0
         version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
       eslint-plugin-import:
-        specifier: ^2.29.1
-        version: 2.29.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
-      eslint-plugin-require-extensions:
-        specifier: ^0.1.1
-        version: 0.1.3(eslint@8.57.0)
-      mocha:
-        specifier: ^10.4.0
-        version: 10.4.0
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      start-server-and-test:
-        specifier: ^2.0.4
-        version: 2.0.4
-      ts-node:
-        specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
-
-  token/js:
-    dependencies:
-      '@solana/buffer-layout':
-        specifier: ^4.0.0
-        version: 4.0.1
-      '@solana/buffer-layout-utils':
-        specifier: ^0.2.0
-        version: 0.2.0
-      '@solana/spl-token-group':
-        specifier: ^0.0.3
-        version: link:../../token-group/js
-      '@solana/spl-token-metadata':
-        specifier: ^0.1.3
-        version: 0.1.4(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
-      buffer:
-        specifier: ^6.0.3
-        version: 6.0.3
-    devDependencies:
-      '@solana/codecs-strings':
-        specifier: 2.0.0-preview.3
-        version: 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-memo':
-        specifier: 0.2.4
-        version: link:../../memo/js
-      '@solana/web3.js':
-        specifier: ^1.93.0
-        version: 1.93.0
-      '@types/chai':
-        specifier: ^4.3.16
-        version: 4.3.16
-      '@types/chai-as-promised':
-        specifier: ^7.1.4
-        version: 7.1.8
-      '@types/mocha':
-        specifier: ^10.0.6
-        version: 10.0.6
-      '@types/node':
-        specifier: ^20.14.5
-        version: 20.14.5
-      '@types/node-fetch':
-        specifier: ^2.6.11
-        version: 2.6.11
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.13.1
-        version: 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser':
-        specifier: ^7.13.1
-        version: 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      chai:
-        specifier: ^5.1.1
-        version: 5.1.1
-      chai-as-promised:
-        specifier: ^8.0.0
-        version: 8.0.0(chai@5.1.1)
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.0
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.0)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2)
+        specifier: ^2.31.0
+        version: 2.31.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)
       eslint-plugin-require-extensions:
         specifier: ^0.1.1
         version: 0.1.3(eslint@8.57.0)
-      gh-pages:
-        specifier: ^6.1.1
-        version: 6.1.1
       mocha:
-        specifier: ^10.4.0
-        version: 10.4.0
-      prettier:
-        specifier: ^3.3.2
-        version: 3.3.2
-      process:
-        specifier: ^0.11.10
-        version: 0.11.10
-      shx:
-        specifier: ^0.3.4
-        version: 0.3.4
+        specifier: ^11.0.1
+        version: 11.0.1
       start-server-and-test:
-        specifier: ^2.0.4
-        version: 2.0.4
+        specifier: ^2.0.9
+        version: 2.0.9
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
-      typedoc:
-        specifier: ^0.25.13
-        version: 0.25.13(typescript@5.4.5)
+        version: 10.9.2(@types/node@22.10.5)(typescript@5.7.2)
       typescript:
-        specifier: ^5.4.5
-        version: 5.4.5
+        specifier: ^5.7.2
+        version: 5.7.2
 
 packages:
 
@@ -869,47 +321,40 @@ packages:
     resolution: {integrity: sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==}
     engines: {node: '>=6.0.0'}
     dependencies:
-      '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.20
-    dev: true
-
-  /@ava/typescript@5.0.0:
-    resolution: {integrity: sha512-2twsQz2fUd95QK1MtKuEnjkiN47SKHZfi/vWj040EN6Eo2ZW3SNcAwncJqXXoMTYZTWtBRXYp3Fg8z+JkFI9aQ==}
-    engines: {node: ^18.18 || ^20.8 || ^21 || ^22}
-    dependencies:
-      escape-string-regexp: 5.0.0
-      execa: 8.0.1
+      '@jridgewell/gen-mapping': 0.3.5
+      '@jridgewell/trace-mapping': 0.3.25
     dev: true
 
-  /@babel/code-frame@7.24.2:
-    resolution: {integrity: sha512-y5+tLQyV8pg3fsiln67BVLD1P13Eg4lh5RW9mF0zUuvLrv9uIQ4MCL+CRT+FTsBlBjcIan6PGsLcBN0m3ClUyQ==}
+  /@babel/code-frame@7.26.2:
+    resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/highlight': 7.24.5
+      '@babel/helper-validator-identifier': 7.25.9
+      js-tokens: 4.0.0
       picocolors: 1.0.0
     dev: true
 
-  /@babel/compat-data@7.23.2:
-    resolution: {integrity: sha512-0S9TQMmDHlqAZ2ITT95irXKfxN9bncq8ZCoJhun3nHL/lLUxd2NKBJYoNGWH7S0hz6fRQwWlAWn/ILM0C70KZQ==}
+  /@babel/compat-data@7.26.2:
+    resolution: {integrity: sha512-Z0WgzSEa+aUcdiJuCIqgujCshpMWgUpgOxXotrYPSA53hA3qopNaqcJpyr0hVb1FeWdnqFA35/fUtXgBK8srQg==}
     engines: {node: '>=6.9.0'}
     dev: true
 
-  /@babel/core@7.23.2:
-    resolution: {integrity: sha512-n7s51eWdaWZ3vGT2tD4T7J6eJs3QoBXydv7vkUM06Bf1cbVD2Kc2UrkzhiQwobfV7NwOnQXYL7UBJ5VPU+RGoQ==}
+  /@babel/core@7.26.0:
+    resolution: {integrity: sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@ampproject/remapping': 2.2.1
-      '@babel/code-frame': 7.24.2
-      '@babel/generator': 7.23.0
-      '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
-      '@babel/helpers': 7.23.2
-      '@babel/parser': 7.23.0
-      '@babel/template': 7.22.15
-      '@babel/traverse': 7.23.2
-      '@babel/types': 7.23.0
+      '@babel/code-frame': 7.26.2
+      '@babel/generator': 7.26.2
+      '@babel/helper-compilation-targets': 7.25.9
+      '@babel/helper-module-transforms': 7.26.0(@babel/core@7.26.0)
+      '@babel/helpers': 7.26.0
+      '@babel/parser': 7.26.2
+      '@babel/template': 7.25.9
+      '@babel/traverse': 7.25.9
+      '@babel/types': 7.26.0
       convert-source-map: 2.0.0
-      debug: 4.3.5
+      debug: 4.4.0
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -917,66 +362,50 @@ packages:
       - supports-color
     dev: true
 
-  /@babel/generator@7.23.0:
-    resolution: {integrity: sha512-lN85QRR+5IbYrMWM6Y4pE/noaQtg4pNiqeNGX60eqOfo6gtEj6uw/JagelB8vVztSd7R6M5n1+PQkDbHbBRU4g==}
+  /@babel/generator@7.26.2:
+    resolution: {integrity: sha512-zevQbhbau95nkoxSq3f/DC/SC+EEOUZd3DYqfSkMhY2/wfSeaHV1Ew4vk8e+x8lja31IbyuUa2uQ3JONqKbysw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.23.0
-      '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.20
-      jsesc: 2.5.2
+      '@babel/parser': 7.26.2
+      '@babel/types': 7.26.0
+      '@jridgewell/gen-mapping': 0.3.5
+      '@jridgewell/trace-mapping': 0.3.25
+      jsesc: 3.0.2
     dev: true
 
-  /@babel/helper-compilation-targets@7.22.15:
-    resolution: {integrity: sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==}
+  /@babel/helper-compilation-targets@7.25.9:
+    resolution: {integrity: sha512-j9Db8Suy6yV/VHa4qzrj9yZfZxhLWQdVnRlXxmKLYlhWUVB1sB2G5sxuWYXk/whHD9iW76PmNzxZ4UCnTQTVEQ==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/compat-data': 7.23.2
-      '@babel/helper-validator-option': 7.22.15
-      browserslist: 4.22.1
+      '@babel/compat-data': 7.26.2
+      '@babel/helper-validator-option': 7.25.9
+      browserslist: 4.24.2
       lru-cache: 5.1.1
       semver: 6.3.1
     dev: true
 
-  /@babel/helper-environment-visitor@7.22.20:
-    resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==}
-    engines: {node: '>=6.9.0'}
-    dev: true
-
-  /@babel/helper-function-name@7.23.0:
-    resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==}
+  /@babel/helper-module-imports@7.25.9:
+    resolution: {integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/template': 7.22.15
-      '@babel/types': 7.23.0
-    dev: true
-
-  /@babel/helper-hoist-variables@7.22.5:
-    resolution: {integrity: sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/types': 7.23.0
-    dev: true
-
-  /@babel/helper-module-imports@7.22.15:
-    resolution: {integrity: sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/types': 7.23.0
+      '@babel/traverse': 7.25.9
+      '@babel/types': 7.26.0
+    transitivePeerDependencies:
+      - supports-color
     dev: true
 
-  /@babel/helper-module-transforms@7.23.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-WhDWw1tdrlT0gMgUJSlX0IQvoO1eN279zrAUbVB+KpV2c3Tylz8+GnKOLllCS6Z/iZQEyVYxhZVUdPTqs2YYPw==}
+  /@babel/helper-module-transforms@7.26.0(@babel/core@7.26.0):
+    resolution: {integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
-      '@babel/core': 7.23.2
-      '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-module-imports': 7.22.15
-      '@babel/helper-simple-access': 7.22.5
-      '@babel/helper-split-export-declaration': 7.22.6
-      '@babel/helper-validator-identifier': 7.24.5
+      '@babel/core': 7.26.0
+      '@babel/helper-module-imports': 7.25.9
+      '@babel/helper-validator-identifier': 7.25.9
+      '@babel/traverse': 7.25.9
+    transitivePeerDependencies:
+      - supports-color
     dev: true
 
   /@babel/helper-plugin-utils@7.22.5:
@@ -984,463 +413,257 @@ packages:
     engines: {node: '>=6.9.0'}
     dev: true
 
-  /@babel/helper-simple-access@7.22.5:
-    resolution: {integrity: sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==}
+  /@babel/helper-string-parser@7.25.9:
+    resolution: {integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==}
     engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/types': 7.23.0
     dev: true
 
-  /@babel/helper-split-export-declaration@7.22.6:
-    resolution: {integrity: sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==}
+  /@babel/helper-validator-identifier@7.25.9:
+    resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==}
     engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/types': 7.23.0
     dev: true
 
-  /@babel/helper-string-parser@7.22.5:
-    resolution: {integrity: sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==}
+  /@babel/helper-validator-option@7.25.9:
+    resolution: {integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==}
     engines: {node: '>=6.9.0'}
     dev: true
 
-  /@babel/helper-validator-identifier@7.24.5:
-    resolution: {integrity: sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==}
-    engines: {node: '>=6.9.0'}
-    dev: true
-
-  /@babel/helper-validator-option@7.22.15:
-    resolution: {integrity: sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==}
-    engines: {node: '>=6.9.0'}
-    dev: true
-
-  /@babel/helpers@7.23.2:
-    resolution: {integrity: sha512-lzchcp8SjTSVe/fPmLwtWVBFC7+Tbn8LGHDVfDp9JGxpAY5opSaEFgt8UQvrnECWOTdji2mOWMz1rOhkHscmGQ==}
+  /@babel/helpers@7.26.0:
+    resolution: {integrity: sha512-tbhNuIxNcVb21pInl3ZSjksLCvgdZy9KwJ8brv993QtIVKJBBkYXz4q4ZbAv31GdnC+R90np23L5FbEBlthAEw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/template': 7.22.15
-      '@babel/traverse': 7.23.2
-      '@babel/types': 7.23.0
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.0
     dev: true
 
-  /@babel/highlight@7.24.5:
-    resolution: {integrity: sha512-8lLmua6AVh/8SLJRRVD6V8p73Hir9w5mJrhE+IPpILG31KKlI9iz5zmBYKcWPS59qSfgP9RaSBQSHHE81WKuEw==}
-    engines: {node: '>=6.9.0'}
+  /@babel/parser@7.23.0:
+    resolution: {integrity: sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
     dependencies:
-      '@babel/helper-validator-identifier': 7.24.5
-      chalk: 2.4.2
-      js-tokens: 4.0.0
-      picocolors: 1.0.0
+      '@babel/types': 7.26.0
     dev: true
 
-  /@babel/parser@7.23.0:
-    resolution: {integrity: sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==}
+  /@babel/parser@7.26.2:
+    resolution: {integrity: sha512-DWMCZH9WA4Maitz2q21SRKHo9QXZxkDsbNZoVD62gusNtNBBqDg9i7uOhASfTfIGNzW+O+r7+jAlM8dwphcJKQ==}
     engines: {node: '>=6.0.0'}
     hasBin: true
     dependencies:
-      '@babel/types': 7.23.0
+      '@babel/types': 7.26.0
     dev: true
 
-  /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.23.2):
+  /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.26.0):
     resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.23.2):
+  /@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.26.0):
     resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.23.2):
+  /@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.26.0):
     resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-jsx@7.22.5(@babel/core@7.23.2):
+  /@babel/plugin-syntax-jsx@7.22.5(@babel/core@7.26.0):
     resolution: {integrity: sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.23.2):
+  /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.26.0):
     resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.23.2):
+  /@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.26.0):
     resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.23.2):
+  /@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.23.2):
+  /@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.26.0):
     resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/plugin-syntax-typescript@7.22.5(@babel/core@7.23.2):
+  /@babel/plugin-syntax-typescript@7.22.5(@babel/core@7.26.0):
     resolution: {integrity: sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/helper-plugin-utils': 7.22.5
     dev: true
 
-  /@babel/runtime@7.24.7:
-    resolution: {integrity: sha512-UwgBRMjJP+xv857DCngvqXI3Iq6J4v0wXmwc6sapg+zyhbwmQX67LUEFrkK5tbyJ30jGuG3ZvWpBiB9LCy1kWw==}
+  /@babel/runtime@7.25.0:
+    resolution: {integrity: sha512-7dRy4DwXwtzBrPbZflqxnvfxLF8kdZXPkhymtDeFoFqE6ldzjQFgYTtYIFARcLEYDrqfBfYcZt1WqFxRoyC9Rw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       regenerator-runtime: 0.14.0
 
-  /@babel/template@7.22.15:
-    resolution: {integrity: sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==}
+  /@babel/template@7.25.9:
+    resolution: {integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/code-frame': 7.24.2
-      '@babel/parser': 7.23.0
-      '@babel/types': 7.23.0
+      '@babel/code-frame': 7.26.2
+      '@babel/parser': 7.26.2
+      '@babel/types': 7.26.0
     dev: true
 
-  /@babel/traverse@7.23.2:
-    resolution: {integrity: sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==}
+  /@babel/traverse@7.25.9:
+    resolution: {integrity: sha512-ZCuvfwOwlz/bawvAuvcj8rrithP2/N55Tzz342AkTvq4qaWbGfmCk/tKhNaV2cthijKrPAA8SRJV5WWe7IBMJw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/code-frame': 7.24.2
-      '@babel/generator': 7.23.0
-      '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-function-name': 7.23.0
-      '@babel/helper-hoist-variables': 7.22.5
-      '@babel/helper-split-export-declaration': 7.22.6
-      '@babel/parser': 7.23.0
-      '@babel/types': 7.23.0
-      debug: 4.3.5
+      '@babel/code-frame': 7.26.2
+      '@babel/generator': 7.26.2
+      '@babel/parser': 7.26.2
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.0
+      debug: 4.4.0
       globals: 11.12.0
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@babel/types@7.23.0:
-    resolution: {integrity: sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==}
+  /@babel/types@7.26.0:
+    resolution: {integrity: sha512-Z/yiTPj+lDVnF7lWeKCIJzaIkI0vYO87dMpZ4bg4TDrFe4XXLFWL1TbXU27gBP3QccxV9mZICCrnjnYlJjXHOA==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/helper-string-parser': 7.22.5
-      '@babel/helper-validator-identifier': 7.24.5
-      to-fast-properties: 2.0.0
+      '@babel/helper-string-parser': 7.25.9
+      '@babel/helper-validator-identifier': 7.25.9
     dev: true
 
   /@bcoe/v8-coverage@0.2.3:
     resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==}
     dev: true
 
-  /@coral-xyz/borsh@0.26.0(@solana/web3.js@1.93.0):
-    resolution: {integrity: sha512-uCZ0xus0CszQPHYfWAqKS5swS1UxvePu83oOF+TWpUkedsNlg6p2p4azxZNSSqwXb9uXMFgxhuMBX9r3Xoi0vQ==}
-    engines: {node: '>=10'}
-    peerDependencies:
-      '@solana/web3.js': ^1.68.0
+  /@coral-xyz/anchor@0.29.0:
+    resolution: {integrity: sha512-eny6QNG0WOwqV0zQ7cs/b1tIuzZGmP7U7EcH+ogt4Gdbl8HDmIYVMh/9aTmYZPaFWjtUaI8qSn73uYEXWfATdA==}
+    engines: {node: '>=11'}
     dependencies:
-      '@solana/web3.js': 1.93.0
+      '@coral-xyz/borsh': 0.29.0(@solana/web3.js@1.95.4)
+      '@noble/hashes': 1.4.0
+      '@solana/web3.js': 1.95.4
       bn.js: 5.2.1
+      bs58: 4.0.1
       buffer-layout: 1.2.2
+      camelcase: 6.3.0
+      cross-fetch: 3.1.8
+      crypto-hash: 1.3.0
+      eventemitter3: 4.0.7
+      pako: 2.1.0
+      snake-case: 3.0.4
+      superstruct: 0.15.5
+      toml: 3.0.0
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - utf-8-validate
     dev: true
 
-  /@cspotcode/source-map-support@0.8.1:
-    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
-    engines: {node: '>=12'}
-    dependencies:
-      '@jridgewell/trace-mapping': 0.3.9
-    dev: true
-
-  /@esbuild/aix-ppc64@0.21.5:
-    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
-    engines: {node: '>=12'}
-    cpu: [ppc64]
-    os: [aix]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/android-arm64@0.21.5:
-    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/android-arm@0.21.5:
-    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
-    engines: {node: '>=12'}
-    cpu: [arm]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/android-x64@0.21.5:
-    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/darwin-arm64@0.21.5:
-    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/darwin-x64@0.21.5:
-    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/freebsd-arm64@0.21.5:
-    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [freebsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/freebsd-x64@0.21.5:
-    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [freebsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-arm64@0.21.5:
-    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-arm@0.21.5:
-    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
-    engines: {node: '>=12'}
-    cpu: [arm]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-ia32@0.21.5:
-    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
-    engines: {node: '>=12'}
-    cpu: [ia32]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-loong64@0.21.5:
-    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
-    engines: {node: '>=12'}
-    cpu: [loong64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-mips64el@0.21.5:
-    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
-    engines: {node: '>=12'}
-    cpu: [mips64el]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-ppc64@0.21.5:
-    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
-    engines: {node: '>=12'}
-    cpu: [ppc64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-riscv64@0.21.5:
-    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
-    engines: {node: '>=12'}
-    cpu: [riscv64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-s390x@0.21.5:
-    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
-    engines: {node: '>=12'}
-    cpu: [s390x]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-x64@0.21.5:
-    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/netbsd-x64@0.21.5:
-    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [netbsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/openbsd-x64@0.21.5:
-    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [openbsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/sunos-x64@0.21.5:
-    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [sunos]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/win32-arm64@0.21.5:
-    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/win32-ia32@0.21.5:
-    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
-    engines: {node: '>=12'}
-    cpu: [ia32]
-    os: [win32]
-    requiresBuild: true
+  /@coral-xyz/borsh@0.29.0(@solana/web3.js@1.95.4):
+    resolution: {integrity: sha512-s7VFVa3a0oqpkuRloWVPdCK7hMbAMY270geZOGfCnaqexrP5dTIpbEHL33req6IYPPJ0hYa71cdvJ1h6V55/oQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@solana/web3.js': ^1.68.0
+    dependencies:
+      '@solana/web3.js': 1.95.4
+      bn.js: 5.2.1
+      buffer-layout: 1.2.2
     dev: true
-    optional: true
 
-  /@esbuild/win32-x64@0.21.5:
-    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+  /@cspotcode/source-map-support@0.8.1:
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
-    cpu: [x64]
-    os: [win32]
-    requiresBuild: true
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.9
     dev: true
-    optional: true
 
   /@eslint-community/eslint-utils@4.4.0(eslint@8.57.0):
     resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
@@ -1452,17 +675,48 @@ packages:
       eslint-visitor-keys: 3.4.3
     dev: true
 
+  /@eslint-community/eslint-utils@4.4.0(eslint@9.13.0):
+    resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+    dependencies:
+      eslint: 9.13.0
+      eslint-visitor-keys: 3.4.3
+    dev: true
+
   /@eslint-community/regexpp@4.10.0:
     resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
     dev: true
 
+  /@eslint-community/regexpp@4.12.1:
+    resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+    dev: true
+
+  /@eslint/config-array@0.18.0:
+    resolution: {integrity: sha512-fTxvnS1sRMu3+JjXwJG0j/i4RT9u4qJ+lqS/yCGap4lH4zZGzQ7tu+xZqQmcMZq5OBZDL4QRxQzRjkWcGt8IVw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      '@eslint/object-schema': 2.1.4
+      debug: 4.4.0
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@eslint/core@0.7.0:
+    resolution: {integrity: sha512-xp5Jirz5DyPYlPiKat8jaq0EmYvDXKKpzTbxXMpT9eqlRJkRKIz9AGMdlvYjih+im+QlhWrpvVjl8IPC/lHlUw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
   /@eslint/eslintrc@2.1.4:
     resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       ajv: 6.12.6
-      debug: 4.3.5
+      debug: 4.4.0
       espree: 9.6.1
       globals: 13.24.0
       ignore: 5.3.1
@@ -1474,11 +728,53 @@ packages:
       - supports-color
     dev: true
 
+  /@eslint/eslintrc@3.1.0:
+    resolution: {integrity: sha512-4Bfj15dVJdoy3RfZmmo86RK1Fwzn6SstsvK9JS+BaVKqC6QQQQyXekNaC+g+LKNgkQ+2VhGAzm6hO40AhMR3zQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      ajv: 6.12.6
+      debug: 4.4.0
+      espree: 10.3.0
+      globals: 14.0.0
+      ignore: 5.3.1
+      import-fresh: 3.3.0
+      js-yaml: 4.1.0
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@eslint/js@8.57.0:
     resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
+  /@eslint/js@9.13.0:
+    resolution: {integrity: sha512-IFLyoY4d72Z5y/6o/BazFBezupzI/taV8sGumxTAVw3lXG9A6md1Dc34T9s1FoD/an9pJH8RHbAxsaEbBed9lA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
+  /@eslint/object-schema@2.1.4:
+    resolution: {integrity: sha512-BsWiH1yFGjXXS2yvrf5LyuoSIIbPrGUWob917o+BTKuZ7qJdxX8aJLRxs1fS9n6r7vESrq1OUqb68dANcFXuQQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
+  /@eslint/plugin-kit@0.2.2:
+    resolution: {integrity: sha512-CXtq5nR4Su+2I47WPOlWud98Y5Lv8Kyxp2ukhgFx/eW6Blm18VXJO5WuQylPugRo8nbluoi6GvvxBLqHcvqUUw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      levn: 0.4.1
+    dev: true
+
+  /@gerrit0/mini-shiki@1.24.1:
+    resolution: {integrity: sha512-PNP/Gjv3VqU7z7DjRgO3F9Ok5frTKqtpV+LJW1RzMcr2zpRk0ulhEWnbcNGXzPC7BZyWMIHrkfQX2GZRfxrn6Q==}
+    dependencies:
+      '@shikijs/engine-oniguruma': 1.24.0
+      '@shikijs/types': 1.24.0
+      '@shikijs/vscode-textmate': 9.3.0
+    dev: true
+
   /@hapi/hoek@9.3.0:
     resolution: {integrity: sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==}
     dev: true
@@ -1489,12 +785,25 @@ packages:
       '@hapi/hoek': 9.3.0
     dev: true
 
+  /@humanfs/core@0.19.1:
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
+    dev: true
+
+  /@humanfs/node@0.16.6:
+    resolution: {integrity: sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==}
+    engines: {node: '>=18.18.0'}
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.3.1
+    dev: true
+
   /@humanwhocodes/config-array@0.11.14:
     resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==}
     engines: {node: '>=10.10.0'}
     dependencies:
       '@humanwhocodes/object-schema': 2.0.2
-      debug: 4.3.5
+      debug: 4.4.0
       minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
@@ -1509,6 +818,11 @@ packages:
     resolution: {integrity: sha512-6EwiSjwWYP7pTckG6I5eyFANjPhmPjUX9JRLUSfNPC7FX7zK9gyZAfUEaECL6ALTpGX5AjnBq3C9XmVWPitNpw==}
     dev: true
 
+  /@humanwhocodes/retry@0.3.1:
+    resolution: {integrity: sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==}
+    engines: {node: '>=18.18'}
+    dev: true
+
   /@isaacs/cliui@8.0.2:
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
@@ -1542,13 +856,25 @@ packages:
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       jest-message-util: 29.7.0
       jest-util: 29.7.0
       slash: 3.0.0
     dev: true
 
+  /@jest/console@30.0.0-alpha.6:
+    resolution: {integrity: sha512-08BeAnuabmauj5B+Xa4GNPAotQUGm3PLKSE3rnpnmxniZzR4tXhx8+AA2+HGTri4bbVRY/r3Jl0vJnkhvHTkeQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      jest-message-util: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      slash: 3.0.0
+    dev: true
+
   /@jest/core@29.7.0(ts-node@10.9.2):
     resolution: {integrity: sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1563,14 +889,14 @@ packages:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       ci-info: 3.9.0
       exit: 0.1.2
       graceful-fs: 4.2.11
       jest-changed-files: 29.7.0
-      jest-config: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      jest-config: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       jest-haste-map: 29.7.0
       jest-message-util: 29.7.0
       jest-regex-util: 29.6.3
@@ -1592,16 +918,71 @@ packages:
       - ts-node
     dev: true
 
+  /@jest/core@30.0.0-alpha.6:
+    resolution: {integrity: sha512-Qsvu9/I0hUOpeelp3jlTmg6cg3C+w18v4hxWVGchCRJAChvuxmsomB1Cm+DKB6NiMy2EvUvpwdT8X31lERtemw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/console': 30.0.0-alpha.6
+      '@jest/pattern': 30.0.0-alpha.6
+      '@jest/reporters': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/transform': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      ansi-escapes: 4.3.2
+      chalk: 4.1.2
+      ci-info: 4.0.0
+      exit: 0.1.2
+      graceful-fs: 4.2.11
+      jest-changed-files: 30.0.0-alpha.6
+      jest-config: 30.0.0-alpha.6(@types/node@22.10.5)
+      jest-haste-map: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-regex-util: 30.0.0-alpha.6
+      jest-resolve: 30.0.0-alpha.6
+      jest-resolve-dependencies: 30.0.0-alpha.6
+      jest-runner: 30.0.0-alpha.6
+      jest-runtime: 30.0.0-alpha.6
+      jest-snapshot: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      jest-validate: 30.0.0-alpha.6
+      jest-watcher: 30.0.0-alpha.6
+      micromatch: 4.0.8
+      pretty-format: 30.0.0-alpha.6
+      slash: 3.0.0
+      strip-ansi: 6.0.1
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    dev: true
+
   /@jest/environment@29.7.0:
     resolution: {integrity: sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       jest-mock: 29.7.0
     dev: true
 
+  /@jest/environment@30.0.0-alpha.6:
+    resolution: {integrity: sha512-pjNYNkzq761hh8D2grrG77L6nhe2VBCFFM+G1hyqhaJ2MAzhp2Gh+G94uF3px7luSzLh8GYvGJQGYy197EUOGQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/fake-timers': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      jest-mock: 30.0.0-alpha.6
+    dev: true
+
   /@jest/expect-utils@29.7.0:
     resolution: {integrity: sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1609,6 +990,13 @@ packages:
       jest-get-type: 29.6.3
     dev: true
 
+  /@jest/expect-utils@30.0.0-alpha.6:
+    resolution: {integrity: sha512-QMySMhaCUl0ZQd7Tx5X3fVWY5jtQxZNrTll0OyavdQ70ZTLgk0kU9K+XovcMWO26MK9R5EX7bBgD/j7w9hUM4w==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      jest-get-type: 30.0.0-alpha.6
+    dev: true
+
   /@jest/expect@29.7.0:
     resolution: {integrity: sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1619,18 +1007,40 @@ packages:
       - supports-color
     dev: true
 
+  /@jest/expect@30.0.0-alpha.6:
+    resolution: {integrity: sha512-3O74pygTwUBzUjO958IgNwmp0WrjASbiWdMEfUMePVqtiGoyS4Nxj9hsx4uKsNVivNJSZiiayYoP6dLhWerJXQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      expect: 30.0.0-alpha.6
+      jest-snapshot: 30.0.0-alpha.6
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@jest/fake-timers@29.7.0:
     resolution: {integrity: sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/types': 29.6.3
       '@sinonjs/fake-timers': 10.3.0
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       jest-message-util: 29.7.0
       jest-mock: 29.7.0
       jest-util: 29.7.0
     dev: true
 
+  /@jest/fake-timers@30.0.0-alpha.6:
+    resolution: {integrity: sha512-deka0RmhJgEKPJM6cXPd4TJQ6fLczErdMN7Oxzr16UTDFHxtFd79tduJ8uP92dQyO4zy63N/dlFK6d+FHyWUDw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      '@sinonjs/fake-timers': 11.3.1
+      '@types/node': 22.10.5
+      jest-message-util: 30.0.0-alpha.6
+      jest-mock: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+    dev: true
+
   /@jest/globals@29.7.0:
     resolution: {integrity: sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1643,6 +1053,26 @@ packages:
       - supports-color
     dev: true
 
+  /@jest/globals@30.0.0-alpha.6:
+    resolution: {integrity: sha512-+uJMoPUos9RH6+52iNgKJBbx1Hd2QsCZjExi5XpVvTjJ/gE4eJ1X7irUMt+14sH0QkeZ3GnjeTJFopyjOCsu+Q==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/environment': 30.0.0-alpha.6
+      '@jest/expect': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      jest-mock: 30.0.0-alpha.6
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@jest/pattern@30.0.0-alpha.6:
+    resolution: {integrity: sha512-eoV3sjS1M5k3YdrFWezqdndfgepwB86gwyXC0BzV2saZdJ42ySUoEDBGKuwta8A6Zh3w8tVHNFxz1BqiFraHCQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@types/node': 22.10.5
+      jest-regex-util: 30.0.0-alpha.6
+    dev: true
+
   /@jest/reporters@29.7.0:
     resolution: {integrity: sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1658,7 +1088,7 @@ packages:
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
       '@jridgewell/trace-mapping': 0.3.20
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       collect-v8-coverage: 1.0.2
       exit: 0.1.2
@@ -1680,6 +1110,43 @@ packages:
       - supports-color
     dev: true
 
+  /@jest/reporters@30.0.0-alpha.6:
+    resolution: {integrity: sha512-jzW0t2OtEzBYwlG4EMJKG4q5RPaVvLPDm/nBS08hd+XPoLJJ9b5thyo/MoThIqJfdi0lHqFlDQUmlL205CMoSw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@bcoe/v8-coverage': 0.2.3
+      '@jest/console': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/transform': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@jridgewell/trace-mapping': 0.3.25
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      collect-v8-coverage: 1.0.2
+      exit: 0.1.2
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      istanbul-lib-coverage: 3.2.1
+      istanbul-lib-instrument: 6.0.3
+      istanbul-lib-report: 3.0.1
+      istanbul-lib-source-maps: 5.0.6
+      istanbul-reports: 3.1.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      jest-worker: 30.0.0-alpha.6
+      slash: 3.0.0
+      string-length: 4.0.2
+      strip-ansi: 6.0.1
+      v8-to-istanbul: 9.1.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@jest/schemas@29.6.3:
     resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1687,11 +1154,37 @@ packages:
       '@sinclair/typebox': 0.27.8
     dev: true
 
+  /@jest/schemas@30.0.0-alpha.6:
+    resolution: {integrity: sha512-Ukr3kR/VsBq8+JHU92xArhSJeFQHVHs5T1laPO00GrrNzv3DvoHn3/EVVagGn9CHbLeAyJHXFRHYxq3+520kiA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@sinclair/typebox': 0.33.17
+    dev: true
+
+  /@jest/snapshot-utils@30.0.0-alpha.6:
+    resolution: {integrity: sha512-iDtIFCyRT8ZyLmz6kYbS8GR/MBXKA6uZPBfdTcnd2y0T987DV3GVlvwkAC+iFTc1w3HgwQe8LTf+y3i+O2ISCw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      natural-compare: 1.4.0
+    dev: true
+
   /@jest/source-map@29.6.3:
     resolution: {integrity: sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@jridgewell/trace-mapping': 0.3.20
+      '@jridgewell/trace-mapping': 0.3.25
+      callsites: 3.1.0
+      graceful-fs: 4.2.11
+    dev: true
+
+  /@jest/source-map@30.0.0-alpha.6:
+    resolution: {integrity: sha512-7rSrxehVyzqw5O+F2ds7wLAm9f6QxqYsJU42LNyUpaFlJqtWz3PeQ2Wu3DVoPzGu0C66EhDHKYmeN0mXnRDZmQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.25
       callsites: 3.1.0
       graceful-fs: 4.2.11
     dev: true
@@ -1706,6 +1199,16 @@ packages:
       collect-v8-coverage: 1.0.2
     dev: true
 
+  /@jest/test-result@30.0.0-alpha.6:
+    resolution: {integrity: sha512-Jlg8lCm7VQ6YvQ0eZx2nQEtej/ng+ulV8cXH7Nj5i33hNZq8EZvWM4gQDWDzRe1X7cVE3Bd42On5f6s2rqqIjw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/console': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/istanbul-lib-coverage': 2.0.6
+      collect-v8-coverage: 1.0.2
+    dev: true
+
   /@jest/test-sequencer@29.7.0:
     resolution: {integrity: sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1716,11 +1219,21 @@ packages:
       slash: 3.0.0
     dev: true
 
+  /@jest/test-sequencer@30.0.0-alpha.6:
+    resolution: {integrity: sha512-5M89jbSQWkBjGlFrRk2wXjRJVxR+uN553sFN0q2TglH0/a4OMSVxRBcCmnIqqDMDizGAlYTxW6BaXxHGHpvrRQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/test-result': 30.0.0-alpha.6
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.0.0-alpha.6
+      slash: 3.0.0
+    dev: true
+
   /@jest/transform@29.7.0:
     resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@jest/types': 29.6.3
       '@jridgewell/trace-mapping': 0.3.20
       babel-plugin-istanbul: 6.1.1
@@ -1731,7 +1244,7 @@ packages:
       jest-haste-map: 29.7.0
       jest-regex-util: 29.6.3
       jest-util: 29.7.0
-      micromatch: 4.0.5
+      micromatch: 4.0.8
       pirates: 4.0.6
       slash: 3.0.0
       write-file-atomic: 4.0.2
@@ -1739,6 +1252,29 @@ packages:
       - supports-color
     dev: true
 
+  /@jest/transform@30.0.0-alpha.6:
+    resolution: {integrity: sha512-4L8BZm38BJASswsqruc4c3F0AExYLvp0xq8067e7fIyg4hfwa4zUA+N2idf+eTTjDWevVVdIBfELzJ8b7nvO4Q==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@babel/core': 7.26.0
+      '@jest/types': 30.0.0-alpha.6
+      '@jridgewell/trace-mapping': 0.3.25
+      babel-plugin-istanbul: 7.0.0
+      chalk: 4.1.2
+      convert-source-map: 2.0.0
+      fast-json-stable-stringify: 2.1.0
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.0.0-alpha.6
+      jest-regex-util: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      micromatch: 4.0.8
+      pirates: 4.0.6
+      slash: 3.0.0
+      write-file-atomic: 5.0.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@jest/types@29.6.3:
     resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -1746,18 +1282,31 @@ packages:
       '@jest/schemas': 29.6.3
       '@types/istanbul-lib-coverage': 2.0.6
       '@types/istanbul-reports': 3.0.4
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
+      '@types/yargs': 17.0.31
+      chalk: 4.1.2
+    dev: true
+
+  /@jest/types@30.0.0-alpha.6:
+    resolution: {integrity: sha512-qUjAm8uvIR7oExn/Fp7/bvn58HSZng5itQDM9x0vaxXWxxGH/8MDmqX/h7OUBz9ka+KfYRaTxe4Y6wiM8+nphw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/pattern': 30.0.0-alpha.6
+      '@jest/schemas': 30.0.0-alpha.6
+      '@types/istanbul-lib-coverage': 2.0.6
+      '@types/istanbul-reports': 3.0.4
+      '@types/node': 22.10.5
       '@types/yargs': 17.0.31
       chalk: 4.1.2
     dev: true
 
-  /@jridgewell/gen-mapping@0.3.3:
-    resolution: {integrity: sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==}
+  /@jridgewell/gen-mapping@0.3.5:
+    resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==}
     engines: {node: '>=6.0.0'}
     dependencies:
-      '@jridgewell/set-array': 1.1.2
+      '@jridgewell/set-array': 1.2.1
       '@jridgewell/sourcemap-codec': 1.4.15
-      '@jridgewell/trace-mapping': 0.3.20
+      '@jridgewell/trace-mapping': 0.3.25
     dev: true
 
   /@jridgewell/resolve-uri@3.1.1:
@@ -1765,18 +1314,11 @@ packages:
     engines: {node: '>=6.0.0'}
     dev: true
 
-  /@jridgewell/set-array@1.1.2:
-    resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==}
+  /@jridgewell/set-array@1.2.1:
+    resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
     engines: {node: '>=6.0.0'}
     dev: true
 
-  /@jridgewell/source-map@0.3.5:
-    resolution: {integrity: sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==}
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.20
-    dev: true
-
   /@jridgewell/sourcemap-codec@1.4.15:
     resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==}
     dev: true
@@ -1788,38 +1330,27 @@ packages:
       '@jridgewell/sourcemap-codec': 1.4.15
     dev: true
 
-  /@jridgewell/trace-mapping@0.3.9:
-    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
+  /@jridgewell/trace-mapping@0.3.25:
+    resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
     dependencies:
       '@jridgewell/resolve-uri': 3.1.1
       '@jridgewell/sourcemap-codec': 1.4.15
     dev: true
 
-  /@mapbox/node-pre-gyp@1.0.11:
-    resolution: {integrity: sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==}
-    hasBin: true
+  /@jridgewell/trace-mapping@0.3.9:
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
     dependencies:
-      detect-libc: 2.0.2
-      https-proxy-agent: 5.0.1
-      make-dir: 3.1.0
-      node-fetch: 2.7.0
-      nopt: 5.0.0
-      npmlog: 5.0.1
-      rimraf: 3.0.2
-      semver: 7.6.0
-      tar: 6.2.0
-    transitivePeerDependencies:
-      - encoding
-      - supports-color
+      '@jridgewell/resolve-uri': 3.1.1
+      '@jridgewell/sourcemap-codec': 1.4.15
     dev: true
 
   /@metaplex-foundation/beet-solana@0.3.1:
     resolution: {integrity: sha512-tgyEl6dvtLln8XX81JyBvWjIiEcjTkUwZbrM5dIobTmoqMuGewSyk9CClno8qsMsFdB5T3jC91Rjeqmu/6xk2g==}
     dependencies:
       '@metaplex-foundation/beet': 0.7.2
-      '@solana/web3.js': 1.93.0
+      '@solana/web3.js': 1.95.5
       bs58: 5.0.0
-      debug: 4.3.5
+      debug: 4.3.7(supports-color@8.1.1)
     transitivePeerDependencies:
       - bufferutil
       - encoding
@@ -1831,9 +1362,9 @@ packages:
     resolution: {integrity: sha512-/6o32FNUtwK8tjhotrvU/vorP7umBuRFvBZrC6XCk51aKidBHe5LPVPA5AjGPbV3oftMfRuXPNd9yAGeEqeCDQ==}
     dependencies:
       '@metaplex-foundation/beet': 0.7.2
-      '@solana/web3.js': 1.93.0
+      '@solana/web3.js': 1.95.4
       bs58: 5.0.0
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.7(supports-color@8.1.1)
     transitivePeerDependencies:
       - bufferutil
       - encoding
@@ -1847,15 +1378,15 @@ packages:
       ansicolors: 0.3.2
       assert: 2.1.0
       bn.js: 5.2.1
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.7(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   /@metaplex-foundation/rustbin@0.3.5:
     resolution: {integrity: sha512-m0wkRBEQB/8krwMwKBvFugufZtYwMXiGHud2cTDAv+aGXK4M90y0Hx67/wpu+AqqoQfdV8VM9YezUOHKD+Z5kA==}
     dependencies:
-      debug: 4.3.4(supports-color@8.1.1)
-      semver: 7.5.4
+      debug: 4.3.7(supports-color@8.1.1)
+      semver: 7.6.3
       text-table: 0.2.0
       toml: 3.0.0
     transitivePeerDependencies:
@@ -1867,61 +1398,25 @@ packages:
     hasBin: true
     dependencies:
       '@metaplex-foundation/beet': 0.7.2
-      '@metaplex-foundation/beet-solana': 0.3.1
-      '@metaplex-foundation/rustbin': 0.3.5
-      '@solana/web3.js': 1.93.0
-      ansi-colors: 4.1.3
-      camelcase: 6.3.0
-      debug: 4.3.4(supports-color@8.1.1)
-      js-sha256: 0.9.0
-      prettier: 2.8.8
-      snake-case: 3.0.4
-      spok: 1.5.5
-    transitivePeerDependencies:
-      - bufferutil
-      - encoding
-      - supports-color
-      - utf-8-validate
-    dev: true
-
-  /@metaplex-foundation/umi-options@0.8.9:
-    resolution: {integrity: sha512-jSQ61sZMPSAk/TXn8v8fPqtz3x8d0/blVZXLLbpVbo2/T5XobiI6/MfmlUosAjAUaQl6bHRF8aIIqZEFkJiy4A==}
-    dev: false
-
-  /@metaplex-foundation/umi-public-keys@0.8.9:
-    resolution: {integrity: sha512-CxMzN7dgVGOq9OcNCJe2casKUpJ3RmTVoOvDFyeoTQuK+vkZ1YSSahbqC1iGuHEtKTLSjtWjKvUU6O7zWFTw3Q==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers-encodings': 0.8.9
-    dev: false
-
-  /@metaplex-foundation/umi-serializers-core@0.8.9:
-    resolution: {integrity: sha512-WT82tkiYJ0Qmscp7uTj1Hz6aWQPETwaKLAENAUN5DeWghkuBKtuxyBKVvEOuoXerJSdhiAk0e8DWA4cxcTTQ/w==}
-    dev: false
-
-  /@metaplex-foundation/umi-serializers-encodings@0.8.9:
-    resolution: {integrity: sha512-N3VWLDTJ0bzzMKcJDL08U3FaqRmwlN79FyE4BHj6bbAaJ9LEHjDQ9RJijZyWqTm0jE7I750fU7Ow5EZL38Xi6Q==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers-core': 0.8.9
-    dev: false
-
-  /@metaplex-foundation/umi-serializers-numbers@0.8.9:
-    resolution: {integrity: sha512-NtBf1fnVNQJHFQjLFzRu2i9GGnigb9hOm/Gfrk628d0q0tRJB7BOM3bs5C61VAs7kJs4yd+pDNVAERJkknQ7Lg==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers-core': 0.8.9
-    dev: false
-
-  /@metaplex-foundation/umi-serializers@0.8.9:
-    resolution: {integrity: sha512-Sve8Etm3zqvLSUfza+MYRkjTnCpiaAFT7VWdqeHzA3n58P0AfT3p74RrZwVt/UFkxI+ln8BslwBDJmwzcPkuHw==}
-    dependencies:
-      '@metaplex-foundation/umi-options': 0.8.9
-      '@metaplex-foundation/umi-public-keys': 0.8.9
-      '@metaplex-foundation/umi-serializers-core': 0.8.9
-      '@metaplex-foundation/umi-serializers-encodings': 0.8.9
-      '@metaplex-foundation/umi-serializers-numbers': 0.8.9
-    dev: false
+      '@metaplex-foundation/beet-solana': 0.3.1
+      '@metaplex-foundation/rustbin': 0.3.5
+      '@solana/web3.js': 1.95.4
+      ansi-colors: 4.1.3
+      camelcase: 6.3.0
+      debug: 4.3.7(supports-color@8.1.1)
+      js-sha256: 0.9.0
+      prettier: 2.8.8
+      snake-case: 3.0.4
+      spok: 1.5.5
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+    dev: true
 
-  /@noble/curves@1.4.0:
-    resolution: {integrity: sha512-p+4cb332SFCrReJkCYe8Xzm0OWi4Jji5jVdIZRL/PmacmDkFNw6MrrV+gGpiPxLHbV+zKFRywUWbaseT+tZRXg==}
+  /@noble/curves@1.4.2:
+    resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==}
     dependencies:
       '@noble/hashes': 1.4.0
 
@@ -1957,58 +1452,13 @@ packages:
     dev: true
     optional: true
 
-  /@pkgr/utils@2.4.2:
-    resolution: {integrity: sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==}
+  /@pkgr/core@0.1.1:
+    resolution: {integrity: sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==}
     engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
-    dependencies:
-      cross-spawn: 7.0.3
-      fast-glob: 3.3.2
-      is-glob: 4.0.3
-      open: 9.1.0
-      picocolors: 1.0.0
-      tslib: 2.6.3
-    dev: true
-
-  /@project-serum/anchor@0.26.0:
-    resolution: {integrity: sha512-Nq+COIjE1135T7qfnOHEn7E0q39bQTgXLFk837/rgFe6Hkew9WML7eHsS+lSYD2p3OJaTiUOHTAq1lHy36oIqQ==}
-    engines: {node: '>=11'}
-    dependencies:
-      '@coral-xyz/borsh': 0.26.0(@solana/web3.js@1.93.0)
-      '@solana/web3.js': 1.93.0
-      base64-js: 1.5.1
-      bn.js: 5.2.1
-      bs58: 4.0.1
-      buffer-layout: 1.2.2
-      camelcase: 6.3.0
-      cross-fetch: 3.1.8
-      crypto-hash: 1.3.0
-      eventemitter3: 4.0.7
-      js-sha256: 0.9.0
-      pako: 2.1.0
-      snake-case: 3.0.4
-      superstruct: 0.15.5
-      toml: 3.0.0
-    transitivePeerDependencies:
-      - bufferutil
-      - encoding
-      - utf-8-validate
-    dev: true
-
-  /@rollup/plugin-alias@5.1.0(rollup@4.18.0):
-    resolution: {integrity: sha512-lpA3RZ9PdIG7qqhEfv79tBffNaoDuukFDrmhLqg9ifv99u/ehn+lOg30x2zmhf8AQqQUZaMk/B9fZraQ6/acDQ==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      rollup: 4.18.0
-      slash: 4.0.0
     dev: true
 
-  /@rollup/plugin-commonjs@26.0.1(rollup@4.18.0):
-    resolution: {integrity: sha512-UnsKoZK6/aGIH6AdkptXhNvhaqftcjq3zZdT+LY5Ftms6JR06nADcDsYp5hTU9E2lbJUEOhdlY5J4DNTneM+jQ==}
+  /@rollup/plugin-commonjs@28.0.2(rollup@4.30.1):
+    resolution: {integrity: sha512-BEFI2EDqzl+vA1rl97IDRZ61AIwGH093d9nz8+dThxJNH8oSoB7MjWvPCX3dkaK1/RCJ/1v/R1XB15FuSs0fQw==}
     engines: {node: '>=16.0.0 || 14 >= 14.17'}
     peerDependencies:
       rollup: ^2.68.0||^3.0.0||^4.0.0
@@ -2016,44 +1466,18 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.1.0(rollup@4.18.0)
+      '@rollup/pluginutils': 5.1.0(rollup@4.30.1)
       commondir: 1.0.1
       estree-walker: 2.0.2
-      glob: 10.4.1
+      fdir: 6.3.0(picomatch@4.0.2)
       is-reference: 1.2.1
       magic-string: 0.30.10
-      rollup: 4.18.0
-    dev: true
-
-  /@rollup/plugin-json@6.1.0(rollup@4.18.0):
-    resolution: {integrity: sha512-EGI2te5ENk1coGeADSIwZ7G2Q8CJS2sF120T7jLw4xFw9n7wIOXHo+kIYRAoVpJAN+kmqZSoO3Fp4JtoNF4ReA==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      '@rollup/pluginutils': 5.1.0(rollup@4.18.0)
-      rollup: 4.18.0
-    dev: true
-
-  /@rollup/plugin-multi-entry@6.0.1(rollup@4.18.0):
-    resolution: {integrity: sha512-AXm6toPyTSfbYZWghQGbom1Uh7dHXlrGa+HoiYNhQtDUE3Q7LqoUYdVQx9E1579QWS1uOiu+cZRSE4okO7ySgw==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      '@rollup/plugin-virtual': 3.0.2(rollup@4.18.0)
-      matched: 5.0.1
-      rollup: 4.18.0
+      picomatch: 4.0.2
+      rollup: 4.30.1
     dev: true
 
-  /@rollup/plugin-node-resolve@15.2.3(rollup@4.18.0):
-    resolution: {integrity: sha512-j/lym8nf5E21LwBT4Df1VD6hRO2L2iwUeUmP7litikRsVp1H6NWx20NEp0Y7su+7XGc476GnXXc4kFeZNGmaSQ==}
+  /@rollup/plugin-node-resolve@16.0.0(rollup@4.30.1):
+    resolution: {integrity: sha512-0FPvAeVUT/zdWoO0jnb/V5BlBsUSNfkIOtFHzMO4H9MOklrmQFY6FduVHKucNb/aTFxvnGhj4MNj/T1oNdDfNg==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
       rollup: ^2.78.0||^3.0.0||^4.0.0
@@ -2061,32 +1485,16 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.0.5(rollup@4.18.0)
+      '@rollup/pluginutils': 5.1.0(rollup@4.30.1)
       '@types/resolve': 1.20.2
       deepmerge: 4.3.1
-      is-builtin-module: 3.2.1
       is-module: 1.0.0
       resolve: 1.22.8
-      rollup: 4.18.0
-    dev: true
-
-  /@rollup/plugin-terser@0.4.4(rollup@4.18.0):
-    resolution: {integrity: sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      rollup: 4.18.0
-      serialize-javascript: 6.0.1
-      smob: 1.4.1
-      terser: 5.24.0
+      rollup: 4.30.1
     dev: true
 
-  /@rollup/plugin-typescript@11.1.6(rollup@4.18.0)(tslib@2.6.3)(typescript@5.4.5):
-    resolution: {integrity: sha512-R92yOmIACgYdJ7dJ97p4K69I8gg6IEHt8M7dUBxN3W6nrO8uUxX5ixl0yU/N3aZTi8WhPuICvOHXQvF6FaykAA==}
+  /@rollup/plugin-typescript@12.1.2(rollup@4.30.1)(tslib@2.8.1)(typescript@5.7.2):
+    resolution: {integrity: sha512-cdtSp154H5sv637uMr1a8OTWB0L1SWDSm1rDGiyfcGcvQ6cuTs4MDk2BVEBGysUWago4OJN4EQZqOTl/QY3Jgg==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
       rollup: ^2.14.0||^3.0.0||^4.0.0
@@ -2098,49 +1506,14 @@ packages:
       tslib:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.1.0(rollup@4.18.0)
+      '@rollup/pluginutils': 5.1.0(rollup@4.30.1)
       resolve: 1.22.8
-      rollup: 4.18.0
-      tslib: 2.6.3
-      typescript: 5.4.5
-    dev: true
-
-  /@rollup/plugin-virtual@3.0.2(rollup@4.18.0):
-    resolution: {integrity: sha512-10monEYsBp3scM4/ND4LNH5Rxvh3e/cVeL3jWTgZ2SrQ+BmUoQcopVQvnaMcOnykb1VkxUFuDAN+0FnpTFRy2A==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      rollup: 4.18.0
-    dev: true
-
-  /@rollup/pluginutils@4.2.1:
-    resolution: {integrity: sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==}
-    engines: {node: '>= 8.0.0'}
-    dependencies:
-      estree-walker: 2.0.2
-      picomatch: 2.3.1
-    dev: true
-
-  /@rollup/pluginutils@5.0.5(rollup@4.18.0):
-    resolution: {integrity: sha512-6aEYR910NyP73oHiJglti74iRyOwgFU4x3meH/H8OJx6Ry0j6cOVZ5X/wTvub7G7Ao6qaHBEaNsV3GLJkSsF+Q==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      '@types/estree': 1.0.5
-      estree-walker: 2.0.2
-      picomatch: 2.3.1
-      rollup: 4.18.0
+      rollup: 4.30.1
+      tslib: 2.8.1
+      typescript: 5.7.2
     dev: true
 
-  /@rollup/pluginutils@5.1.0(rollup@4.18.0):
+  /@rollup/pluginutils@5.1.0(rollup@4.30.1):
     resolution: {integrity: sha512-XTIWOPPcpvyKI6L1NHo0lFlCyznUEyPmPY1mc3KpPVDYulHSTvyeLNVW00QTLIAFNhR3kYnJTQHeGqU4M3n09g==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
@@ -2149,142 +1522,188 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@types/estree': 1.0.5
+      '@types/estree': 1.0.6
       estree-walker: 2.0.2
       picomatch: 2.3.1
-      rollup: 4.18.0
+      rollup: 4.30.1
     dev: true
 
-  /@rollup/rollup-android-arm-eabi@4.18.0:
-    resolution: {integrity: sha512-Tya6xypR10giZV1XzxmH5wr25VcZSncG0pZIjfePT0OVBvqNEurzValetGNarVrGiq66EBVAFn15iYX4w6FKgQ==}
+  /@rollup/rollup-android-arm-eabi@4.30.1:
+    resolution: {integrity: sha512-pSWY+EVt3rJ9fQ3IqlrEUtXh3cGqGtPDH1FQlNZehO2yYxCHEX1SPsz1M//NXwYfbTlcKr9WObLnJX9FsS9K1Q==}
     cpu: [arm]
     os: [android]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-android-arm64@4.18.0:
-    resolution: {integrity: sha512-avCea0RAP03lTsDhEyfy+hpfr85KfyTctMADqHVhLAF3MlIkq83CP8UfAHUssgXTYd+6er6PaAhx/QGv4L1EiA==}
+  /@rollup/rollup-android-arm64@4.30.1:
+    resolution: {integrity: sha512-/NA2qXxE3D/BRjOJM8wQblmArQq1YoBVJjrjoTSBS09jgUisq7bqxNHJ8kjCHeV21W/9WDGwJEWSN0KQ2mtD/w==}
     cpu: [arm64]
     os: [android]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-darwin-arm64@4.18.0:
-    resolution: {integrity: sha512-IWfdwU7KDSm07Ty0PuA/W2JYoZ4iTj3TUQjkVsO/6U+4I1jN5lcR71ZEvRh52sDOERdnNhhHU57UITXz5jC1/w==}
+  /@rollup/rollup-darwin-arm64@4.30.1:
+    resolution: {integrity: sha512-r7FQIXD7gB0WJ5mokTUgUWPl0eYIH0wnxqeSAhuIwvnnpjdVB8cRRClyKLQr7lgzjctkbp5KmswWszlwYln03Q==}
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-darwin-x64@4.18.0:
-    resolution: {integrity: sha512-n2LMsUz7Ynu7DoQrSQkBf8iNrjOGyPLrdSg802vk6XT3FtsgX6JbE8IHRvposskFm9SNxzkLYGSq9QdpLYpRNA==}
+  /@rollup/rollup-darwin-x64@4.30.1:
+    resolution: {integrity: sha512-x78BavIwSH6sqfP2xeI1hd1GpHL8J4W2BXcVM/5KYKoAD3nNsfitQhvWSw+TFtQTLZ9OmlF+FEInEHyubut2OA==}
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-arm-gnueabihf@4.18.0:
-    resolution: {integrity: sha512-C/zbRYRXFjWvz9Z4haRxcTdnkPt1BtCkz+7RtBSuNmKzMzp3ZxdM28Mpccn6pt28/UWUCTXa+b0Mx1k3g6NOMA==}
+  /@rollup/rollup-freebsd-arm64@4.30.1:
+    resolution: {integrity: sha512-HYTlUAjbO1z8ywxsDFWADfTRfTIIy/oUlfIDmlHYmjUP2QRDTzBuWXc9O4CXM+bo9qfiCclmHk1x4ogBjOUpUQ==}
+    cpu: [arm64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-freebsd-x64@4.30.1:
+    resolution: {integrity: sha512-1MEdGqogQLccphhX5myCJqeGNYTNcmTyaic9S7CG3JhwuIByJ7J05vGbZxsizQthP1xpVx7kd3o31eOogfEirw==}
+    cpu: [x64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-linux-arm-gnueabihf@4.30.1:
+    resolution: {integrity: sha512-PaMRNBSqCx7K3Wc9QZkFx5+CX27WFpAMxJNiYGAXfmMIKC7jstlr32UhTgK6T07OtqR+wYlWm9IxzennjnvdJg==}
     cpu: [arm]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-arm-musleabihf@4.18.0:
-    resolution: {integrity: sha512-l3m9ewPgjQSXrUMHg93vt0hYCGnrMOcUpTz6FLtbwljo2HluS4zTXFy2571YQbisTnfTKPZ01u/ukJdQTLGh9A==}
+  /@rollup/rollup-linux-arm-musleabihf@4.30.1:
+    resolution: {integrity: sha512-B8Rcyj9AV7ZlEFqvB5BubG5iO6ANDsRKlhIxySXcF1axXYUyqwBok+XZPgIYGBgs7LDXfWfifxhw0Ik57T0Yug==}
     cpu: [arm]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-arm64-gnu@4.18.0:
-    resolution: {integrity: sha512-rJ5D47d8WD7J+7STKdCUAgmQk49xuFrRi9pZkWoRD1UeSMakbcepWXPF8ycChBoAqs1pb2wzvbY6Q33WmN2ftw==}
+  /@rollup/rollup-linux-arm64-gnu@4.30.1:
+    resolution: {integrity: sha512-hqVyueGxAj3cBKrAI4aFHLV+h0Lv5VgWZs9CUGqr1z0fZtlADVV1YPOij6AhcK5An33EXaxnDLmJdQikcn5NEw==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-arm64-musl@4.18.0:
-    resolution: {integrity: sha512-be6Yx37b24ZwxQ+wOQXXLZqpq4jTckJhtGlWGZs68TgdKXJgw54lUUoFYrg6Zs/kjzAQwEwYbp8JxZVzZLRepQ==}
+  /@rollup/rollup-linux-arm64-musl@4.30.1:
+    resolution: {integrity: sha512-i4Ab2vnvS1AE1PyOIGp2kXni69gU2DAUVt6FSXeIqUCPIR3ZlheMW3oP2JkukDfu3PsexYRbOiJrY+yVNSk9oA==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-powerpc64le-gnu@4.18.0:
-    resolution: {integrity: sha512-hNVMQK+qrA9Todu9+wqrXOHxFiD5YmdEi3paj6vP02Kx1hjd2LLYR2eaN7DsEshg09+9uzWi2W18MJDlG0cxJA==}
+  /@rollup/rollup-linux-loongarch64-gnu@4.30.1:
+    resolution: {integrity: sha512-fARcF5g296snX0oLGkVxPmysetwUk2zmHcca+e9ObOovBR++9ZPOhqFUM61UUZ2EYpXVPN1redgqVoBB34nTpQ==}
+    cpu: [loong64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-linux-powerpc64le-gnu@4.30.1:
+    resolution: {integrity: sha512-GLrZraoO3wVT4uFXh67ElpwQY0DIygxdv0BNW9Hkm3X34wu+BkqrDrkcsIapAY+N2ATEbvak0XQ9gxZtCIA5Rw==}
     cpu: [ppc64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-riscv64-gnu@4.18.0:
-    resolution: {integrity: sha512-ROCM7i+m1NfdrsmvwSzoxp9HFtmKGHEqu5NNDiZWQtXLA8S5HBCkVvKAxJ8U+CVctHwV2Gb5VUaK7UAkzhDjlg==}
+  /@rollup/rollup-linux-riscv64-gnu@4.30.1:
+    resolution: {integrity: sha512-0WKLaAUUHKBtll0wvOmh6yh3S0wSU9+yas923JIChfxOaaBarmb/lBKPF0w/+jTVozFnOXJeRGZ8NvOxvk/jcw==}
     cpu: [riscv64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-s390x-gnu@4.18.0:
-    resolution: {integrity: sha512-0UyyRHyDN42QL+NbqevXIIUnKA47A+45WyasO+y2bGJ1mhQrfrtXUpTxCOrfxCR4esV3/RLYyucGVPiUsO8xjg==}
+  /@rollup/rollup-linux-s390x-gnu@4.30.1:
+    resolution: {integrity: sha512-GWFs97Ruxo5Bt+cvVTQkOJ6TIx0xJDD/bMAOXWJg8TCSTEK8RnFeOeiFTxKniTc4vMIaWvCplMAFBt9miGxgkA==}
     cpu: [s390x]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-x64-gnu@4.18.0:
-    resolution: {integrity: sha512-xuglR2rBVHA5UsI8h8UbX4VJ470PtGCf5Vpswh7p2ukaqBGFTnsfzxUBetoWBWymHMxbIG0Cmx7Y9qDZzr648w==}
+  /@rollup/rollup-linux-x64-gnu@4.30.1:
+    resolution: {integrity: sha512-UtgGb7QGgXDIO+tqqJ5oZRGHsDLO8SlpE4MhqpY9Llpzi5rJMvrK6ZGhsRCST2abZdBqIBeXW6WPD5fGK5SDwg==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-linux-x64-musl@4.18.0:
-    resolution: {integrity: sha512-LKaqQL9osY/ir2geuLVvRRs+utWUNilzdE90TpyoX0eNqPzWjRm14oMEE+YLve4k/NAqCdPkGYDaDF5Sw+xBfg==}
+  /@rollup/rollup-linux-x64-musl@4.30.1:
+    resolution: {integrity: sha512-V9U8Ey2UqmQsBT+xTOeMzPzwDzyXmnAoO4edZhL7INkwQcaW1Ckv3WJX3qrrp/VHaDkEWIBWhRwP47r8cdrOow==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-win32-arm64-msvc@4.18.0:
-    resolution: {integrity: sha512-7J6TkZQFGo9qBKH0pk2cEVSRhJbL6MtfWxth7Y5YmZs57Pi+4x6c2dStAUvaQkHQLnEQv1jzBUW43GvZW8OFqA==}
+  /@rollup/rollup-win32-arm64-msvc@4.30.1:
+    resolution: {integrity: sha512-WabtHWiPaFF47W3PkHnjbmWawnX/aE57K47ZDT1BXTS5GgrBUEpvOzq0FI0V/UYzQJgdb8XlhVNH8/fwV8xDjw==}
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-win32-ia32-msvc@4.18.0:
-    resolution: {integrity: sha512-Txjh+IxBPbkUB9+SXZMpv+b/vnTEtFyfWZgJ6iyCmt2tdx0OF5WhFowLmnh8ENGNpfUlUZkdI//4IEmhwPieNg==}
+  /@rollup/rollup-win32-ia32-msvc@4.30.1:
+    resolution: {integrity: sha512-pxHAU+Zv39hLUTdQQHUVHf4P+0C47y/ZloorHpzs2SXMRqeAWmGghzAhfOlzFHHwjvgokdFAhC4V+6kC1lRRfw==}
     cpu: [ia32]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@rollup/rollup-win32-x64-msvc@4.18.0:
-    resolution: {integrity: sha512-UOo5FdvOL0+eIVTgS4tIdbW+TtnBLWg1YBCcU2KWM7nuNwRz9bksDX1bekJJCpu25N1DVWaCwnT39dVQxzqS8g==}
+  /@rollup/rollup-win32-x64-msvc@4.30.1:
+    resolution: {integrity: sha512-D6qjsXGcvhTjv0kI4fU8tUuBDF/Ueee4SVX79VfNDXZa64TfCW1Slkb6Z7O1p7vflqZjcmOVdZlqf8gvJxc6og==}
     cpu: [x64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@sideway/address@4.1.4:
-    resolution: {integrity: sha512-7vwq+rOHVWjyXxVlR76Agnvhy8I9rpzjosTESvmhNeXOXdZZB15Fl+TI9x1SiHZH5Jv2wTGduSxFDIaq0m3DUw==}
+  /@rtsao/scc@1.1.0:
+    resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==}
+    dev: true
+
+  /@shikijs/engine-oniguruma@1.24.0:
+    resolution: {integrity: sha512-Eua0qNOL73Y82lGA4GF5P+G2+VXX9XnuUxkiUuwcxQPH4wom+tE39kZpBFXfUuwNYxHSkrSxpB1p4kyRW0moSg==}
+    dependencies:
+      '@shikijs/types': 1.24.0
+      '@shikijs/vscode-textmate': 9.3.0
+    dev: true
+
+  /@shikijs/types@1.24.0:
+    resolution: {integrity: sha512-aptbEuq1Pk88DMlCe+FzXNnBZ17LCiLIGWAeCWhoFDzia5Q5Krx3DgnULLiouSdd6+LUM39XwXGppqYE0Ghtug==}
+    dependencies:
+      '@shikijs/vscode-textmate': 9.3.0
+      '@types/hast': 3.0.4
+    dev: true
+
+  /@shikijs/vscode-textmate@9.3.0:
+    resolution: {integrity: sha512-jn7/7ky30idSkd/O5yDBfAnVt+JJpepofP/POZ1iMOxK59cOfqIgg/Dj0eFsjOTMw+4ycJN0uhZH/Eb0bs/EUA==}
+    dev: true
+
+  /@sideway/address@4.1.5:
+    resolution: {integrity: sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==}
     dependencies:
       '@hapi/hoek': 9.3.0
     dev: true
@@ -2301,9 +1720,8 @@ packages:
     resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}
     dev: true
 
-  /@sindresorhus/merge-streams@1.0.0:
-    resolution: {integrity: sha512-rUV5WyJrJLoloD4NDN1V1+LDMDWOa4OTsT4yYJwQNpTU6FWxkxHpL7eu4w+DmiH8x/EAM1otkPE1+LaspIbplw==}
-    engines: {node: '>=18'}
+  /@sinclair/typebox@0.33.17:
+    resolution: {integrity: sha512-75232GRx3wp3P7NP+yc4nRK3XUAnaQShxTAzapgmQrgs0QvSq0/mOJGoZXRpH15cFCKyys+4laCPbBselqJ5Ag==}
     dev: true
 
   /@sinonjs/commons@3.0.0:
@@ -2312,29 +1730,30 @@ packages:
       type-detect: 4.0.8
     dev: true
 
+  /@sinonjs/commons@3.0.1:
+    resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
+    dependencies:
+      type-detect: 4.0.8
+    dev: true
+
   /@sinonjs/fake-timers@10.3.0:
     resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==}
     dependencies:
       '@sinonjs/commons': 3.0.0
     dev: true
 
-  /@solana/addresses@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-zmg+ALhjxZApKJKSjeGK7EgMT9NywdvGKlAjyNL2fieiFWp0lRTBmWyjPBCQQGdJjBkayCscq3GQkDF2MhC6fg==}
+  /@sinonjs/fake-timers@11.3.1:
+    resolution: {integrity: sha512-EVJO7nW5M/F5Tur0Rf2z/QoMo+1Ia963RiMtapiQrEWvY0iBUvADo8Beegwjpnle5BHkyHuoxSTW3jF43H1XRA==}
     dependencies:
-      '@metaplex-foundation/umi-serializers': 0.8.9
-      '@solana/assertions': 2.0.0-experimental.21e994f
-    dev: false
-
-  /@solana/assertions@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-iGOUpOqkqxzQ/xi4Q3YLiBQPASiQ43NYTalmQm99hmOhySRA4+yyQTmMW1PJ8FAm7Zf86cCiYTf19Exa7+DxoQ==}
-    dev: false
+      '@sinonjs/commons': 3.0.1
+    dev: true
 
   /@solana/buffer-layout-utils@0.2.0:
     resolution: {integrity: sha512-szG4sxgJGktbuZYDg2FfNmkMi0DYQoVjN2h7ta1W1hPrwzarcFLBq9UpX1UjNXsNpT9dn+chgprtWGioUAr4/g==}
     engines: {node: '>= 10'}
     dependencies:
       '@solana/buffer-layout': 4.0.1
-      '@solana/web3.js': 1.93.0
+      '@solana/web3.js': 1.95.5
       bigint-buffer: 1.1.5
       bignumber.js: 9.1.2
     transitivePeerDependencies:
@@ -2348,265 +1767,203 @@ packages:
     dependencies:
       buffer: 6.0.3
 
-  /@solana/codecs-core@2.0.0-preview.2:
-    resolution: {integrity: sha512-gLhCJXieSCrAU7acUJjbXl+IbGnqovvxQLlimztPoGgfLQ1wFYu+XJswrEVQqknZYK1pgxpxH3rZ+OKFs0ndQg==}
-    dependencies:
-      '@solana/errors': 2.0.0-preview.2
-
-  /@solana/codecs-core@2.0.0-preview.3:
-    resolution: {integrity: sha512-xQz6USSBs82lUNoVa/wwnm6wa2y2eWtGwPLUwF/NOGGpR+QH9EODijXvJ8wuC9llyqerqdC+5mrmx9C8VSMNYg==}
-    dependencies:
-      '@solana/errors': 2.0.0-preview.3
-
-  /@solana/codecs-data-structures@2.0.0-preview.2:
-    resolution: {integrity: sha512-Xf5vIfromOZo94Q8HbR04TbgTwzigqrKII0GjYr21K7rb3nba4hUW2ir8kguY7HWFBcjHGlU5x3MevKBOLp3Zg==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.2
-      '@solana/codecs-numbers': 2.0.0-preview.2
-      '@solana/errors': 2.0.0-preview.2
-
-  /@solana/codecs-data-structures@2.0.0-preview.3:
-    resolution: {integrity: sha512-PfXvZCf9qDF+Dv4WG6cb4xZoY9tj117bmZWS17iKimuNSsvuFSHpzERy0mmX2hwYEAM4CnQBd/9dgx+eAeMAsg==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.3
-      '@solana/codecs-numbers': 2.0.0-preview.3
-      '@solana/errors': 2.0.0-preview.3
-    dev: false
-
-  /@solana/codecs-numbers@2.0.0-preview.2:
-    resolution: {integrity: sha512-aLZnDTf43z4qOnpTcDsUVy1Ci9im1Md8thWipSWbE+WM9ojZAx528oAql+Cv8M8N+6ALKwgVRhPZkto6E59ARw==}
+  /@solana/codecs-core@2.0.0-rc.1(typescript@5.7.2):
+    resolution: {integrity: sha512-bauxqMfSs8EHD0JKESaNmNuNvkvHSuN3bbWAF5RjOfDu2PugxHrvRebmYauvSumZ3cTfQ4HJJX6PG5rN852qyQ==}
+    peerDependencies:
+      typescript: '>=5'
     dependencies:
-      '@solana/codecs-core': 2.0.0-preview.2
-      '@solana/errors': 2.0.0-preview.2
+      '@solana/errors': 2.0.0-rc.1(typescript@5.7.2)
+      typescript: 5.7.2
+    dev: true
 
-  /@solana/codecs-numbers@2.0.0-preview.3:
-    resolution: {integrity: sha512-cjsHexVAj4GveDtG0+WjW121TKMbWN7AkOvGlf1qauOJgzJvX3V7KXHWuEg8wGGfRiLiXKEgh7KieQiB17EI3Q==}
+  /@solana/codecs-data-structures@2.0.0-rc.1(typescript@5.7.2):
+    resolution: {integrity: sha512-rinCv0RrAVJ9rE/rmaibWJQxMwC5lSaORSZuwjopSUE6T0nb/MVg6Z1siNCXhh/HFTOg0l8bNvZHgBcN/yvXog==}
+    peerDependencies:
+      typescript: '>=5'
     dependencies:
-      '@solana/codecs-core': 2.0.0-preview.3
-      '@solana/errors': 2.0.0-preview.3
+      '@solana/codecs-core': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-numbers': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/errors': 2.0.0-rc.1(typescript@5.7.2)
+      typescript: 5.7.2
+    dev: true
 
-  /@solana/codecs-strings@2.0.0-preview.2(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-EgBwY+lIaHHgMJIqVOGHfIfpdmmUDNoNO/GAUGeFPf+q0dF+DtwhJPEMShhzh64X2MeCZcmSO6Kinx0Bvmmz2g==}
+  /@solana/codecs-numbers@2.0.0-rc.1(typescript@5.7.2):
+    resolution: {integrity: sha512-J5i5mOkvukXn8E3Z7sGIPxsThRCgSdgTWJDQeZvucQ9PT6Y3HiVXJ0pcWiOWAoQ3RX8e/f4I3IC+wE6pZiJzDQ==}
     peerDependencies:
-      fastestsmallesttextencoderdecoder: ^1.0.22
+      typescript: '>=5'
     dependencies:
-      '@solana/codecs-core': 2.0.0-preview.2
-      '@solana/codecs-numbers': 2.0.0-preview.2
-      '@solana/errors': 2.0.0-preview.2
-      fastestsmallesttextencoderdecoder: 1.0.22
+      '@solana/codecs-core': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/errors': 2.0.0-rc.1(typescript@5.7.2)
+      typescript: 5.7.2
+    dev: true
 
-  /@solana/codecs-strings@2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-CUij3XgdoqbrEYncyy+kHCIXRHjqkcjiyJhf4hWVjMXM5nu2jreehhBiLFHFjlFw2U3vp1gig5QNxji8SjpQzw==}
+  /@solana/codecs-strings@2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-9/wPhw8TbGRTt6mHC4Zz1RqOnuPTqq1Nb4EyuvpZ39GW6O2t2Q7Q0XxiB3+BdoEjwA2XgPw6e2iRfvYgqty44g==}
     peerDependencies:
       fastestsmallesttextencoderdecoder: ^1.0.22
+      typescript: '>=5'
     dependencies:
-      '@solana/codecs-core': 2.0.0-preview.3
-      '@solana/codecs-numbers': 2.0.0-preview.3
-      '@solana/errors': 2.0.0-preview.3
+      '@solana/codecs-core': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-numbers': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/errors': 2.0.0-rc.1(typescript@5.7.2)
       fastestsmallesttextencoderdecoder: 1.0.22
+      typescript: 5.7.2
+    dev: true
 
-  /@solana/codecs@2.0.0-preview.2(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-4HHzCD5+pOSmSB71X6w9ptweV48Zj1Vqhe732+pcAQ2cMNnN0gMPMdDq7j3YwaZDZ7yrILVV/3+HTnfT77t2yA==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.2
-      '@solana/codecs-data-structures': 2.0.0-preview.2
-      '@solana/codecs-numbers': 2.0.0-preview.2
-      '@solana/codecs-strings': 2.0.0-preview.2(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/options': 2.0.0-preview.2
-    transitivePeerDependencies:
-      - fastestsmallesttextencoderdecoder
-
-  /@solana/codecs@2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-uB0GMAY1VrNoJxZ9S4F1RBL57gI+8YwxnV9DD5EP5rU8iD7Wq4wbaB2IPcENyJi7rmzytIjKJg0MI6i2bBr+0w==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.3
-      '@solana/codecs-data-structures': 2.0.0-preview.3
-      '@solana/codecs-numbers': 2.0.0-preview.3
-      '@solana/codecs-strings': 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/options': 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
+  /@solana/codecs@2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-qxoR7VybNJixV51L0G1RD2boZTcxmwUWnKCaJJExQ5qNKwbpSyDdWfFJfM5JhGyKe9DnPVOZB+JHWXnpbZBqrQ==}
+    peerDependencies:
+      typescript: '>=5'
+    dependencies:
+      '@solana/codecs-core': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-data-structures': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-numbers': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-strings': 2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/options': 2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - fastestsmallesttextencoderdecoder
-    dev: false
-
-  /@solana/errors@2.0.0-preview.2:
-    resolution: {integrity: sha512-H2DZ1l3iYF5Rp5pPbJpmmtCauWeQXRJapkDg8epQ8BJ7cA2Ut/QEtC3CMmw/iMTcuS6uemFNLcWvlOfoQhvQuA==}
-    hasBin: true
-    dependencies:
-      chalk: 5.3.0
-      commander: 12.0.0
+    dev: true
 
-  /@solana/errors@2.0.0-preview.3:
-    resolution: {integrity: sha512-IZAUMcKaV3Hn0QTfzlGmVsDaH1mVUq0uURJi+tm8K3n37cKrvXyS2GQsHtIMRaLdOVp1IbTtIc5YF3+qATlpyw==}
+  /@solana/errors@2.0.0-rc.1(typescript@5.7.2):
+    resolution: {integrity: sha512-ejNvQ2oJ7+bcFAYWj225lyRkHnixuAeb7RQCixm+5mH4n1IA4Qya/9Bmfy5RAAHQzxK43clu3kZmL5eF9VGtYQ==}
     hasBin: true
+    peerDependencies:
+      typescript: '>=5'
     dependencies:
       chalk: 5.3.0
-      commander: 12.0.0
+      commander: 12.1.0
+      typescript: 5.7.2
+    dev: true
 
-  /@solana/eslint-config-solana@3.0.3(@typescript-eslint/eslint-plugin@6.21.0)(@typescript-eslint/parser@6.21.0)(eslint-plugin-jest@27.9.0)(eslint-plugin-react-hooks@4.6.0)(eslint-plugin-simple-import-sort@10.0.0)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.2.0)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-yTaeCbOBwjmK4oUkknixOpwOzzAK8+4YWvJEJFNHuueESetieDnAeEHV7rzJllFgHEWa9nXps9Q3aD4/XJp71A==}
+  /@solana/eslint-config-solana@3.0.6(@typescript-eslint/eslint-plugin@8.12.2)(@typescript-eslint/parser@8.12.2)(eslint-plugin-jest@28.10.0)(eslint-plugin-react-hooks@4.6.2)(eslint-plugin-simple-import-sort@12.1.1)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.3.0)(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-3u024DkukJCfzUfOgN1EmWzVZLaZtgRLJ52FEdQmIG8NYOzLpaIJFgQvjYXWQlnK6ycIcSn/MesHG6sbKkMtTQ==}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': ^6.0.0
-      '@typescript-eslint/parser': ^6.0.0
+      '@typescript-eslint/eslint-plugin': ^7.0.0
+      '@typescript-eslint/parser': ^7.0.0
       eslint: ^8.45.0
       eslint-plugin-jest: ^27.2.3
       eslint-plugin-react-hooks: ^4.6.0
-      eslint-plugin-simple-import-sort: ^10.0.0
+      eslint-plugin-simple-import-sort: ^12.0.0
       eslint-plugin-sort-keys-fix: ^1.1.2
       eslint-plugin-typescript-sort-keys: ^3.2.0
       typescript: ^5.1.6
     dependencies:
-      '@typescript-eslint/eslint-plugin': 6.21.0(@typescript-eslint/parser@6.21.0)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/eslint-plugin': 8.12.2(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/parser': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
       eslint: 8.57.0
-      eslint-plugin-jest: 27.9.0(@typescript-eslint/eslint-plugin@6.21.0)(eslint@8.57.0)(typescript@5.4.5)
-      eslint-plugin-react-hooks: 4.6.0(eslint@8.57.0)
-      eslint-plugin-simple-import-sort: 10.0.0(eslint@8.57.0)
+      eslint-plugin-jest: 28.10.0(@typescript-eslint/eslint-plugin@8.12.2)(eslint@8.57.0)(jest@29.7.0)(typescript@5.7.2)
+      eslint-plugin-react-hooks: 4.6.2(eslint@8.57.0)
+      eslint-plugin-simple-import-sort: 12.1.1(eslint@8.57.0)
       eslint-plugin-sort-keys-fix: 1.1.2
-      eslint-plugin-typescript-sort-keys: 3.2.0(@typescript-eslint/parser@6.21.0)(eslint@8.57.0)(typescript@5.4.5)
-      typescript: 5.4.5
+      eslint-plugin-typescript-sort-keys: 3.3.0(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2)
+      typescript: 5.7.2
     dev: true
 
-  /@solana/eslint-config-solana@3.0.3(@typescript-eslint/eslint-plugin@7.13.1)(@typescript-eslint/parser@7.13.1)(eslint-plugin-jest@28.6.0)(eslint-plugin-react-hooks@4.6.0)(eslint-plugin-simple-import-sort@12.1.0)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.2.0)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-yTaeCbOBwjmK4oUkknixOpwOzzAK8+4YWvJEJFNHuueESetieDnAeEHV7rzJllFgHEWa9nXps9Q3aD4/XJp71A==}
+  /@solana/eslint-config-solana@4.0.0(@eslint/js@9.13.0)(@types/eslint__js@8.42.3)(eslint-plugin-jest@28.10.0)(eslint-plugin-react-hooks@5.0.0)(eslint-plugin-simple-import-sort@12.1.1)(eslint-plugin-sort-keys-fix@1.1.2)(eslint-plugin-typescript-sort-keys@3.3.0)(eslint@9.13.0)(globals@15.11.0)(jest@30.0.0-alpha.6)(typescript-eslint@8.12.2)(typescript@5.7.2):
+    resolution: {integrity: sha512-kDhd7uOsby+7Gffenn0EBeE692s2cwPe0/Lv1BsdfeniDM4NxBcfIXLQFB8iCCvdFWrO9b+0SMuGrhRHdgTDQQ==}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': ^6.0.0
-      '@typescript-eslint/parser': ^6.0.0
-      eslint: ^8.45.0
-      eslint-plugin-jest: ^27.2.3
-      eslint-plugin-react-hooks: ^4.6.0
-      eslint-plugin-simple-import-sort: ^10.0.0
+      '@eslint/js': ^9.13.0
+      '@types/eslint__js': ^8.42.3
+      eslint: ^9.13.0
+      eslint-plugin-jest: ^28.8.3
+      eslint-plugin-react-hooks: ^5.0.0
+      eslint-plugin-simple-import-sort: ^12.1.1
       eslint-plugin-sort-keys-fix: ^1.1.2
-      eslint-plugin-typescript-sort-keys: ^3.2.0
-      typescript: ^5.1.6
-    dependencies:
-      '@typescript-eslint/eslint-plugin': 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      eslint: 8.57.0
-      eslint-plugin-jest: 28.6.0(@typescript-eslint/eslint-plugin@7.13.1)(eslint@8.57.0)(jest@29.7.0)(typescript@5.4.5)
-      eslint-plugin-react-hooks: 4.6.0(eslint@8.57.0)
-      eslint-plugin-simple-import-sort: 12.1.0(eslint@8.57.0)
+      eslint-plugin-typescript-sort-keys: ^3.3.0
+      globals: ^15.11.0
+      jest: ^30.0.0-alpha.6
+      typescript: ^5.6
+      typescript-eslint: ^8.11.0
+    dependencies:
+      '@eslint/js': 9.13.0
+      '@types/eslint__js': 8.42.3
+      eslint: 9.13.0
+      eslint-plugin-jest: 28.10.0(eslint@9.13.0)(jest@30.0.0-alpha.6)(typescript@5.7.2)
+      eslint-plugin-react-hooks: 5.0.0(eslint@9.13.0)
+      eslint-plugin-simple-import-sort: 12.1.1(eslint@9.13.0)
       eslint-plugin-sort-keys-fix: 1.1.2
-      eslint-plugin-typescript-sort-keys: 3.2.0(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      typescript: 5.4.5
+      eslint-plugin-typescript-sort-keys: 3.3.0(@typescript-eslint/parser@8.12.2)(eslint@9.13.0)(typescript@5.7.2)
+      globals: 15.11.0
+      jest: 30.0.0-alpha.6
+      typescript: 5.7.2
+      typescript-eslint: 8.12.2(eslint@9.13.0)(typescript@5.7.2)
     dev: true
 
-  /@solana/functional@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-FMXFiTA+hsc9FCv0r47oF7njq/K9x7zh0H+To7tpeqwN65LtJPu5BMG7xZY3rn5TrudgKw6XPuIr3ARbI8+IWA==}
-    dev: false
-
-  /@solana/instructions@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-PuJJzvT7wtwE5UcGavUppnfVWnoxL8CPhZBb96HpOaQhQ2JuyhN445bfav5KkaUMCE6ubrVzOEqzrbtygD3aBg==}
-    dev: false
-
-  /@solana/keys@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-Qsm7ARy69PdIuis7TZy8ELyhq0pcRFPXtaZ8vLFUvsukrcWRowiJ8JJs6Q3tA+gQK5vUn9ABp7a7Qs0FHzgbyw==}
-    dependencies:
-      '@solana/assertions': 2.0.0-experimental.21e994f
-    dev: false
-
-  /@solana/options@2.0.0-preview.2:
-    resolution: {integrity: sha512-FAHqEeH0cVsUOTzjl5OfUBw2cyT8d5Oekx4xcn5hn+NyPAfQJgM3CEThzgRD6Q/4mM5pVUnND3oK/Mt1RzSE/w==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.2
-      '@solana/codecs-numbers': 2.0.0-preview.2
-
-  /@solana/options@2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-tT5O1CCJVE+rzo4VeeivYLNUL4L/2BjIeiy0MRh04lPxieiR346vUOPC1uCWGD6WqyTOOVUL0tsY4saYLmCTtA==}
-    dependencies:
-      '@solana/codecs-core': 2.0.0-preview.3
-      '@solana/codecs-data-structures': 2.0.0-preview.3
-      '@solana/codecs-numbers': 2.0.0-preview.3
-      '@solana/codecs-strings': 2.0.0-preview.3(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/errors': 2.0.0-preview.3
+  /@solana/options@2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-mLUcR9mZ3qfHlmMnREdIFPf9dpMc/Bl66tLSOOWxw4ml5xMT2ohFn7WGqoKcu/UHkT9CrC6+amEdqCNvUqI7AA==}
+    peerDependencies:
+      typescript: '>=5'
+    dependencies:
+      '@solana/codecs-core': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-data-structures': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-numbers': 2.0.0-rc.1(typescript@5.7.2)
+      '@solana/codecs-strings': 2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/errors': 2.0.0-rc.1(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - fastestsmallesttextencoderdecoder
-    dev: false
+    dev: true
 
-  /@solana/prettier-config-solana@0.0.5(prettier@3.3.2):
+  /@solana/prettier-config-solana@0.0.5(prettier@3.4.2):
     resolution: {integrity: sha512-igtLH1QaX5xzSLlqteexRIg9X1QKA03xKYQc2qY1TrMDDhxKXoRZOStQPWdita2FVJzxTGz/tdMGC1vS0biRcg==}
     peerDependencies:
       prettier: ^3.2.0
     dependencies:
-      prettier: 3.3.2
+      prettier: 3.4.2
     dev: true
 
-  /@solana/rpc-core@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-T7VcTLRi4dsqmpFYdnvcHZFS8Vcgdi6funMUrXcM7ofQqb8vWGJnlX6AX0eIZiVsmoYk5Ki8wW4D6Ul6bXZyZg==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers': 0.8.9
-    dev: false
-
-  /@solana/rpc-transport@2.0.0-experimental.21e994f(node-fetch@2.7.0)(ws@8.14.2):
-    resolution: {integrity: sha512-PfGPzRuEodhfLyOD8ZneYQ389SWYgmj1Q/HWQZo8yZMsiAaW/lqCygoW88lecxXKlZF5gJYrBX154kgvGqEM7g==}
-    peerDependencies:
-      node-fetch: ^2.6.7
-      ws: ^8.14.0
-    dependencies:
-      node-fetch: 2.7.0
-      ws: 8.14.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)
-    dev: false
-
-  /@solana/spl-token-group@0.0.4(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-7+80nrEMdUKlK37V6kOe024+T7J4nNss0F8LQ9OOPYdWCCfJmsGUzVx2W3oeizZR4IHM6N4yC9v1Xqwc3BTPWw==}
+  /@solana/spl-token-group@0.0.7(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-V1N/iX7Cr7H0uazWUT2uk27TMqlqedpXHRqqAbVO2gvmJyT0E0ummMEAVQeXZ05ZhQ/xF39DLSdBp90XebWEug==}
     engines: {node: '>=16'}
     peerDependencies:
-      '@solana/web3.js': ^1.91.6
+      '@solana/web3.js': ^1.95.3
     dependencies:
-      '@solana/codecs': 2.0.0-preview.2(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-type-length-value': 0.1.0
-      '@solana/web3.js': 1.93.0
+      '@solana/codecs': 2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/web3.js': 1.95.5
     transitivePeerDependencies:
       - fastestsmallesttextencoderdecoder
+      - typescript
+    dev: true
 
-  /@solana/spl-token-metadata@0.1.4(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-N3gZ8DlW6NWDV28+vCCDJoTqaCZiF/jDUnk3o8GRkAFzHObiR60Bs1gXHBa8zCPdvOwiG6Z3dg5pg7+RW6XNsQ==}
+  /@solana/spl-token-metadata@0.1.6(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-7sMt1rsm/zQOQcUWllQX9mD2O6KhSAtY1hFR2hfFwgqfFWzSY9E9GDvFVNYUI1F0iQKcm6HmePU9QbKRXTEBiA==}
     engines: {node: '>=16'}
     peerDependencies:
-      '@solana/web3.js': ^1.91.6
+      '@solana/web3.js': ^1.95.3
     dependencies:
-      '@solana/codecs': 2.0.0-preview.2(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-type-length-value': 0.1.0
-      '@solana/web3.js': 1.93.0
+      '@solana/codecs': 2.0.0-rc.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/web3.js': 1.95.5
     transitivePeerDependencies:
       - fastestsmallesttextencoderdecoder
+      - typescript
+    dev: true
 
-  /@solana/spl-token@0.4.6(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22):
-    resolution: {integrity: sha512-1nCnUqfHVtdguFciVWaY/RKcQz1IF4b31jnKgAmjU9QVN1q7dRUkTEWJZgTYIEtsULjVnC9jRqlhgGN39WbKKA==}
+  /@solana/spl-token@0.4.9(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2):
+    resolution: {integrity: sha512-g3wbj4F4gq82YQlwqhPB0gHFXfgsC6UmyGMxtSLf/BozT/oKd59465DbnlUK8L8EcimKMavxsVAMoLcEdeCicg==}
     engines: {node: '>=16'}
     peerDependencies:
-      '@solana/web3.js': ^1.91.6
+      '@solana/web3.js': ^1.95.3
     dependencies:
       '@solana/buffer-layout': 4.0.1
       '@solana/buffer-layout-utils': 0.2.0
-      '@solana/spl-token-group': 0.0.4(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/spl-token-metadata': 0.1.4(@solana/web3.js@1.93.0)(fastestsmallesttextencoderdecoder@1.0.22)
-      '@solana/web3.js': 1.93.0
+      '@solana/spl-token-group': 0.0.7(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/spl-token-metadata': 0.1.6(@solana/web3.js@1.95.5)(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.7.2)
+      '@solana/web3.js': 1.95.5
       buffer: 6.0.3
     transitivePeerDependencies:
       - bufferutil
       - encoding
       - fastestsmallesttextencoderdecoder
+      - typescript
       - utf-8-validate
+    dev: true
 
-  /@solana/spl-type-length-value@0.1.0:
-    resolution: {integrity: sha512-JBMGB0oR4lPttOZ5XiUGyvylwLQjt1CPJa6qQ5oM+MBCndfjz2TKKkw0eATlLLcYmq1jBVsNlJ2cD6ns2GR7lA==}
-    engines: {node: '>=16'}
-    dependencies:
-      buffer: 6.0.3
-
-  /@solana/transactions@2.0.0-experimental.21e994f:
-    resolution: {integrity: sha512-DunbTMBzlC7jmTzkFsRm5DhGe+MjaZ8m+SJ7V520mQq+kxrbPrRmI3ikfUVdejg0WaEV4Dy+RwQ5xllsrJ47kA==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers': 0.8.9
-      '@solana/addresses': 2.0.0-experimental.21e994f
-      '@solana/keys': 2.0.0-experimental.21e994f
-    dev: false
-
-  /@solana/web3.js@1.93.0:
-    resolution: {integrity: sha512-suf4VYwWxERz4tKoPpXCRHFRNst7jmcFUaD65kII+zg9urpy5PeeqgLV6G5eWGzcVzA9tZeXOju1A1Y+0ojEVw==}
+  /@solana/web3.js@1.95.4:
+    resolution: {integrity: sha512-sdewnNEA42ZSMxqkzdwEWi6fDgzwtJHaQa5ndUGEJYtoOnM6X5cvPmjoTUp7/k7bRrVAxfBgDnvQQHD6yhlLYw==}
     dependencies:
-      '@babel/runtime': 7.24.7
-      '@noble/curves': 1.4.0
+      '@babel/runtime': 7.25.0
+      '@noble/curves': 1.4.2
       '@noble/hashes': 1.4.0
       '@solana/buffer-layout': 4.0.1
       agentkeepalive: 4.5.0
@@ -2616,36 +1973,42 @@ packages:
       bs58: 4.0.1
       buffer: 6.0.3
       fast-stable-stringify: 1.0.0
-      jayson: 4.1.0
+      jayson: 4.1.1
       node-fetch: 2.7.0
-      rpc-websockets: 9.0.0
-      superstruct: 1.0.4
+      rpc-websockets: 9.0.2
+      superstruct: 2.0.2
     transitivePeerDependencies:
       - bufferutil
       - encoding
       - utf-8-validate
 
-  /@solana/web3.js@2.0.0-experimental.21e994f(node-fetch@2.7.0)(ws@8.14.2):
-    resolution: {integrity: sha512-Yy0D57nlNTDm0BhBRIM85Sn52T6vjxpBRRdwE/FOJJmN92n0Qpc4mTAwOPfEqoVpiTcluUBZ4l8FAWxjGCFMgQ==}
-    dependencies:
-      '@metaplex-foundation/umi-serializers': 0.8.9
-      '@solana/addresses': 2.0.0-experimental.21e994f
-      '@solana/functional': 2.0.0-experimental.21e994f
-      '@solana/instructions': 2.0.0-experimental.21e994f
-      '@solana/keys': 2.0.0-experimental.21e994f
-      '@solana/rpc-core': 2.0.0-experimental.21e994f
-      '@solana/rpc-transport': 2.0.0-experimental.21e994f(node-fetch@2.7.0)(ws@8.14.2)
-      '@solana/transactions': 2.0.0-experimental.21e994f
+  /@solana/web3.js@1.95.5:
+    resolution: {integrity: sha512-hU9cBrbg1z6gEjLH9vwIckGBVB78Ijm0iZFNk4ocm5OD82piPwuk3MeQ1rfiKD9YQtr95krrcaopb49EmQJlRg==}
+    dependencies:
+      '@babel/runtime': 7.25.0
+      '@noble/curves': 1.4.2
+      '@noble/hashes': 1.4.0
+      '@solana/buffer-layout': 4.0.1
+      agentkeepalive: 4.5.0
+      bigint-buffer: 1.1.5
+      bn.js: 5.2.1
+      borsh: 0.7.0
+      bs58: 4.0.1
+      buffer: 6.0.3
       fast-stable-stringify: 1.0.0
+      jayson: 4.1.1
+      node-fetch: 2.7.0
+      rpc-websockets: 9.0.2
+      superstruct: 2.0.2
     transitivePeerDependencies:
-      - node-fetch
-      - ws
-    dev: false
+      - bufferutil
+      - encoding
+      - utf-8-validate
 
   /@swc/helpers@0.5.11:
     resolution: {integrity: sha512-YNlnKRWF2sVojTpIyzwou9XoTNbzbzONwRhOoniEioF1AtaitTvVZblaQRrAzChWQ1bLYyYSWzM18y4WwgzJ+A==}
     dependencies:
-      tslib: 2.6.3
+      tslib: 2.8.1
 
   /@tsconfig/node10@1.0.9:
     resolution: {integrity: sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==}
@@ -2666,8 +2029,8 @@ packages:
   /@types/babel__core@7.20.4:
     resolution: {integrity: sha512-mLnSC22IC4vcWiuObSRjrLd9XcBTGf59vUSoq2jkQDJ/QQ8PMI9rSuzE+aEV8karUMbskw07bKYoUJCKTUaygg==}
     dependencies:
-      '@babel/parser': 7.23.0
-      '@babel/types': 7.23.0
+      '@babel/parser': 7.26.2
+      '@babel/types': 7.26.0
       '@types/babel__generator': 7.6.7
       '@types/babel__template': 7.4.4
       '@types/babel__traverse': 7.20.4
@@ -2676,47 +2039,47 @@ packages:
   /@types/babel__generator@7.6.7:
     resolution: {integrity: sha512-6Sfsq+EaaLrw4RmdFWE9Onp63TOUue71AWb4Gpa6JxzgTYtimbM086WnYTy2U67AofR++QKCo08ZP6pwx8YFHQ==}
     dependencies:
-      '@babel/types': 7.23.0
+      '@babel/types': 7.26.0
     dev: true
 
   /@types/babel__template@7.4.4:
     resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
     dependencies:
-      '@babel/parser': 7.23.0
-      '@babel/types': 7.23.0
+      '@babel/parser': 7.26.2
+      '@babel/types': 7.26.0
     dev: true
 
   /@types/babel__traverse@7.20.4:
     resolution: {integrity: sha512-mSM/iKUk5fDDrEV/e83qY+Cr3I1+Q3qqTuEn++HAWYjEa1+NxZr6CNrcJGf2ZTnq4HoFGC3zaTPZTobCzCFukA==}
     dependencies:
-      '@babel/types': 7.23.0
+      '@babel/types': 7.26.0
     dev: true
 
-  /@types/bn.js@5.1.5:
-    resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==}
+  /@types/bn.js@5.1.6:
+    resolution: {integrity: sha512-Xh8vSwUeMKeYYrj3cX4lGQgFSF/N03r+tv4AiLl1SucqV+uTQpxRcnM8AkXKHwYP9ZPXOYXRr2KPXpVlIvqh9w==}
     dependencies:
-      '@types/node': 20.14.2
+      '@types/node': 22.10.5
     dev: true
 
-  /@types/chai-as-promised@7.1.8:
-    resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==}
+  /@types/chai-as-promised@8.0.1:
+    resolution: {integrity: sha512-dAlDhLjJlABwAVYObo9TPWYTRg9NaQM5CXeaeJYcYAkvzUf0JRLIiog88ao2Wqy/20WUnhbbUZcgvngEbJ3YXQ==}
     dependencies:
-      '@types/chai': 4.3.16
+      '@types/chai': 5.0.1
     dev: true
 
-  /@types/chai@4.3.16:
-    resolution: {integrity: sha512-PatH4iOdyh3MyWtmHVFXLWCCIhUbopaltqddG9BzB+gMIzee2MJrvd+jouii9Z3wzQJruGWAm7WOMjgfG8hQlQ==}
+  /@types/chai@5.0.1:
+    resolution: {integrity: sha512-5T8ajsg3M/FOncpLYW7sdOcD6yf4+722sze/tc4KQV0P8Z2rAr3SAuHCIkYmYpt8VbcQlnz8SxlOlPQYefe4cA==}
+    dependencies:
+      '@types/deep-eql': 4.0.2
     dev: true
 
   /@types/connect@3.4.38:
     resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
     dependencies:
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
 
-  /@types/eslint-plugin-prettier@3.1.3:
-    resolution: {integrity: sha512-Jk+lgBZM0u9ETUyqe2HvykL1j6uE7L1oEqbInWtsVHT6sP+AdwLb4ncmQBqASTS+YzYOPF6hKX0zgEhblRMjqA==}
-    dependencies:
-      '@types/eslint': 8.56.7
+  /@types/deep-eql@4.0.2:
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
     dev: true
 
   /@types/eslint@8.56.7:
@@ -2726,14 +2089,30 @@ packages:
       '@types/json-schema': 7.0.15
     dev: true
 
+  /@types/eslint__js@8.42.3:
+    resolution: {integrity: sha512-alfG737uhmPdnvkrLdZLcEKJ/B8s9Y4hrZ+YAdzUeoArBlSUERA2E87ROfOaS4jd/C45fzOoZzidLc1IPwLqOw==}
+    dependencies:
+      '@types/eslint': 8.56.7
+    dev: true
+
   /@types/estree@1.0.5:
     resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==}
     dev: true
 
+  /@types/estree@1.0.6:
+    resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==}
+    dev: true
+
   /@types/graceful-fs@4.1.9:
     resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==}
     dependencies:
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
+    dev: true
+
+  /@types/hast@3.0.4:
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+    dependencies:
+      '@types/unist': 3.0.3
     dev: true
 
   /@types/istanbul-lib-coverage@2.0.6:
@@ -2752,8 +2131,8 @@ packages:
       '@types/istanbul-lib-report': 3.0.3
     dev: true
 
-  /@types/jest@29.5.12:
-    resolution: {integrity: sha512-eDC8bTvT/QhYdxJAulQikueigY5AsdBRH2yDKW3yveW7svY3+DzN84/2NUgkw10RTiJbWqZrTtoGVdYlvFJdLw==}
+  /@types/jest@29.5.14:
+    resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==}
     dependencies:
       expect: 29.7.0
       pretty-format: 29.7.0
@@ -2767,30 +2146,24 @@ packages:
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
     dev: true
 
-  /@types/mocha@10.0.6:
-    resolution: {integrity: sha512-dJvrYWxP/UcXm36Qn36fxhUKu8A/xMRXVT2cliFF1Z7UA9liG5Psj3ezNSZw+5puH2czDXRLcXQxf8JbJt0ejg==}
+  /@types/mocha@10.0.10:
+    resolution: {integrity: sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==}
     dev: true
 
-  /@types/node-fetch@2.6.11:
-    resolution: {integrity: sha512-24xFj9R5+rfQJLRyM56qh+wnVSYhyXC2tkoBndtY0U+vubqNsYXGjufB2nn8Q6gt0LrARwL6UBtMCSVCwl4B1g==}
+  /@types/node-fetch@2.6.12:
+    resolution: {integrity: sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==}
     dependencies:
-      '@types/node': 20.14.2
+      '@types/node': 22.10.5
       form-data: 4.0.0
     dev: true
 
   /@types/node@12.20.55:
     resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
 
-  /@types/node@20.14.2:
-    resolution: {integrity: sha512-xyu6WAMVwv6AKFLB+e/7ySZVr/0zLCzOa7rSpq6jNwpqOrUbcACDWC+53d4n2QHOnDou0fbIsg8wZu/sxrnI4Q==}
-    dependencies:
-      undici-types: 5.26.5
-    dev: true
-
-  /@types/node@20.14.5:
-    resolution: {integrity: sha512-aoRR+fJkZT2l0aGOJhuA8frnCSoNX6W7U2mpNq63+BxBIj5BQFt8rHy627kijCmm63ijdSdwvGgpUsU6MBsZZA==}
+  /@types/node@22.10.5:
+    resolution: {integrity: sha512-F8Q+SeGimwOo86fiovQh8qiXfFEh2/ocYv7tU5pJ3EXMSSxk1Joj5wefpFK2fHTf/N6HKGSxIDBT9f3gCxXPkQ==}
     dependencies:
-      undici-types: 5.26.5
+      undici-types: 6.20.0
 
   /@types/resolve@1.20.2:
     resolution: {integrity: sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==}
@@ -2804,18 +2177,22 @@ packages:
     resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
     dev: true
 
+  /@types/unist@3.0.3:
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+    dev: true
+
   /@types/uuid@8.3.4:
     resolution: {integrity: sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==}
 
   /@types/ws@7.4.7:
     resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==}
     dependencies:
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
 
   /@types/ws@8.5.10:
     resolution: {integrity: sha512-vmQSUcfalpIq0R9q7uTo2lXs6eGIpt9wtnLdMv9LVpIjCA/+ufZRozlVoVelIYixx1ugCBKDhn89vnsEGOCx9A==}
     dependencies:
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
 
   /@types/yargs-parser@21.0.3:
     resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==}
@@ -2824,116 +2201,175 @@ packages:
   /@types/yargs@17.0.31:
     resolution: {integrity: sha512-bocYSx4DI8TmdlvxqGpVNXOgCNR1Jj0gNPhhAY+iz1rgKDAaYrAYdFYnhDV1IFuiuVc9HkOwyDcFxaTElF3/wg==}
     dependencies:
-      '@types/yargs-parser': 21.0.3
+      '@types/yargs-parser': 21.0.3
+    dev: true
+
+  /@typescript-eslint/eslint-plugin@8.12.2(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-gQxbxM8mcxBwaEmWdtLCIGLfixBMHhQjBqR8sVWNTPpcj45WlYL2IObS/DNMLH1DBP0n8qz+aiiLTGfopPEebw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^8.0.0 || ^8.0.0-alpha.0
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@eslint-community/regexpp': 4.12.1
+      '@typescript-eslint/parser': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/type-utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.12.2
+      eslint: 8.57.0
+      graphemer: 1.4.0
+      ignore: 5.3.1
+      natural-compare: 1.4.0
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
+    transitivePeerDependencies:
+      - supports-color
     dev: true
 
-  /@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-oy9+hTPCUFpngkEZUSzbf9MxI65wbKFoQYsgPdILTfbUldp5ovUuphZVe4i30emU9M/kP+T64Di0mxl7dSw3MA==}
-    engines: {node: ^16.0.0 || >=18.0.0}
+  /@typescript-eslint/eslint-plugin@8.12.2(@typescript-eslint/parser@8.12.2)(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-gQxbxM8mcxBwaEmWdtLCIGLfixBMHhQjBqR8sVWNTPpcj45WlYL2IObS/DNMLH1DBP0n8qz+aiiLTGfopPEebw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
-      eslint: ^7.0.0 || ^8.0.0
+      '@typescript-eslint/parser': ^8.0.0 || ^8.0.0-alpha.0
+      eslint: ^8.57.0 || ^9.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.10.0
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/type-utils': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.3.5
-      eslint: 8.57.0
+      '@eslint-community/regexpp': 4.12.1
+      '@typescript-eslint/parser': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/type-utils': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.12.2
+      eslint: 9.13.0
       graphemer: 1.4.0
       ignore: 5.3.1
       natural-compare: 1.4.0
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/eslint-plugin@7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-kZqi+WZQaZfPKnsflLJQCz6Ze9FFSMfXrrIOcyargekQxG37ES7DJNpJUE9Q/X5n3yTIP/WPutVNzgknQ7biLg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/eslint-plugin@8.4.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-rg8LGdv7ri3oAlenMACk9e+AR4wUV0yrrG+XKsGKOK0EVgeEDqurkXMPILG2836fW4ibokTB5v4b6Z9+GYQDEw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^7.0.0
-      eslint: ^8.56.0
+      '@typescript-eslint/parser': ^8.0.0 || ^8.0.0-alpha.0
+      eslint: ^8.57.0 || ^9.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
       '@eslint-community/regexpp': 4.10.0
-      '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/scope-manager': 7.13.1
-      '@typescript-eslint/type-utils': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/utils': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/visitor-keys': 7.13.1
+      '@typescript-eslint/parser': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/scope-manager': 8.4.0
+      '@typescript-eslint/type-utils': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.4.0
       eslint: 8.57.0
       graphemer: 1.4.0
       ignore: 5.3.1
       natural-compare: 1.4.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/experimental-utils@5.62.0(eslint@8.57.0)(typescript@5.4.5):
+  /@typescript-eslint/experimental-utils@5.62.0(eslint@8.57.0)(typescript@5.7.2):
     resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.7.2)
       eslint: 8.57.0
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/parser@6.21.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==}
-    engines: {node: ^16.0.0 || >=18.0.0}
+  /@typescript-eslint/experimental-utils@5.62.0(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+    dependencies:
+      '@typescript-eslint/utils': 5.62.0(eslint@9.13.0)(typescript@5.7.2)
+      eslint: 9.13.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+    dev: true
+
+  /@typescript-eslint/parser@8.12.2(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-MrvlXNfGPLH3Z+r7Tk+Z5moZAc0dzdVjTgUgwsdGweH7lydysQsnSww3nAmsq8blFuRD5VRlAr9YdEFw3e6PBw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^7.0.0 || ^8.0.0
+      eslint: ^8.57.0 || ^9.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.4.5)
-      '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.3.5
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.12.2
+      debug: 4.3.7(supports-color@8.1.1)
       eslint: 8.57.0
-      typescript: 5.4.5
+      typescript: 5.7.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript-eslint/parser@8.12.2(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-MrvlXNfGPLH3Z+r7Tk+Z5moZAc0dzdVjTgUgwsdGweH7lydysQsnSww3nAmsq8blFuRD5VRlAr9YdEFw3e6PBw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.12.2
+      debug: 4.3.7(supports-color@8.1.1)
+      eslint: 9.13.0
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-1ELDPlnLvDQ5ybTSrMhRTFDfOQEOXNM+eP+3HT/Yq7ruWpciQw+Avi73pdEbA4SooCawEWo3dtYbF68gN7Ed1A==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/parser@8.4.0(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-NHgWmKSgJk5K9N16GIhQ4jSobBoJwrmURaLErad0qlLjrpP5bECYg+wxVTGlGZmJbU03jj/dfnb6V9bw+5icsA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.56.0
+      eslint: ^8.57.0 || ^9.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 7.13.1
-      '@typescript-eslint/types': 7.13.1
-      '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.4.5)
-      '@typescript-eslint/visitor-keys': 7.13.1
-      debug: 4.3.5
+      '@typescript-eslint/scope-manager': 8.4.0
+      '@typescript-eslint/types': 8.4.0
+      '@typescript-eslint/typescript-estree': 8.4.0(typescript@5.7.2)
+      '@typescript-eslint/visitor-keys': 8.4.0
+      debug: 4.3.6
       eslint: 8.57.0
-      typescript: 5.4.5
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -2946,75 +2382,76 @@ packages:
       '@typescript-eslint/visitor-keys': 5.62.0
     dev: true
 
-  /@typescript-eslint/scope-manager@6.21.0:
-    resolution: {integrity: sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dependencies:
-      '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/visitor-keys': 6.21.0
-    dev: true
-
-  /@typescript-eslint/scope-manager@7.12.0:
-    resolution: {integrity: sha512-itF1pTnN6F3unPak+kutH9raIkL3lhH1YRPGgt7QQOh43DQKVJXmWkpb+vpc/TiDHs6RSd9CTbDsc/Y+Ygq7kg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/scope-manager@8.12.2:
+    resolution: {integrity: sha512-gPLpLtrj9aMHOvxJkSbDBmbRuYdtiEbnvO25bCMza3DhMjTQw0u7Y1M+YR5JPbMsXXnSPuCf5hfq0nEkQDL/JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dependencies:
-      '@typescript-eslint/types': 7.12.0
-      '@typescript-eslint/visitor-keys': 7.12.0
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/visitor-keys': 8.12.2
     dev: true
 
-  /@typescript-eslint/scope-manager@7.13.1:
-    resolution: {integrity: sha512-adbXNVEs6GmbzaCpymHQ0MB6E4TqoiVbC0iqG3uijR8ZYfpAXMGttouQzF4Oat3P2GxDVIrg7bMI/P65LiQZdg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/scope-manager@8.4.0:
+    resolution: {integrity: sha512-n2jFxLeY0JmKfUqy3P70rs6vdoPjHK8P/w+zJcV3fk0b0BwRXC/zxRTEnAsgYT7MwdQDt/ZEbtdzdVC+hcpF0A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dependencies:
-      '@typescript-eslint/types': 7.13.1
-      '@typescript-eslint/visitor-keys': 7.13.1
+      '@typescript-eslint/types': 8.4.0
+      '@typescript-eslint/visitor-keys': 8.4.0
     dev: true
 
-  /@typescript-eslint/scope-manager@7.6.0:
-    resolution: {integrity: sha512-ngttyfExA5PsHSx0rdFgnADMYQi+Zkeiv4/ZxGYUWd0nLs63Ha0ksmp8VMxAIC0wtCFxMos7Lt3PszJssG/E6w==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/type-utils@8.12.2(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-bwuU4TAogPI+1q/IJSKuD4shBLc/d2vGcRT588q+jzayQyjVK2X6v/fbR4InY2U2sgf8MEvVCqEWUzYzgBNcGQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
     dependencies:
-      '@typescript-eslint/types': 7.6.0
-      '@typescript-eslint/visitor-keys': 7.6.0
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      debug: 4.4.0
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
+    transitivePeerDependencies:
+      - eslint
+      - supports-color
     dev: true
 
-  /@typescript-eslint/type-utils@6.21.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-rZQI7wHfao8qMX3Rd3xqeYSMCL3SoiSQLBATSiVKARdFGCYSRvmViieZjqc58jKgs8Y8i9YvVVhRbHSTA4VBag==}
-    engines: {node: ^16.0.0 || >=18.0.0}
+  /@typescript-eslint/type-utils@8.12.2(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-bwuU4TAogPI+1q/IJSKuD4shBLc/d2vGcRT588q+jzayQyjVK2X6v/fbR4InY2U2sgf8MEvVCqEWUzYzgBNcGQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.4.5)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
-      debug: 4.3.5
-      eslint: 8.57.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      debug: 4.4.0
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
+      - eslint
       - supports-color
     dev: true
 
-  /@typescript-eslint/type-utils@7.13.1(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-aWDbLu1s9bmgPGXSzNCxELu+0+HQOapV/y+60gPXafR8e2g1Bifxzevaa+4L2ytCWm+CHqpELq4CSoN9ELiwCg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/type-utils@8.4.0(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-pu2PAmNrl9KX6TtirVOrbLPLwDmASpZhK/XU7WvoKoCUkdtq9zF7qQ7gna0GBZFN0hci0vHaSusiL2WpsQk37A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.56.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.4.5)
-      '@typescript-eslint/utils': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      debug: 4.3.5
-      eslint: 8.57.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      '@typescript-eslint/typescript-estree': 8.4.0(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
+      debug: 4.4.0
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
+      - eslint
       - supports-color
     dev: true
 
@@ -3023,27 +2460,17 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
-  /@typescript-eslint/types@6.21.0:
-    resolution: {integrity: sha512-1kFmZ1rOm5epu9NZEZm1kckCDGj5UJEf7P1kliH4LKu/RkwpsfqqGmY2OOcUs18lSlQBKLDYBOGxRVtrMN5lpg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dev: true
-
-  /@typescript-eslint/types@7.12.0:
-    resolution: {integrity: sha512-o+0Te6eWp2ppKY3mLCU+YA9pVJxhUJE15FV7kxuD9jgwIAa+w/ycGJBMrYDTpVGUM/tgpa9SeMOugSabWFq7bg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/types@8.12.2:
+    resolution: {integrity: sha512-VwDwMF1SZ7wPBUZwmMdnDJ6sIFk4K4s+ALKLP6aIQsISkPv8jhiw65sAK6SuWODN/ix+m+HgbYDkH+zLjrzvOA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dev: true
 
-  /@typescript-eslint/types@7.13.1:
-    resolution: {integrity: sha512-7K7HMcSQIAND6RBL4kDl24sG/xKM13cA85dc7JnmQXw2cBDngg7c19B++JzvJHRG3zG36n9j1i451GBzRuHchw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/types@8.4.0:
+    resolution: {integrity: sha512-T1RB3KQdskh9t3v/qv7niK6P8yvn7ja1mS7QK7XfRVL6wtZ8/mFs/FHf4fKvTA0rKnqnYxl/uHFNbnEt0phgbw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dev: true
 
-  /@typescript-eslint/types@7.6.0:
-    resolution: {integrity: sha512-h02rYQn8J+MureCvHVVzhl69/GAfQGPQZmOMjG1KfCl7o3HtMSlPaPUAPu6lLctXI5ySRGIYk94clD/AUMCUgQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    dev: true
-
-  /@typescript-eslint/typescript-estree@5.62.0(typescript@5.4.5):
+  /@typescript-eslint/typescript-estree@5.62.0(typescript@5.7.2):
     resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
@@ -3054,105 +2481,61 @@ packages:
     dependencies:
       '@typescript-eslint/types': 5.62.0
       '@typescript-eslint/visitor-keys': 5.62.0
-      debug: 4.3.5
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.6.0
-      tsutils: 3.21.0(typescript@5.4.5)
-      typescript: 5.4.5
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/typescript-estree@6.21.0(typescript@5.4.5):
-    resolution: {integrity: sha512-6npJTkZcO+y2/kr+z0hc4HwNfrrP4kNYh57ek7yCNlrBjWQ1Y0OS7jiZTkgumrvkX5HkEKXFZkkdFNkaW2wmUQ==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.3.5
-      globby: 11.1.0
-      is-glob: 4.0.3
-      minimatch: 9.0.3
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/typescript-estree@7.12.0(typescript@5.4.5):
-    resolution: {integrity: sha512-5bwqLsWBULv1h6pn7cMW5dXX/Y2amRqLaKqsASVwbBHMZSnHqE/HN4vT4fE0aFsiwxYvr98kqOWh1a8ZKXalCQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 7.12.0
-      '@typescript-eslint/visitor-keys': 7.12.0
-      debug: 4.3.5
+      debug: 4.4.0
       globby: 11.1.0
       is-glob: 4.0.3
-      minimatch: 9.0.4
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      semver: 7.6.3
+      tsutils: 3.21.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/typescript-estree@7.13.1(typescript@5.4.5):
-    resolution: {integrity: sha512-uxNr51CMV7npU1BxZzYjoVz9iyjckBduFBP0S5sLlh1tXYzHzgZ3BR9SVsNed+LmwKrmnqN3Kdl5t7eZ5TS1Yw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/typescript-estree@8.12.2(typescript@5.7.2):
+    resolution: {integrity: sha512-mME5MDwGe30Pq9zKPvyduyU86PH7aixwqYR2grTglAdB+AN8xXQ1vFGpYaUSJ5o5P/5znsSBeNcs5g5/2aQwow==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 7.13.1
-      '@typescript-eslint/visitor-keys': 7.13.1
-      debug: 4.3.5
-      globby: 11.1.0
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/visitor-keys': 8.12.2
+      debug: 4.4.0
+      fast-glob: 3.3.2
       is-glob: 4.0.3
-      minimatch: 9.0.4
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      minimatch: 9.0.5
+      semver: 7.6.3
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/typescript-estree@7.6.0(typescript@5.4.5):
-    resolution: {integrity: sha512-+7Y/GP9VuYibecrCQWSKgl3GvUM5cILRttpWtnAu8GNL9j11e4tbuGZmZjJ8ejnKYyBRb2ddGQ3rEFCq3QjMJw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/typescript-estree@8.4.0(typescript@5.7.2):
+    resolution: {integrity: sha512-kJ2OIP4dQw5gdI4uXsaxUZHRwWAGpREJ9Zq6D5L0BweyOrWsL6Sz0YcAZGWhvKnH7fm1J5YFE1JrQL0c9dd53A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 7.6.0
-      '@typescript-eslint/visitor-keys': 7.6.0
-      debug: 4.3.5
-      globby: 11.1.0
+      '@typescript-eslint/types': 8.4.0
+      '@typescript-eslint/visitor-keys': 8.4.0
+      debug: 4.4.0
+      fast-glob: 3.3.2
       is-glob: 4.0.3
-      minimatch: 9.0.4
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      minimatch: 9.0.5
+      semver: 7.6.3
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.4.5):
+  /@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.7.2):
     resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
@@ -3163,80 +2546,78 @@ packages:
       '@types/semver': 7.5.8
       '@typescript-eslint/scope-manager': 5.62.0
       '@typescript-eslint/types': 5.62.0
-      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.4.5)
+      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.7.2)
       eslint: 8.57.0
       eslint-scope: 5.1.1
-      semver: 7.6.0
+      semver: 7.6.3
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@6.21.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-NfWVaC8HP9T8cbKQxHcsJBY5YE1O33+jpMwN45qzWWaPDZgLIbo12toGMWnmhvCpd3sIxkpDw3Wv1B3dYrbDQQ==}
-    engines: {node: ^16.0.0 || >=18.0.0}
+  /@typescript-eslint/utils@5.62.0(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
-      eslint: ^7.0.0 || ^8.0.0
+      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
+      '@eslint-community/eslint-utils': 4.4.0(eslint@9.13.0)
       '@types/json-schema': 7.0.15
       '@types/semver': 7.5.8
-      '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.4.5)
-      eslint: 8.57.0
-      semver: 7.6.0
+      '@typescript-eslint/scope-manager': 5.62.0
+      '@typescript-eslint/types': 5.62.0
+      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.7.2)
+      eslint: 9.13.0
+      eslint-scope: 5.1.1
+      semver: 7.6.3
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@7.12.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-Y6hhwxwDx41HNpjuYswYp6gDbkiZ8Hin9Bf5aJQn1bpTs3afYY4GX+MPYxma8jtoIV2GRwTM/UJm/2uGCVv+DQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/utils@8.12.2(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-UTTuDIX3fkfAz6iSVa5rTuSfWIYZ6ATtEocQ/umkRSyC9O919lbZ8dcH7mysshrCdrAM03skJOEYaBugxN+M6A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.56.0
+      eslint: ^8.57.0 || ^9.0.0
     dependencies:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
-      '@typescript-eslint/scope-manager': 7.12.0
-      '@typescript-eslint/types': 7.12.0
-      '@typescript-eslint/typescript-estree': 7.12.0(typescript@5.4.5)
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
       eslint: 8.57.0
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@7.13.1(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-h5MzFBD5a/Gh/fvNdp9pTfqJAbuQC4sCN2WzuXme71lqFJsZtLbjxfSk4r3p02WIArOF9N94pdsLiGutpDbrXQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/utils@8.12.2(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-UTTuDIX3fkfAz6iSVa5rTuSfWIYZ6ATtEocQ/umkRSyC9O919lbZ8dcH7mysshrCdrAM03skJOEYaBugxN+M6A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.56.0
+      eslint: ^8.57.0 || ^9.0.0
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
-      '@typescript-eslint/scope-manager': 7.13.1
-      '@typescript-eslint/types': 7.13.1
-      '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.4.5)
-      eslint: 8.57.0
+      '@eslint-community/eslint-utils': 4.4.0(eslint@9.13.0)
+      '@typescript-eslint/scope-manager': 8.12.2
+      '@typescript-eslint/types': 8.12.2
+      '@typescript-eslint/typescript-estree': 8.12.2(typescript@5.7.2)
+      eslint: 9.13.0
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@7.6.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-x54gaSsRRI+Nwz59TXpCsr6harB98qjXYzsRxGqvA5Ue3kQH+FxS7FYU81g/omn22ML2pZJkisy6Q+ElK8pBCA==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/utils@8.4.0(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-swULW8n1IKLjRAgciCkTCafyTHHfwVQFt8DovmaF69sKbOxTSFMmIZaSHjqO9i/RV0wIblaawhzvtva8Nmm7lQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      eslint: ^8.56.0
+      eslint: ^8.57.0 || ^9.0.0
     dependencies:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
-      '@types/json-schema': 7.0.15
-      '@types/semver': 7.5.8
-      '@typescript-eslint/scope-manager': 7.6.0
-      '@typescript-eslint/types': 7.6.0
-      '@typescript-eslint/typescript-estree': 7.6.0(typescript@5.4.5)
+      '@typescript-eslint/scope-manager': 8.4.0
+      '@typescript-eslint/types': 8.4.0
+      '@typescript-eslint/typescript-estree': 8.4.0(typescript@5.7.2)
       eslint: 8.57.0
-      semver: 7.6.0
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -3250,35 +2631,19 @@ packages:
       eslint-visitor-keys: 3.4.3
     dev: true
 
-  /@typescript-eslint/visitor-keys@6.21.0:
-    resolution: {integrity: sha512-JJtkDduxLi9bivAB+cYOVMtbkqdPOhZ+ZI5LC47MIRrDV4Yn2o+ZnW10Nkmr28xRpSpdJ6Sm42Hjf2+REYXm0A==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    dependencies:
-      '@typescript-eslint/types': 6.21.0
-      eslint-visitor-keys: 3.4.3
-    dev: true
-
-  /@typescript-eslint/visitor-keys@7.12.0:
-    resolution: {integrity: sha512-uZk7DevrQLL3vSnfFl5bj4sL75qC9D6EdjemIdbtkuUmIheWpuiiylSY01JxJE7+zGrOWDZrp1WxOuDntvKrHQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    dependencies:
-      '@typescript-eslint/types': 7.12.0
-      eslint-visitor-keys: 3.4.3
-    dev: true
-
-  /@typescript-eslint/visitor-keys@7.13.1:
-    resolution: {integrity: sha512-k/Bfne7lrP7hcb7m9zSsgcBmo+8eicqqfNAJ7uUY+jkTFpKeH2FSkWpFRtimBxgkyvqfu9jTPRbYOvud6isdXA==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/visitor-keys@8.12.2:
+    resolution: {integrity: sha512-PChz8UaKQAVNHghsHcPyx1OMHoFRUEA7rJSK/mDhdq85bk+PLsUHUBqTQTFt18VJZbmxBovM65fezlheQRsSDA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dependencies:
-      '@typescript-eslint/types': 7.13.1
+      '@typescript-eslint/types': 8.12.2
       eslint-visitor-keys: 3.4.3
     dev: true
 
-  /@typescript-eslint/visitor-keys@7.6.0:
-    resolution: {integrity: sha512-4eLB7t+LlNUmXzfOu1VAIAdkjbu5xNSerURS9X/S5TUKWFRpXRQZbmtPqgKmYx8bj3J0irtQXSiWAOY82v+cgw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  /@typescript-eslint/visitor-keys@8.4.0:
+    resolution: {integrity: sha512-zTQD6WLNTre1hj5wp09nBIDiOc2U5r/qmzo7wxPn4ZgAjHql09EofqhF9WF+fZHzL5aCyaIpPcT2hyxl73kr9A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     dependencies:
-      '@typescript-eslint/types': 7.6.0
+      '@typescript-eslint/types': 8.4.0
       eslint-visitor-keys: 3.4.3
     dev: true
 
@@ -3286,28 +2651,6 @@ packages:
     resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==}
     dev: true
 
-  /@vercel/nft@0.26.2:
-    resolution: {integrity: sha512-bxe2iShmKZi7476xYamyKvhhKwQ6JPEtQ2FSq1AjMUH2buMd8LQMkdoHinTqZYc+1sMTh3G0ARdjzNvV1FEisA==}
-    engines: {node: '>=16'}
-    hasBin: true
-    dependencies:
-      '@mapbox/node-pre-gyp': 1.0.11
-      '@rollup/pluginutils': 4.2.1
-      acorn: 8.11.3
-      acorn-import-attributes: 1.9.2(acorn@8.11.3)
-      async-sema: 3.1.1
-      bindings: 1.5.0
-      estree-walker: 2.0.2
-      glob: 7.2.3
-      graceful-fs: 4.2.11
-      micromatch: 4.0.5
-      node-gyp-build: 4.6.1
-      resolve-from: 5.0.0
-    transitivePeerDependencies:
-      - encoding
-      - supports-color
-    dev: true
-
   /JSONStream@1.3.5:
     resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==}
     hasBin: true
@@ -3315,18 +2658,6 @@ packages:
       jsonparse: 1.3.1
       through: 2.3.8
 
-  /abbrev@1.1.1:
-    resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
-    dev: true
-
-  /acorn-import-attributes@1.9.2(acorn@8.11.3):
-    resolution: {integrity: sha512-O+nfJwNolEA771IYJaiLWK1UAwjNsQmZbTRqqwBYxCgVQTmpFEMvBw6LOIQV0Me339L5UMVYFyRohGnGlQDdIQ==}
-    peerDependencies:
-      acorn: ^8
-    dependencies:
-      acorn: 8.11.3
-    dev: true
-
   /acorn-jsx@5.3.2(acorn@7.4.1):
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -3343,14 +2674,19 @@ packages:
       acorn: 8.11.3
     dev: true
 
-  /acorn-walk@8.3.0:
-    resolution: {integrity: sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==}
-    engines: {node: '>=0.4.0'}
+  /acorn-jsx@5.3.2(acorn@8.14.0):
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+    dependencies:
+      acorn: 8.14.0
     dev: true
 
-  /acorn-walk@8.3.2:
-    resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==}
+  /acorn-walk@8.3.4:
+    resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}
     engines: {node: '>=0.4.0'}
+    dependencies:
+      acorn: 8.14.0
     dev: true
 
   /acorn@7.4.1:
@@ -3359,25 +2695,16 @@ packages:
     hasBin: true
     dev: true
 
-  /acorn@8.11.2:
-    resolution: {integrity: sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==}
-    engines: {node: '>=0.4.0'}
-    hasBin: true
-    dev: true
-
   /acorn@8.11.3:
     resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==}
     engines: {node: '>=0.4.0'}
     hasBin: true
     dev: true
 
-  /agent-base@6.0.2:
-    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
-    engines: {node: '>= 6.0.0'}
-    dependencies:
-      debug: 4.3.5
-    transitivePeerDependencies:
-      - supports-color
+  /acorn@8.14.0:
+    resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
     dev: true
 
   /agentkeepalive@4.5.0:
@@ -3395,11 +2722,6 @@ packages:
       uri-js: 4.4.1
     dev: true
 
-  /ansi-colors@4.1.1:
-    resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==}
-    engines: {node: '>=6'}
-    dev: true
-
   /ansi-colors@4.1.3:
     resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
     engines: {node: '>=6'}
@@ -3422,17 +2744,6 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /ansi-sequence-parser@1.1.1:
-    resolution: {integrity: sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==}
-    dev: true
-
-  /ansi-styles@3.2.1:
-    resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
-    engines: {node: '>=4'}
-    dependencies:
-      color-convert: 1.9.3
-    dev: true
-
   /ansi-styles@4.3.0:
     resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
     engines: {node: '>=8'}
@@ -3461,18 +2772,6 @@ packages:
       picomatch: 2.3.1
     dev: true
 
-  /aproba@2.0.0:
-    resolution: {integrity: sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==}
-    dev: true
-
-  /are-we-there-yet@2.0.0:
-    resolution: {integrity: sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==}
-    engines: {node: '>=10'}
-    dependencies:
-      delegates: 1.0.0
-      readable-stream: 3.6.2
-    dev: true
-
   /arg@4.1.3:
     resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
     dev: true
@@ -3491,64 +2790,50 @@ packages:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
     dev: true
 
-  /array-buffer-byte-length@1.0.0:
-    resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==}
+  /array-buffer-byte-length@1.0.1:
+    resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      is-array-buffer: 3.0.2
+      call-bind: 1.0.7
+      is-array-buffer: 3.0.4
     dev: true
 
-  /array-find-index@1.0.2:
-    resolution: {integrity: sha512-M1HQyIXcBGtVywBt8WVdim+lrNaK7VHp99Qt5pSNziXznKHViIBbXWtfRTpEFpF/c4FdfxNAsCCwPp5phBYJtw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /array-includes@3.1.7:
-    resolution: {integrity: sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==}
+  /array-includes@3.1.8:
+    resolution: {integrity: sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
-      get-intrinsic: 1.2.2
+      es-abstract: 1.23.3
+      es-object-atoms: 1.0.0
+      get-intrinsic: 1.2.4
       is-string: 1.0.7
     dev: true
 
-  /array-union@1.0.2:
-    resolution: {integrity: sha512-Dxr6QJj/RdU/hCaBjOfxW+q6lyuVE6JFWIrAUpuOOhoJJoQ99cUn3igRaHVB5P9WrgFVN0FfArM3x0cueOU8ng==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      array-uniq: 1.0.3
-    dev: true
-
   /array-union@2.1.0:
     resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
     engines: {node: '>=8'}
     dev: true
 
-  /array-uniq@1.0.3:
-    resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /array.prototype.findlastindex@1.2.3:
-    resolution: {integrity: sha512-LzLoiOMAxvy+Gd3BAq3B7VeIgPdo+Q8hthvKtXybMvRV0jrXfJM/t8mw7nNlpEcVlVUnCnM2KSX4XU5HmpodOA==}
+  /array.prototype.findlastindex@1.2.5:
+    resolution: {integrity: sha512-zfETvRFA8o7EiNn++N5f/kaCw221hrpGsDmcpndVupkPzEc1Wuf3VgC0qby1BbHs7f5DVYjgtEU2LLh5bqeGfQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
+      es-errors: 1.3.0
+      es-object-atoms: 1.0.0
       es-shim-unscopables: 1.0.2
-      get-intrinsic: 1.2.2
     dev: true
 
   /array.prototype.flat@1.3.2:
     resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
       es-shim-unscopables: 1.0.2
     dev: true
 
@@ -3556,53 +2841,35 @@ packages:
     resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
       es-shim-unscopables: 1.0.2
     dev: true
 
-  /arraybuffer.prototype.slice@1.0.2:
-    resolution: {integrity: sha512-yMBKppFur/fbHu9/6USUe03bZ4knMYiwFBcyiaXB8Go0qNehwX6inYPzK9U0NeQvGxKthcmHcaR8P5MStSRBAw==}
+  /arraybuffer.prototype.slice@1.0.3:
+    resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==}
     engines: {node: '>= 0.4'}
     dependencies:
-      array-buffer-byte-length: 1.0.0
-      call-bind: 1.0.5
+      array-buffer-byte-length: 1.0.1
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
-      get-intrinsic: 1.2.2
-      is-array-buffer: 3.0.2
-      is-shared-array-buffer: 1.0.2
-    dev: true
-
-  /arrgv@1.0.2:
-    resolution: {integrity: sha512-a4eg4yhp7mmruZDQFqVMlxNRFGi/i1r87pt8SDHy0/I8PqSXoUTlWZRdAZo0VXgvEARcujbtTk8kiZRi1uDGRw==}
-    engines: {node: '>=8.0.0'}
-    dev: true
-
-  /arrify@3.0.0:
-    resolution: {integrity: sha512-tLkvA81vQG/XqE2mjDkGQHoOINtMHtysSnemrmoGe6PydDPMRbVugqyk4A6V/WDWEfm3l+0d8anA9r8cv/5Jaw==}
-    engines: {node: '>=12'}
+      es-abstract: 1.23.3
+      es-errors: 1.3.0
+      get-intrinsic: 1.2.4
+      is-array-buffer: 3.0.4
+      is-shared-array-buffer: 1.0.3
     dev: true
 
   /assert@2.1.0:
     resolution: {integrity: sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       is-nan: 1.3.2
-      object-is: 1.1.5
-      object.assign: 4.1.4
+      object-is: 1.1.6
+      object.assign: 4.1.5
       util: 0.12.5
 
-  /assertion-error@2.0.1:
-    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
-    engines: {node: '>=12'}
-    dev: true
-
-  /async-sema@3.1.1:
-    resolution: {integrity: sha512-tLRNUXati5MFePdAk8dw7Qt7DpxPB60ofAgn8WRhW6a2rcimZnYBP9oxHiv0OHy+Wz7kPMG+t4LGdt31+4EmGg==}
-    dev: true
-
   /async@3.2.5:
     resolution: {integrity: sha512-baNZyqaaLhyLVKm/DlvdW051MSgO6b8eVfIezl9E5PqWxFgzLm/wQntEW4zOytVburDEr0JlALEpdOFwvErLsg==}
     dev: true
@@ -3611,87 +2878,51 @@ packages:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
     dev: true
 
-  /ava@6.1.3(@ava/typescript@5.0.0):
-    resolution: {integrity: sha512-tkKbpF1pIiC+q09wNU9OfyTDYZa8yuWvU2up3+lFJ3lr1RmnYh2GBpPwzYUEB0wvTPIUysGjcZLNZr7STDviRA==}
-    engines: {node: ^18.18 || ^20.8 || ^21 || ^22}
-    hasBin: true
-    peerDependencies:
-      '@ava/typescript': '*'
-    peerDependenciesMeta:
-      '@ava/typescript':
-        optional: true
-    dependencies:
-      '@ava/typescript': 5.0.0
-      '@vercel/nft': 0.26.2
-      acorn: 8.11.3
-      acorn-walk: 8.3.2
-      ansi-styles: 6.2.1
-      arrgv: 1.0.2
-      arrify: 3.0.0
-      callsites: 4.1.0
-      cbor: 9.0.1
-      chalk: 5.3.0
-      chunkd: 2.0.1
-      ci-info: 4.0.0
-      ci-parallel-vars: 1.0.1
-      cli-truncate: 4.0.0
-      code-excerpt: 4.0.0
-      common-path-prefix: 3.0.0
-      concordance: 5.0.4
-      currently-unhandled: 0.4.1
-      debug: 4.3.4(supports-color@8.1.1)
-      emittery: 1.0.1
-      figures: 6.0.1
-      globby: 14.0.0
-      ignore-by-default: 2.1.0
-      indent-string: 5.0.0
-      is-plain-object: 5.0.0
-      is-promise: 4.0.0
-      matcher: 5.0.0
-      memoize: 10.0.0
-      ms: 2.1.3
-      p-map: 7.0.1
-      package-config: 5.0.0
-      picomatch: 3.0.1
-      plur: 5.1.0
-      pretty-ms: 9.0.0
-      resolve-cwd: 3.0.0
-      stack-utils: 2.0.6
-      strip-ansi: 7.1.0
-      supertap: 3.0.1
-      temp-dir: 3.0.0
-      write-file-atomic: 5.0.1
-      yargs: 17.7.2
-    transitivePeerDependencies:
-      - encoding
-      - supports-color
-    dev: true
-
-  /available-typed-arrays@1.0.5:
-    resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==}
+  /available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
+    dependencies:
+      possible-typed-array-names: 1.0.0
 
-  /axios@1.6.2(debug@4.3.5):
-    resolution: {integrity: sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==}
+  /axios@1.7.7(debug@4.4.0):
+    resolution: {integrity: sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==}
     dependencies:
-      follow-redirects: 1.15.3(debug@4.3.5)
+      follow-redirects: 1.15.9(debug@4.4.0)
       form-data: 4.0.0
       proxy-from-env: 1.1.0
     transitivePeerDependencies:
       - debug
     dev: true
 
-  /babel-jest@29.7.0(@babel/core@7.23.2):
+  /babel-jest@29.7.0(@babel/core@7.26.0):
     resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     peerDependencies:
       '@babel/core': ^7.8.0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@jest/transform': 29.7.0
       '@types/babel__core': 7.20.4
       babel-plugin-istanbul: 6.1.1
-      babel-preset-jest: 29.6.3(@babel/core@7.23.2)
+      babel-preset-jest: 29.6.3(@babel/core@7.26.0)
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      slash: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-jest@30.0.0-alpha.6(@babel/core@7.26.0):
+    resolution: {integrity: sha512-WOQkqpBz2q8d/AT6D6rZXW5xnKHDmk3kIukaXlzUyoBBIvLh1SEvi2RGS4fboEtS0kNkyL+zf1rSfkt5OCIgmw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    peerDependencies:
+      '@babel/core': ^7.11.0
+    dependencies:
+      '@babel/core': 7.26.0
+      '@jest/transform': 30.0.0-alpha.6
+      '@types/babel__core': 7.20.4
+      babel-plugin-istanbul: 7.0.0
+      babel-preset-jest: 30.0.0-alpha.6(@babel/core@7.26.0)
       chalk: 4.1.2
       graceful-fs: 4.2.11
       slash: 3.0.0
@@ -3712,45 +2943,78 @@ packages:
       - supports-color
     dev: true
 
+  /babel-plugin-istanbul@7.0.0:
+    resolution: {integrity: sha512-C5OzENSx/A+gt7t4VH1I2XsflxyPUmXRFPKBxt33xncdOmq7oROVM3bZv9Ysjjkv8OJYDMa+tKuKMvqU/H3xdw==}
+    engines: {node: '>=12'}
+    dependencies:
+      '@babel/helper-plugin-utils': 7.22.5
+      '@istanbuljs/load-nyc-config': 1.1.0
+      '@istanbuljs/schema': 0.1.3
+      istanbul-lib-instrument: 6.0.3
+      test-exclude: 6.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /babel-plugin-jest-hoist@29.6.3:
     resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@babel/template': 7.22.15
-      '@babel/types': 7.23.0
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.0
       '@types/babel__core': 7.20.4
       '@types/babel__traverse': 7.20.4
     dev: true
 
-  /babel-preset-current-node-syntax@1.0.1(@babel/core@7.23.2):
+  /babel-plugin-jest-hoist@30.0.0-alpha.6:
+    resolution: {integrity: sha512-e/aPv0pmnvJqXM5SfCBpyMwZFEZrKW1Mb4unwTkxewk6/0TjwBk6l3B3F9H9OKZ3ErhkH4b+Epd3IIM5E53I2g==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@babel/template': 7.25.9
+      '@babel/types': 7.26.0
+      '@types/babel__core': 7.20.4
+    dev: true
+
+  /babel-preset-current-node-syntax@1.0.1(@babel/core@7.26.0):
     resolution: {integrity: sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
-      '@babel/core': 7.23.2
-      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.23.2)
-      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.23.2)
-      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.23.2)
-      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.23.2)
-      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.23.2)
-      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.23.2)
-    dev: true
-
-  /babel-preset-jest@29.6.3(@babel/core@7.23.2):
+      '@babel/core': 7.26.0
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.26.0)
+      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.26.0)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.26.0)
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.26.0)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.26.0)
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.26.0)
+      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.26.0)
+    dev: true
+
+  /babel-preset-jest@29.6.3(@babel/core@7.26.0):
     resolution: {integrity: sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       babel-plugin-jest-hoist: 29.6.3
-      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.23.2)
+      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.26.0)
+    dev: true
+
+  /babel-preset-jest@30.0.0-alpha.6(@babel/core@7.26.0):
+    resolution: {integrity: sha512-Xsis7RI2oT2zlyCIEzMtjDiES0wKoQxTUo5BGzx1q3ZemnDE1/7xTC4/lI4eBLmAtwk/hpZLRYwltvbQEvyRWw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    peerDependencies:
+      '@babel/core': ^7.11.0
+    dependencies:
+      '@babel/core': 7.26.0
+      babel-plugin-jest-hoist: 30.0.0-alpha.6
+      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.26.0)
     dev: true
 
   /balanced-match@1.0.2:
@@ -3768,11 +3032,6 @@ packages:
   /base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
-  /big-integer@1.6.51:
-    resolution: {integrity: sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==}
-    engines: {node: '>=0.6'}
-    dev: true
-
   /bigint-buffer@1.1.5:
     resolution: {integrity: sha512-trfYco6AoZ+rKhKnxA0hgX0HAbVP/s808/EuDSe2JDzUnCp/xAsli35Orvk67UrTEcwuxZqYZDmfA2RXJgxVvA==}
     engines: {node: '>= 10.0.0'}
@@ -3797,10 +3056,6 @@ packages:
     resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==}
     dev: true
 
-  /blueimp-md5@2.19.0:
-    resolution: {integrity: sha512-DRQrD6gJyy8FbiE4s+bDoXS9hiW3Vbx5uCdwvcCf3zLHL+Iv7LtGHLpr+GZV8rHG8tK766FGYBwRbu8pELTt+w==}
-    dev: true
-
   /bn.js@5.2.1:
     resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==}
 
@@ -3815,13 +3070,6 @@ packages:
     resolution: {integrity: sha512-kc9+BgR3zz9+cjbwM8ODoUB4fs3X3I5A/HtX7LZKxCLaMrEeDFoBpnhZY//DTS1VZBSs6S5v46RZRbZjRFspEg==}
     dev: false
 
-  /bplist-parser@0.2.0:
-    resolution: {integrity: sha512-z0M+byMThzQmD9NILRniCUXYsYpjwnlO8N5uCFaCqIOpqRsJCrQL9NK3JsD67CN5a08nF5oIL2bD6loTdHOuKw==}
-    engines: {node: '>= 5.10.0'}
-    dependencies:
-      big-integer: 1.6.51
-    dev: true
-
   /brace-expansion@1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
     dependencies:
@@ -3835,26 +3083,26 @@ packages:
       balanced-match: 1.0.2
     dev: true
 
-  /braces@3.0.2:
-    resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
+  /braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
     dependencies:
-      fill-range: 7.0.1
+      fill-range: 7.1.1
     dev: true
 
   /browser-stdout@1.3.1:
     resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
     dev: true
 
-  /browserslist@4.22.1:
-    resolution: {integrity: sha512-FEVc202+2iuClEhZhrWy6ZiAcRLvNMyYcxZ8raemul1DYVOVdFsbqckWLdsixQZCpJlwe77Z3UTalE7jsjnKfQ==}
+  /browserslist@4.24.2:
+    resolution: {integrity: sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
     dependencies:
-      caniuse-lite: 1.0.30001561
-      electron-to-chromium: 1.4.578
-      node-releases: 2.0.13
-      update-browserslist-db: 1.0.13(browserslist@4.22.1)
+      caniuse-lite: 1.0.30001676
+      electron-to-chromium: 1.5.50
+      node-releases: 2.0.18
+      update-browserslist-db: 1.1.1(browserslist@4.24.2)
     dev: true
 
   /bs-logger@0.2.6:
@@ -3887,6 +3135,7 @@ packages:
   /buffer-layout@1.2.2:
     resolution: {integrity: sha512-kWSuLN694+KTk8SrYvCqwP2WcgQjoRCiF5b4QDvkkz8EmgD+aWAIceGFKMIAdmF/pH+vpgNV3d3kAKorcdAmWA==}
     engines: {node: '>=4.5'}
+    dev: true
 
   /buffer@6.0.3:
     resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
@@ -3901,83 +3150,33 @@ packages:
     dependencies:
       node-gyp-build: 4.6.1
 
-  /builtin-modules@3.3.0:
-    resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
-    engines: {node: '>=6'}
-    dev: true
-
-  /bundle-name@3.0.0:
-    resolution: {integrity: sha512-PKA4BeSvBpQKQ8iPOGCSiell+N8P+Tf1DlwqmYhpe2gAhKPHn8EYOxVT+ShuGmhg8lN8XiSlS80yiExKXrURlw==}
-    engines: {node: '>=12'}
-    dependencies:
-      run-applescript: 5.0.0
-    dev: true
-
-  /call-bind@1.0.5:
-    resolution: {integrity: sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==}
+  /call-bind@1.0.7:
+    resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==}
+    engines: {node: '>= 0.4'}
     dependencies:
+      es-define-property: 1.0.0
+      es-errors: 1.3.0
       function-bind: 1.1.2
-      get-intrinsic: 1.2.2
-      set-function-length: 1.1.1
+      get-intrinsic: 1.2.4
+      set-function-length: 1.2.2
 
   /callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
     dev: true
 
-  /callsites@4.1.0:
-    resolution: {integrity: sha512-aBMbD1Xxay75ViYezwT40aQONfr+pSXTHwNKvIXhXD6+LY3F1dLIcceoC5OZKBVHbXcysz1hL9D2w0JJIMXpUw==}
-    engines: {node: '>=12.20'}
-    dev: true
-
   /camelcase@5.3.1:
     resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
     engines: {node: '>=6'}
     dev: true
 
-  /camelcase@6.3.0:
-    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /caniuse-lite@1.0.30001561:
-    resolution: {integrity: sha512-NTt0DNoKe958Q0BE0j0c1V9jbUzhBxHIEJy7asmGrpE0yG63KTV7PLHPnK2E1O9RsQrQ081I3NLuXGS6zht3cw==}
-    dev: true
-
-  /cbor@9.0.1:
-    resolution: {integrity: sha512-/TQOWyamDxvVIv+DY9cOLNuABkoyz8K/F3QE56539pGVYohx0+MEA1f4lChFTX79dBTBS7R1PF6ovH7G+VtBfQ==}
-    engines: {node: '>=16'}
-    dependencies:
-      nofilter: 3.1.0
-    dev: true
-
-  /chai-as-promised@8.0.0(chai@5.1.1):
-    resolution: {integrity: sha512-sMsGXTrS3FunP/wbqh/KxM8Kj/aLPXQGkNtvE5wPfSToq8wkkvBpTZo1LIiEVmC4BwkKpag+l5h/20lBMk6nUg==}
-    peerDependencies:
-      chai: '>= 2.1.2 < 6'
-    dependencies:
-      chai: 5.1.1
-      check-error: 2.1.1
-    dev: true
-
-  /chai@5.1.1:
-    resolution: {integrity: sha512-pT1ZgP8rPNqUgieVaEY+ryQr6Q4HXNg8Ei9UnLUrjN4IA7dvQC5JB+/kxVcPNDHyBcc/26CXPkbNzq3qwrOEKA==}
-    engines: {node: '>=12'}
-    dependencies:
-      assertion-error: 2.0.1
-      check-error: 2.1.1
-      deep-eql: 5.0.1
-      loupe: 3.1.0
-      pathval: 2.0.0
+  /camelcase@6.3.0:
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
     dev: true
 
-  /chalk@2.4.2:
-    resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
-    engines: {node: '>=4'}
-    dependencies:
-      ansi-styles: 3.2.1
-      escape-string-regexp: 1.0.5
-      supports-color: 5.5.0
+  /caniuse-lite@1.0.30001676:
+    resolution: {integrity: sha512-Qz6zwGCiPghQXGJvgQAem79esjitvJ+CxSbSQkW9H/UX5hg8XM88d4lp2W+MEQ81j+Hip58Il+jGVdazk1z9cw==}
     dev: true
 
   /chalk@4.1.2:
@@ -3991,17 +3190,13 @@ packages:
   /chalk@5.3.0:
     resolution: {integrity: sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==}
     engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+    dev: true
 
   /char-regex@1.0.2:
     resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==}
     engines: {node: '>=10'}
     dev: true
 
-  /check-error@2.1.1:
-    resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==}
-    engines: {node: '>= 16'}
-    dev: true
-
   /check-more-types@2.24.0:
     resolution: {integrity: sha512-Pj779qHxV2tuapviy1bSZNEL1maXr13bPYpsvSDB68HlYcYuhlDrmGd63i0JHMCLKzc7rUSNIrpdJlhVlNwrxA==}
     engines: {node: '>= 0.8.0'}
@@ -4012,7 +3207,7 @@ packages:
     engines: {node: '>= 8.10.0'}
     dependencies:
       anymatch: 3.1.3
-      braces: 3.0.2
+      braces: 3.0.3
       glob-parent: 5.1.2
       is-binary-path: 2.1.0
       is-glob: 4.0.3
@@ -4022,15 +3217,6 @@ packages:
       fsevents: 2.3.3
     dev: true
 
-  /chownr@2.0.0:
-    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /chunkd@2.0.1:
-    resolution: {integrity: sha512-7d58XsFmOq0j6el67Ug9mHf9ELUXsQXYJBkyxhH/k+6Ke0qXRnv0kbemx+Twc6fRJ07C49lcbdgm9FL1Ei/6SQ==}
-    dev: true
-
   /ci-info@3.9.0:
     resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
     engines: {node: '>=8'}
@@ -4041,22 +3227,10 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /ci-parallel-vars@1.0.1:
-    resolution: {integrity: sha512-uvzpYrpmidaoxvIQHM+rKSrigjOe9feHYbw4uOI2gdfe1C3xIlxO+kVXq83WQWNniTf8bAxVpy+cQeFQsMERKg==}
-    dev: true
-
   /cjs-module-lexer@1.2.3:
     resolution: {integrity: sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==}
     dev: true
 
-  /cli-truncate@4.0.0:
-    resolution: {integrity: sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==}
-    engines: {node: '>=18'}
-    dependencies:
-      slice-ansi: 5.0.0
-      string-width: 7.0.0
-    dev: true
-
   /cliui@7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
     dependencies:
@@ -4079,23 +3253,10 @@ packages:
     engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'}
     dev: true
 
-  /code-excerpt@4.0.0:
-    resolution: {integrity: sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dependencies:
-      convert-to-spaces: 2.0.1
-    dev: true
-
   /collect-v8-coverage@1.0.2:
     resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==}
     dev: true
 
-  /color-convert@1.9.3:
-    resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
-    dependencies:
-      color-name: 1.1.3
-    dev: true
-
   /color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
@@ -4103,20 +3264,10 @@ packages:
       color-name: 1.1.4
     dev: true
 
-  /color-name@1.1.3:
-    resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
-    requiresBuild: true
-    dev: true
-
   /color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
     dev: true
 
-  /color-support@1.1.3:
-    resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==}
-    hasBin: true
-    dev: true
-
   /combined-stream@1.0.8:
     resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
     engines: {node: '>= 0.8'}
@@ -4124,14 +3275,15 @@ packages:
       delayed-stream: 1.0.0
     dev: true
 
-  /commander@11.1.0:
-    resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
-    engines: {node: '>=16'}
+  /commander@12.1.0:
+    resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==}
+    engines: {node: '>=18'}
     dev: true
 
-  /commander@12.0.0:
-    resolution: {integrity: sha512-MwVNWlYjDTtOjX5PiD7o5pK0UrFU/OYgcJfjjK4RaHZETNtjJqrZa9Y9ds88+A+f+d5lv+561eZ+yCKoS3gbAA==}
+  /commander@13.0.0:
+    resolution: {integrity: sha512-oPYleIY8wmTVzkvQq10AEok6YcTC4sRUBl8F9gVuwchGVUCTbl/vhLTaQqutuuySYOsu8YTgV+OxKc/8Yvx+mQ==}
     engines: {node: '>=18'}
+    dev: true
 
   /commander@2.20.3:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
@@ -4141,10 +3293,6 @@ packages:
     engines: {node: '>= 6'}
     dev: true
 
-  /common-path-prefix@3.0.0:
-    resolution: {integrity: sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==}
-    dev: true
-
   /commondir@1.0.1:
     resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
     dev: true
@@ -4153,34 +3301,11 @@ packages:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
     dev: true
 
-  /concordance@5.0.4:
-    resolution: {integrity: sha512-OAcsnTEYu1ARJqWVGwf4zh4JDfHZEaSNlNccFmt8YjB2l/n19/PF2viLINHc57vO4FKIAFl2FWASIGZZWZ2Kxw==}
-    engines: {node: '>=10.18.0 <11 || >=12.14.0 <13 || >=14'}
-    dependencies:
-      date-time: 3.1.0
-      esutils: 2.0.3
-      fast-diff: 1.3.0
-      js-string-escape: 1.0.1
-      lodash: 4.17.21
-      md5-hex: 3.0.1
-      semver: 7.6.0
-      well-known-symbols: 2.0.0
-    dev: true
-
-  /console-control-strings@1.1.0:
-    resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}
-    dev: true
-
   /convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
     dev: true
 
-  /convert-to-spaces@2.0.1:
-    resolution: {integrity: sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dev: true
-
-  /create-jest@29.7.0(@types/node@20.14.5)(ts-node@10.9.2):
+  /create-jest@29.7.0(@types/node@22.10.5)(ts-node@10.9.2):
     resolution: {integrity: sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     hasBin: true
@@ -4189,7 +3314,7 @@ packages:
       chalk: 4.1.2
       exit: 0.1.2
       graceful-fs: 4.2.11
-      jest-config: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      jest-config: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       jest-util: 29.7.0
       prompts: 2.4.2
     transitivePeerDependencies:
@@ -4203,14 +3328,6 @@ packages:
     resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
     dev: true
 
-  /cross-env@7.0.3:
-    resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==}
-    engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'}
-    hasBin: true
-    dependencies:
-      cross-spawn: 7.0.3
-    dev: true
-
   /cross-fetch@3.1.8:
     resolution: {integrity: sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==}
     dependencies:
@@ -4233,18 +3350,31 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /currently-unhandled@0.4.1:
-    resolution: {integrity: sha512-/fITjgjGU50vjQ4FH6eUoYu+iUoUKIXws2hL15JJpIR+BbTxaXQsMuuyjtNh2WqsSBS5nsaZHFsFecyw5CCAng==}
-    engines: {node: '>=0.10.0'}
+  /data-view-buffer@1.0.1:
+    resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      array-find-index: 1.0.2
+      call-bind: 1.0.7
+      es-errors: 1.3.0
+      is-data-view: 1.0.1
     dev: true
 
-  /date-time@3.1.0:
-    resolution: {integrity: sha512-uqCUKXE5q1PNBXjPqvwhwJf9SwMoAHBgWJ6DcrnS5o+W2JOiIILl0JEdVD8SGujrNS02GGxgwAg2PN2zONgtjg==}
-    engines: {node: '>=6'}
+  /data-view-byte-length@1.0.1:
+    resolution: {integrity: sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.7
+      es-errors: 1.3.0
+      is-data-view: 1.0.1
+    dev: true
+
+  /data-view-byte-offset@1.0.0:
+    resolution: {integrity: sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      time-zone: 1.0.0
+      call-bind: 1.0.7
+      es-errors: 1.3.0
+      is-data-view: 1.0.1
     dev: true
 
   /debug@3.2.7:
@@ -4258,8 +3388,8 @@ packages:
       ms: 2.1.3
     dev: true
 
-  /debug@4.3.4(supports-color@8.1.1):
-    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+  /debug@4.3.6:
+    resolution: {integrity: sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==}
     engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
@@ -4268,10 +3398,22 @@ packages:
         optional: true
     dependencies:
       ms: 2.1.2
+    dev: true
+
+  /debug@4.3.7(supports-color@8.1.1):
+    resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.3
       supports-color: 8.1.1
 
-  /debug@4.3.5:
-    resolution: {integrity: sha512-pt0bNEmneDIvdL1Xsd9oDQ/wrQRkXDT4AUWlNZNPKvW5x/jyO9VFXkJUP07vQ2upmw5PlaITaPKc31jK13V+jg==}
+  /debug@4.4.0:
+    resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
     engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
@@ -4279,7 +3421,7 @@ packages:
       supports-color:
         optional: true
     dependencies:
-      ms: 2.1.2
+      ms: 2.1.3
     dev: true
 
   /decamelize@4.0.0:
@@ -4296,17 +3438,12 @@ packages:
         optional: true
     dev: true
 
-  /deep-eql@5.0.1:
-    resolution: {integrity: sha512-nwQCf6ne2gez3o1MxWifqkciwt0zhl0LO1/UwVu4uMBuPmflWM4oQ70XMqHqnBJA+nhzncaqL9HVL6KkHJ28lw==}
-    engines: {node: '>=6'}
-    dev: true
-
   /deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
     dev: true
 
-  /deepmerge-ts@5.1.0:
-    resolution: {integrity: sha512-eS8dRJOckyo9maw9Tu5O5RUi/4inFLrnoLkBe3cPfDMx3WZioXtmOew4TXQaxq7Rhl4xjDtR7c6x8nNTxOvbFw==}
+  /deepmerge-ts@7.1.3:
+    resolution: {integrity: sha512-qCSH6I0INPxd9Y1VtAiLpnYvz5O//6rCfJXKk0z66Up9/VOSr+1yS8XSKA5IWRxjocFGlzPyaZYe+jxq7OOLtQ==}
     engines: {node: '>=16.0.0'}
     dev: true
 
@@ -4315,43 +3452,20 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /default-browser-id@3.0.0:
-    resolution: {integrity: sha512-OZ1y3y0SqSICtE8DE4S8YOE9UZOJ8wO16fKWVP5J1Qz42kV9jcnMVFrEE/noXb/ss3Q4pZIH79kxofzyNNtUNA==}
-    engines: {node: '>=12'}
-    dependencies:
-      bplist-parser: 0.2.0
-      untildify: 4.0.0
-    dev: true
-
-  /default-browser@4.0.0:
-    resolution: {integrity: sha512-wX5pXO1+BrhMkSbROFsyxUm0i/cJEScyNhA4PPxc41ICuv05ZZB/MX28s8aZx6xjmatvebIapF6hLEKEcpneUA==}
-    engines: {node: '>=14.16'}
-    dependencies:
-      bundle-name: 3.0.0
-      default-browser-id: 3.0.0
-      execa: 7.2.0
-      titleize: 3.0.0
-    dev: true
-
-  /define-data-property@1.1.1:
-    resolution: {integrity: sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==}
+  /define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.2
+      es-define-property: 1.0.0
+      es-errors: 1.3.0
       gopd: 1.0.1
-      has-property-descriptors: 1.0.1
-
-  /define-lazy-prop@3.0.0:
-    resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
-    engines: {node: '>=12'}
-    dev: true
 
   /define-properties@1.2.1:
     resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-data-property: 1.1.1
-      has-property-descriptors: 1.0.1
+      define-data-property: 1.1.4
+      has-property-descriptors: 1.0.2
       object-keys: 1.1.1
 
   /delay@5.0.0:
@@ -4363,15 +3477,6 @@ packages:
     engines: {node: '>=0.4.0'}
     dev: true
 
-  /delegates@1.0.0:
-    resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==}
-    dev: true
-
-  /detect-libc@2.0.2:
-    resolution: {integrity: sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==}
-    engines: {node: '>=8'}
-    dev: true
-
   /detect-newline@3.1.0:
     resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==}
     engines: {node: '>=8'}
@@ -4382,13 +3487,18 @@ packages:
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dev: true
 
+  /diff-sequences@30.0.0-alpha.6:
+    resolution: {integrity: sha512-DVGt3/yzbneMUTuupsMqyfSXMnU2fE0lVsC9uFsJmRpluvSi7ZhrS0GX5tnMna6Ta788FGfOUx+irI/+cAZ4EA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dev: true
+
   /diff@4.0.2:
     resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
     engines: {node: '>=0.3.1'}
     dev: true
 
-  /diff@5.0.0:
-    resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==}
+  /diff@5.2.0:
+    resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==}
     engines: {node: '>=0.3.1'}
     dev: true
 
@@ -4417,7 +3527,7 @@ packages:
     resolution: {integrity: sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==}
     dependencies:
       no-case: 3.0.4
-      tslib: 2.6.3
+      tslib: 2.8.1
     dev: true
 
   /dotenv@16.0.3:
@@ -4433,8 +3543,16 @@ packages:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
     dev: true
 
-  /electron-to-chromium@1.4.578:
-    resolution: {integrity: sha512-V0ZhSu1BQZKfG0yNEL6Dadzik8E1vAzfpVOapdSiT9F6yapEJ3Bk+4tZ4SMPdWiUchCgnM/ByYtBzp5ntzDMIA==}
+  /ejs@3.1.10:
+    resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+    dependencies:
+      jake: 10.9.1
+    dev: true
+
+  /electron-to-chromium@1.5.50:
+    resolution: {integrity: sha512-eMVObiUQ2LdgeO1F/ySTXsvqvxb6ZH2zPGaMYsWzRDdOddUa77tdmI0ltg+L16UpbWdhPmuF3wIQYyQq65WfZw==}
     dev: true
 
   /email-addresses@5.0.0:
@@ -4446,15 +3564,6 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /emittery@1.0.1:
-    resolution: {integrity: sha512-2ID6FdrMD9KDLldGesP6317G78K7km/kMcwItRtVFva7I/cSEOIaLpewaUb+YLXVwdAp3Ctfxh/V5zIl1sj7dQ==}
-    engines: {node: '>=14.16'}
-    dev: true
-
-  /emoji-regex@10.3.0:
-    resolution: {integrity: sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==}
-    dev: true
-
   /emoji-regex@8.0.0:
     resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
     dev: true
@@ -4463,70 +3572,99 @@ packages:
     resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
     dev: true
 
+  /entities@4.5.0:
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
+    dev: true
+
   /error-ex@1.3.2:
     resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
     dependencies:
       is-arrayish: 0.2.1
     dev: true
 
-  /es-abstract@1.22.3:
-    resolution: {integrity: sha512-eiiY8HQeYfYH2Con2berK+To6GrK2RxbPawDkGq4UiCQQfZHb6wX9qQqkbpPqaxQFcl8d9QzZqo0tGE0VcrdwA==}
+  /es-abstract@1.23.3:
+    resolution: {integrity: sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==}
     engines: {node: '>= 0.4'}
     dependencies:
-      array-buffer-byte-length: 1.0.0
-      arraybuffer.prototype.slice: 1.0.2
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.5
-      es-set-tostringtag: 2.0.2
+      array-buffer-byte-length: 1.0.1
+      arraybuffer.prototype.slice: 1.0.3
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.7
+      data-view-buffer: 1.0.1
+      data-view-byte-length: 1.0.1
+      data-view-byte-offset: 1.0.0
+      es-define-property: 1.0.0
+      es-errors: 1.3.0
+      es-object-atoms: 1.0.0
+      es-set-tostringtag: 2.0.3
       es-to-primitive: 1.2.1
       function.prototype.name: 1.1.6
-      get-intrinsic: 1.2.2
-      get-symbol-description: 1.0.0
+      get-intrinsic: 1.2.4
+      get-symbol-description: 1.0.2
       globalthis: 1.0.3
       gopd: 1.0.1
-      has-property-descriptors: 1.0.1
-      has-proto: 1.0.1
+      has-property-descriptors: 1.0.2
+      has-proto: 1.0.3
       has-symbols: 1.0.3
-      hasown: 2.0.0
-      internal-slot: 1.0.6
-      is-array-buffer: 3.0.2
+      hasown: 2.0.2
+      internal-slot: 1.0.7
+      is-array-buffer: 3.0.4
       is-callable: 1.2.7
-      is-negative-zero: 2.0.2
+      is-data-view: 1.0.1
+      is-negative-zero: 2.0.3
       is-regex: 1.1.4
-      is-shared-array-buffer: 1.0.2
+      is-shared-array-buffer: 1.0.3
       is-string: 1.0.7
-      is-typed-array: 1.1.12
+      is-typed-array: 1.1.13
       is-weakref: 1.0.2
       object-inspect: 1.13.1
       object-keys: 1.1.1
-      object.assign: 4.1.4
-      regexp.prototype.flags: 1.5.1
-      safe-array-concat: 1.0.1
-      safe-regex-test: 1.0.0
-      string.prototype.trim: 1.2.8
-      string.prototype.trimend: 1.0.7
-      string.prototype.trimstart: 1.0.7
-      typed-array-buffer: 1.0.0
-      typed-array-byte-length: 1.0.0
-      typed-array-byte-offset: 1.0.0
-      typed-array-length: 1.0.4
+      object.assign: 4.1.5
+      regexp.prototype.flags: 1.5.2
+      safe-array-concat: 1.1.2
+      safe-regex-test: 1.0.3
+      string.prototype.trim: 1.2.9
+      string.prototype.trimend: 1.0.8
+      string.prototype.trimstart: 1.0.8
+      typed-array-buffer: 1.0.2
+      typed-array-byte-length: 1.0.1
+      typed-array-byte-offset: 1.0.2
+      typed-array-length: 1.0.6
       unbox-primitive: 1.0.2
-      which-typed-array: 1.1.13
+      which-typed-array: 1.1.15
+    dev: true
+
+  /es-define-property@1.0.0:
+    resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      get-intrinsic: 1.2.4
+
+  /es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  /es-object-atoms@1.0.0:
+    resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
     dev: true
 
-  /es-set-tostringtag@2.0.2:
-    resolution: {integrity: sha512-BuDyupZt65P9D2D2vA/zqcI3G5xRsklm5N3xCwuiy+/vKy8i0ifdsQP1sLgO4tZDSCaQUSnmC48khknGMV3D2Q==}
+  /es-set-tostringtag@2.0.3:
+    resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.2
-      has-tostringtag: 1.0.0
-      hasown: 2.0.0
+      get-intrinsic: 1.2.4
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
     dev: true
 
   /es-shim-unscopables@1.0.2:
     resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==}
     dependencies:
-      hasown: 2.0.0
+      hasown: 2.0.2
     dev: true
 
   /es-to-primitive@1.2.1:
@@ -4546,39 +3684,8 @@ packages:
     dependencies:
       es6-promise: 4.2.8
 
-  /esbuild@0.21.5:
-    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
-    engines: {node: '>=12'}
-    hasBin: true
-    requiresBuild: true
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.21.5
-      '@esbuild/android-arm': 0.21.5
-      '@esbuild/android-arm64': 0.21.5
-      '@esbuild/android-x64': 0.21.5
-      '@esbuild/darwin-arm64': 0.21.5
-      '@esbuild/darwin-x64': 0.21.5
-      '@esbuild/freebsd-arm64': 0.21.5
-      '@esbuild/freebsd-x64': 0.21.5
-      '@esbuild/linux-arm': 0.21.5
-      '@esbuild/linux-arm64': 0.21.5
-      '@esbuild/linux-ia32': 0.21.5
-      '@esbuild/linux-loong64': 0.21.5
-      '@esbuild/linux-mips64el': 0.21.5
-      '@esbuild/linux-ppc64': 0.21.5
-      '@esbuild/linux-riscv64': 0.21.5
-      '@esbuild/linux-s390x': 0.21.5
-      '@esbuild/linux-x64': 0.21.5
-      '@esbuild/netbsd-x64': 0.21.5
-      '@esbuild/openbsd-x64': 0.21.5
-      '@esbuild/sunos-x64': 0.21.5
-      '@esbuild/win32-arm64': 0.21.5
-      '@esbuild/win32-ia32': 0.21.5
-      '@esbuild/win32-x64': 0.21.5
-    dev: true
-
-  /escalade@3.1.1:
-    resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==}
+  /escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
     dev: true
 
@@ -4602,36 +3709,74 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /eslint-config-prettier@9.1.0(eslint@8.57.0):
+  /eslint-config-prettier@9.1.0(eslint@9.13.0):
     resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==}
     hasBin: true
     peerDependencies:
       eslint: '>=7.0.0'
     dependencies:
-      eslint: 8.57.0
+      eslint: 9.13.0
     dev: true
 
-  /eslint-config-turbo@2.0.4(eslint@8.57.0):
-    resolution: {integrity: sha512-zGvU+bxoNWVvSl0prGItrnH9FgeNzKEAjRmv8ruqql1psI37T8IoLF/XeOzT3CzzYzJxuI3wW1yb2agDFYQdHQ==}
+  /eslint-config-turbo@2.3.3(eslint@8.57.0):
+    resolution: {integrity: sha512-cM9wSBYowQIrjx2MPCzFE6jTnG4vpTPJKZ/O+Ps3CqrmGK/wtNOsY6WHGMwLtKY/nNbgRahAJH6jGVF6k2coOg==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
       eslint: 8.57.0
-      eslint-plugin-turbo: 2.0.4(eslint@8.57.0)
+      eslint-plugin-turbo: 2.3.3(eslint@8.57.0)
+    dev: true
+
+  /eslint-config-turbo@2.3.3(eslint@9.13.0):
+    resolution: {integrity: sha512-cM9wSBYowQIrjx2MPCzFE6jTnG4vpTPJKZ/O+Ps3CqrmGK/wtNOsY6WHGMwLtKY/nNbgRahAJH6jGVF6k2coOg==}
+    peerDependencies:
+      eslint: '>6.6.0'
+    dependencies:
+      eslint: 9.13.0
+      eslint-plugin-turbo: 2.3.3(eslint@9.13.0)
     dev: true
 
   /eslint-import-resolver-node@0.3.9:
     resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==}
     dependencies:
       debug: 3.2.7
-      is-core-module: 2.13.1
+      is-core-module: 2.15.1
       resolve: 1.22.8
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@7.13.1)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0):
-    resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
+  /eslint-module-utils@2.12.0(@typescript-eslint/parser@8.12.2)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0):
+    resolution: {integrity: sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: '*'
+      eslint-import-resolver-node: '*'
+      eslint-import-resolver-typescript: '*'
+      eslint-import-resolver-webpack: '*'
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+      eslint:
+        optional: true
+      eslint-import-resolver-node:
+        optional: true
+      eslint-import-resolver-typescript:
+        optional: true
+      eslint-import-resolver-webpack:
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      debug: 3.2.7
+      eslint: 8.57.0
+      eslint-import-resolver-node: 0.3.9
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /eslint-module-utils@2.12.0(@typescript-eslint/parser@8.4.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0):
+    resolution: {integrity: sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg==}
     engines: {node: '>=4'}
     peerDependencies:
       '@typescript-eslint/parser': '*'
@@ -4651,7 +3796,7 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/parser': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
       debug: 3.2.7
       eslint: 8.57.0
       eslint-import-resolver-node: 0.3.9
@@ -4670,56 +3815,58 @@ packages:
       ignore: 5.2.4
     dev: true
 
-  /eslint-plugin-functional@6.5.1(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-8FbXylC/kptJ1drux4fyopVWmDkNTHGj/p7DKFt6G8hVXUhkC1eHCcNb5bnUOrpYEycIXXi0MrE3Nt0oEOkrQA==}
-    engines: {node: '>=16.10.0'}
+  /eslint-plugin-functional@7.2.1(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-cHhUmrOSde6pGuUJ6guuuJQKudbEMpk6DtgHLjStwjbI/NnzWp2jIizaLF1U1zVDJBjJHfJ1HeqYiDyiCF34CQ==}
+    engines: {node: '>=v18.18.0'}
     peerDependencies:
-      eslint: ^8.0.0
-      typescript: '>=4.3.5'
+      eslint: ^9.0.0
+      typescript: '>=4.7.4'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/utils': 7.6.0(eslint@8.57.0)(typescript@5.4.5)
-      deepmerge-ts: 5.1.0
-      escape-string-regexp: 4.0.0
+      '@typescript-eslint/utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      deepmerge-ts: 7.1.3
+      escape-string-regexp: 5.0.0
       eslint: 8.57.0
-      is-immutable-type: 3.1.0(eslint@8.57.0)(typescript@5.4.5)
-      semver: 7.6.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      typescript: 5.4.5
+      is-immutable-type: 5.0.0(eslint@8.57.0)(typescript@5.7.2)
+      ts-api-utils: 2.0.0(typescript@5.7.2)
+      ts-declaration-location: 1.0.4(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /eslint-plugin-import@2.29.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0):
-    resolution: {integrity: sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==}
+  /eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.12.2)(eslint@8.57.0):
+    resolution: {integrity: sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==}
     engines: {node: '>=4'}
     peerDependencies:
       '@typescript-eslint/parser': '*'
-      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
+      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9
     peerDependenciesMeta:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      array-includes: 3.1.7
-      array.prototype.findlastindex: 1.2.3
+      '@rtsao/scc': 1.1.0
+      '@typescript-eslint/parser': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
+      array-includes: 3.1.8
+      array.prototype.findlastindex: 1.2.5
       array.prototype.flat: 1.3.2
       array.prototype.flatmap: 1.3.2
       debug: 3.2.7
       doctrine: 2.1.0
       eslint: 8.57.0
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@7.13.1)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0)
-      hasown: 2.0.0
-      is-core-module: 2.13.1
+      eslint-module-utils: 2.12.0(@typescript-eslint/parser@8.12.2)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0)
+      hasown: 2.0.2
+      is-core-module: 2.15.1
       is-glob: 4.0.3
       minimatch: 3.1.2
-      object.fromentries: 2.0.7
-      object.groupby: 1.0.1
-      object.values: 1.1.7
+      object.fromentries: 2.0.8
+      object.groupby: 1.0.3
+      object.values: 1.2.0
       semver: 6.3.1
+      string.prototype.trimend: 1.0.8
       tsconfig-paths: 3.15.0
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
@@ -4727,12 +3874,49 @@ packages:
       - supports-color
     dev: true
 
-  /eslint-plugin-jest@27.9.0(@typescript-eslint/eslint-plugin@6.21.0)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-QIT7FH7fNmd9n4se7FFKHbsLKGQiw885Ds6Y/sxKgCZ6natwCsXdgPOADnYVxN2QrRweF0FZWbJ6S7Rsn7llug==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
+  /eslint-plugin-import@2.31.0(@typescript-eslint/parser@8.4.0)(eslint@8.57.0):
+    resolution: {integrity: sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+    dependencies:
+      '@rtsao/scc': 1.1.0
+      '@typescript-eslint/parser': 8.4.0(eslint@8.57.0)(typescript@5.7.2)
+      array-includes: 3.1.8
+      array.prototype.findlastindex: 1.2.5
+      array.prototype.flat: 1.3.2
+      array.prototype.flatmap: 1.3.2
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 8.57.0
+      eslint-import-resolver-node: 0.3.9
+      eslint-module-utils: 2.12.0(@typescript-eslint/parser@8.4.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0)
+      hasown: 2.0.2
+      is-core-module: 2.15.1
+      is-glob: 4.0.3
+      minimatch: 3.1.2
+      object.fromentries: 2.0.8
+      object.groupby: 1.0.3
+      object.values: 1.2.0
+      semver: 6.3.1
+      string.prototype.trimend: 1.0.8
+      tsconfig-paths: 3.15.0
+    transitivePeerDependencies:
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+    dev: true
+
+  /eslint-plugin-jest@28.10.0(@typescript-eslint/eslint-plugin@8.12.2)(eslint@8.57.0)(jest@29.7.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-hyMWUxkBH99HpXT3p8hc7REbEZK3D+nk8vHXGgpB+XXsi0gO4PxMSP+pjfUzb67GnV9yawV9a53eUmcde1CCZA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': ^5.0.0 || ^6.0.0 || ^7.0.0
-      eslint: ^7.0.0 || ^8.0.0
+      '@typescript-eslint/eslint-plugin': ^6.0.0 || ^7.0.0 || ^8.0.0
+      eslint: ^7.0.0 || ^8.0.0 || ^9.0.0
       jest: '*'
     peerDependenciesMeta:
       '@typescript-eslint/eslint-plugin':
@@ -4740,19 +3924,20 @@ packages:
       jest:
         optional: true
     dependencies:
-      '@typescript-eslint/eslint-plugin': 6.21.0(@typescript-eslint/parser@6.21.0)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/eslint-plugin': 8.12.2(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
       eslint: 8.57.0
+      jest: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /eslint-plugin-jest@28.6.0(@typescript-eslint/eslint-plugin@7.13.1)(eslint@8.57.0)(jest@29.7.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-YG28E1/MIKwnz+e2H7VwYPzHUYU4aMa19w0yGcwXnnmJH6EfgHahTJ2un3IyraUxNfnz/KUhJAFXNNwWPo12tg==}
+  /eslint-plugin-jest@28.10.0(eslint@9.13.0)(jest@30.0.0-alpha.6)(typescript@5.7.2):
+    resolution: {integrity: sha512-hyMWUxkBH99HpXT3p8hc7REbEZK3D+nk8vHXGgpB+XXsi0gO4PxMSP+pjfUzb67GnV9yawV9a53eUmcde1CCZA==}
     engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': ^6.0.0 || ^7.0.0
+      '@typescript-eslint/eslint-plugin': ^6.0.0 || ^7.0.0 || ^8.0.0
       eslint: ^7.0.0 || ^8.0.0 || ^9.0.0
       jest: '*'
     peerDependenciesMeta:
@@ -4761,17 +3946,16 @@ packages:
       jest:
         optional: true
     dependencies:
-      '@typescript-eslint/eslint-plugin': 7.13.1(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/utils': 7.12.0(eslint@8.57.0)(typescript@5.4.5)
-      eslint: 8.57.0
-      jest: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      eslint: 9.13.0
+      jest: 30.0.0-alpha.6
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /eslint-plugin-mocha@10.4.3(eslint@8.57.0):
-    resolution: {integrity: sha512-emc4TVjq5Ht0/upR+psftuz6IBG5q279p+1dSRDeHf+NS9aaerBi3lXKo1SEzwC29hFIW21gO89CEWSvRsi8IQ==}
+  /eslint-plugin-mocha@10.5.0(eslint@8.57.0):
+    resolution: {integrity: sha512-F2ALmQVPT1GoP27O1JTZGrV9Pqg8k79OeIuvw63UxMtQKREZtmkK1NFgkZQ2TW7L2JSSFKHFPTtHu5z8R9QNRw==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
       eslint: '>=7.0.0'
@@ -4782,8 +3966,8 @@ packages:
       rambda: 7.5.0
     dev: true
 
-  /eslint-plugin-prettier@5.1.3(@types/eslint@8.56.7)(eslint-config-prettier@9.1.0)(eslint@8.57.0)(prettier@3.3.2):
-    resolution: {integrity: sha512-C9GCVAs4Eq7ZC/XFQHITLiHJxQngdtraXaM+LoUFoFp/lHNl2Zn8f3WQbe9HvTBBQ9YnKFB0/2Ajdqwo5D1EAw==}
+  /eslint-plugin-prettier@5.2.1(eslint-config-prettier@9.1.0)(eslint@9.13.0)(prettier@3.4.2):
+    resolution: {integrity: sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==}
     engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
       '@types/eslint': '>=8.0.0'
@@ -4796,16 +3980,15 @@ packages:
       eslint-config-prettier:
         optional: true
     dependencies:
-      '@types/eslint': 8.56.7
-      eslint: 8.57.0
-      eslint-config-prettier: 9.1.0(eslint@8.57.0)
-      prettier: 3.3.2
+      eslint: 9.13.0
+      eslint-config-prettier: 9.1.0(eslint@9.13.0)
+      prettier: 3.4.2
       prettier-linter-helpers: 1.0.0
-      synckit: 0.8.6
+      synckit: 0.9.1
     dev: true
 
-  /eslint-plugin-react-hooks@4.6.0(eslint@8.57.0):
-    resolution: {integrity: sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==}
+  /eslint-plugin-react-hooks@4.6.2(eslint@8.57.0):
+    resolution: {integrity: sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==}
     engines: {node: '>=10'}
     peerDependencies:
       eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0
@@ -4813,6 +3996,15 @@ packages:
       eslint: 8.57.0
     dev: true
 
+  /eslint-plugin-react-hooks@5.0.0(eslint@9.13.0):
+    resolution: {integrity: sha512-hIOwI+5hYGpJEc4uPRmz2ulCjAGD/N13Lukkh8cLV0i2IRk/bdZDYjgLVHj+U9Z704kLIdIO6iueGvxNur0sgw==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0
+    dependencies:
+      eslint: 9.13.0
+    dev: true
+
   /eslint-plugin-require-extensions@0.1.3(eslint@8.57.0):
     resolution: {integrity: sha512-T3c1PZ9PIdI3hjV8LdunfYI8gj017UQjzAnCrxuo3wAjneDbTPHdE3oNWInOjMA+z/aBkUtlW5vC0YepYMZIug==}
     engines: {node: '>=16'}
@@ -4822,20 +4014,20 @@ packages:
       eslint: 8.57.0
     dev: true
 
-  /eslint-plugin-simple-import-sort@10.0.0(eslint@8.57.0):
-    resolution: {integrity: sha512-AeTvO9UCMSNzIHRkg8S6c3RPy5YEwKWSQPx3DYghLedo2ZQxowPFLGDN1AZ2evfg6r6mjBSZSLxLFsWSu3acsw==}
+  /eslint-plugin-simple-import-sort@12.1.1(eslint@8.57.0):
+    resolution: {integrity: sha512-6nuzu4xwQtE3332Uz0to+TxDQYRLTKRESSc2hefVT48Zc8JthmN23Gx9lnYhu0FtkRSL1oxny3kJ2aveVhmOVA==}
     peerDependencies:
       eslint: '>=5.0.0'
     dependencies:
       eslint: 8.57.0
     dev: true
 
-  /eslint-plugin-simple-import-sort@12.1.0(eslint@8.57.0):
-    resolution: {integrity: sha512-Y2fqAfC11TcG/WP3TrI1Gi3p3nc8XJyEOJYHyEPEGI/UAgNx6akxxlX74p7SbAQdLcgASKhj8M0GKvH3vq/+ig==}
+  /eslint-plugin-simple-import-sort@12.1.1(eslint@9.13.0):
+    resolution: {integrity: sha512-6nuzu4xwQtE3332Uz0to+TxDQYRLTKRESSc2hefVT48Zc8JthmN23Gx9lnYhu0FtkRSL1oxny3kJ2aveVhmOVA==}
     peerDependencies:
       eslint: '>=5.0.0'
     dependencies:
-      eslint: 8.57.0
+      eslint: 9.13.0
     dev: true
 
   /eslint-plugin-sort-keys-fix@1.1.2:
@@ -4848,8 +4040,8 @@ packages:
       requireindex: 1.2.0
     dev: true
 
-  /eslint-plugin-turbo@2.0.4(eslint@8.57.0):
-    resolution: {integrity: sha512-Ozn//vTXJeqIEvEkThM2vuuldMckPqAne7vg/S3GxF+BBY516cjdp7+dYpCU5Q0083hVm638c8542ubccNE+8w==}
+  /eslint-plugin-turbo@2.3.3(eslint@8.57.0):
+    resolution: {integrity: sha512-j8UEA0Z+NNCsjZep9G5u5soDQHcXq/x4amrwulk6eHF1U91H2qAjp5I4jQcvJewmccCJbVp734PkHHTRnosjpg==}
     peerDependencies:
       eslint: '>6.6.0'
     dependencies:
@@ -4857,38 +4049,47 @@ packages:
       eslint: 8.57.0
     dev: true
 
-  /eslint-plugin-typescript-sort-keys@3.2.0(@typescript-eslint/parser@6.21.0)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-GutszvriaVtwmn7pQjuj9/9o0iXhD7XZs0/424+zsozdRr/fdg5e8206t478Vnqnqi1GjuxcAolj1kf74KnhPA==}
+  /eslint-plugin-turbo@2.3.3(eslint@9.13.0):
+    resolution: {integrity: sha512-j8UEA0Z+NNCsjZep9G5u5soDQHcXq/x4amrwulk6eHF1U91H2qAjp5I4jQcvJewmccCJbVp734PkHHTRnosjpg==}
+    peerDependencies:
+      eslint: '>6.6.0'
+    dependencies:
+      dotenv: 16.0.3
+      eslint: 9.13.0
+    dev: true
+
+  /eslint-plugin-typescript-sort-keys@3.3.0(@typescript-eslint/parser@8.12.2)(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-bRW3Rc/VNdrSP9OoY5wgjjaXCOOkZKpzvl/Mk6l8Sg8CMehVIcg9K4y33l+ZcZiknpl0aR6rKusxuCJNGZWmVw==}
     engines: {node: '>= 16'}
     peerDependencies:
-      '@typescript-eslint/parser': ^6 || ^7
+      '@typescript-eslint/parser': '>=6'
       eslint: ^7 || ^8
       typescript: ^3 || ^4 || ^5
     dependencies:
-      '@typescript-eslint/experimental-utils': 5.62.0(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/experimental-utils': 5.62.0(eslint@8.57.0)(typescript@5.7.2)
+      '@typescript-eslint/parser': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
       eslint: 8.57.0
       json-schema: 0.4.0
       natural-compare-lite: 1.4.0
-      typescript: 5.4.5
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /eslint-plugin-typescript-sort-keys@3.2.0(@typescript-eslint/parser@7.13.1)(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-GutszvriaVtwmn7pQjuj9/9o0iXhD7XZs0/424+zsozdRr/fdg5e8206t478Vnqnqi1GjuxcAolj1kf74KnhPA==}
+  /eslint-plugin-typescript-sort-keys@3.3.0(@typescript-eslint/parser@8.12.2)(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-bRW3Rc/VNdrSP9OoY5wgjjaXCOOkZKpzvl/Mk6l8Sg8CMehVIcg9K4y33l+ZcZiknpl0aR6rKusxuCJNGZWmVw==}
     engines: {node: '>= 16'}
     peerDependencies:
-      '@typescript-eslint/parser': ^6 || ^7
+      '@typescript-eslint/parser': '>=6'
       eslint: ^7 || ^8
       typescript: ^3 || ^4 || ^5
     dependencies:
-      '@typescript-eslint/experimental-utils': 5.62.0(eslint@8.57.0)(typescript@5.4.5)
-      '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
-      eslint: 8.57.0
+      '@typescript-eslint/experimental-utils': 5.62.0(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/parser': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      eslint: 9.13.0
       json-schema: 0.4.0
       natural-compare-lite: 1.4.0
-      typescript: 5.4.5
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -4909,6 +4110,14 @@ packages:
       estraverse: 5.3.0
     dev: true
 
+  /eslint-scope@8.2.0:
+    resolution: {integrity: sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+    dev: true
+
   /eslint-utils@3.0.0(eslint@8.57.0):
     resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==}
     engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0}
@@ -4934,13 +4143,18 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
+  /eslint-visitor-keys@4.2.0:
+    resolution: {integrity: sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
   /eslint@8.57.0:
     resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     hasBin: true
     dependencies:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
-      '@eslint-community/regexpp': 4.10.0
+      '@eslint-community/regexpp': 4.12.1
       '@eslint/eslintrc': 2.1.4
       '@eslint/js': 8.57.0
       '@humanwhocodes/config-array': 0.11.14
@@ -4950,7 +4164,7 @@ packages:
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.3
-      debug: 4.3.4(supports-color@8.1.1)
+      debug: 4.3.7(supports-color@8.1.1)
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
       eslint-scope: 7.2.2
@@ -4962,9 +4176,9 @@ packages:
       file-entry-cache: 6.0.1
       find-up: 5.0.0
       glob-parent: 6.0.2
-      globals: 13.23.0
+      globals: 13.24.0
       graphemer: 1.4.0
-      ignore: 5.2.4
+      ignore: 5.3.1
       imurmurhash: 0.1.4
       is-glob: 4.0.3
       is-path-inside: 3.0.3
@@ -4981,6 +4195,64 @@ packages:
       - supports-color
     dev: true
 
+  /eslint@9.13.0:
+    resolution: {integrity: sha512-EYZK6SX6zjFHST/HRytOdA/zE72Cq/bfw45LSyuwrdvcclb/gqV8RRQxywOBEWO2+WDpva6UZa4CcDeJKzUCFA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@9.13.0)
+      '@eslint-community/regexpp': 4.12.1
+      '@eslint/config-array': 0.18.0
+      '@eslint/core': 0.7.0
+      '@eslint/eslintrc': 3.1.0
+      '@eslint/js': 9.13.0
+      '@eslint/plugin-kit': 0.2.2
+      '@humanfs/node': 0.16.6
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.3.1
+      '@types/estree': 1.0.6
+      '@types/json-schema': 7.0.15
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.3
+      debug: 4.4.0
+      escape-string-regexp: 4.0.0
+      eslint-scope: 8.2.0
+      eslint-visitor-keys: 4.2.0
+      espree: 10.3.0
+      esquery: 1.5.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.1
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.3
+      text-table: 0.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /espree@10.3.0:
+    resolution: {integrity: sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      acorn: 8.14.0
+      acorn-jsx: 5.3.2(acorn@8.14.0)
+      eslint-visitor-keys: 4.2.0
+    dev: true
+
   /espree@6.2.1:
     resolution: {integrity: sha512-ysCxRQY3WaXJz9tdbWOwuWr5Y/XrPTGX9Kiz3yoUXwW0VZ4w30HTkQLaGx/+ttFjF8i+ACbArnB4ce68a9m5hw==}
     engines: {node: '>=6.0.0'}
@@ -5052,6 +4324,10 @@ packages:
 
   /eventemitter3@4.0.7:
     resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+    dev: true
+
+  /eventemitter3@5.0.1:
+    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
 
   /execa@5.1.1:
     resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
@@ -5063,39 +4339,9 @@ packages:
       is-stream: 2.0.1
       merge-stream: 2.0.0
       npm-run-path: 4.0.1
-      onetime: 5.1.2
-      signal-exit: 3.0.7
-      strip-final-newline: 2.0.0
-    dev: true
-
-  /execa@7.2.0:
-    resolution: {integrity: sha512-UduyVP7TLB5IcAQl+OzLyLcS/l32W/GLg+AhHJ+ow40FOk2U3SAllPwR44v4vmdFwIWqpdwxxpQbF1n5ta9seA==}
-    engines: {node: ^14.18.0 || ^16.14.0 || >=18.0.0}
-    dependencies:
-      cross-spawn: 7.0.3
-      get-stream: 6.0.1
-      human-signals: 4.3.1
-      is-stream: 3.0.0
-      merge-stream: 2.0.0
-      npm-run-path: 5.1.0
-      onetime: 6.0.0
-      signal-exit: 3.0.7
-      strip-final-newline: 3.0.0
-    dev: true
-
-  /execa@8.0.1:
-    resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
-    engines: {node: '>=16.17'}
-    dependencies:
-      cross-spawn: 7.0.3
-      get-stream: 8.0.1
-      human-signals: 5.0.0
-      is-stream: 3.0.0
-      merge-stream: 2.0.0
-      npm-run-path: 5.1.0
-      onetime: 6.0.0
-      signal-exit: 4.1.0
-      strip-final-newline: 3.0.0
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
     dev: true
 
   /exit@0.1.2:
@@ -5114,6 +4360,18 @@ packages:
       jest-util: 29.7.0
     dev: true
 
+  /expect@30.0.0-alpha.6:
+    resolution: {integrity: sha512-WVi2V4iHKw/vHEyye00Q9CSZz7KHDbJkJyteUI8kTih9jiyMl3bIk7wLYFcY9D1Blnadlyb5w5NBuNjQBow99g==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/expect-utils': 30.0.0-alpha.6
+      jest-get-type: 30.0.0-alpha.6
+      jest-matcher-utils: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-mock: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+    dev: true
+
   /eyes@0.1.8:
     resolution: {integrity: sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==}
     engines: {node: '> 0.1.90'}
@@ -5134,7 +4392,7 @@ packages:
       '@nodelib/fs.walk': 1.2.8
       glob-parent: 5.1.2
       merge2: 1.4.1
-      micromatch: 4.0.5
+      micromatch: 4.0.8
     dev: true
 
   /fast-json-stable-stringify@2.1.0:
@@ -5150,6 +4408,7 @@ packages:
 
   /fastestsmallesttextencoderdecoder@1.0.22:
     resolution: {integrity: sha512-Pb8d48e+oIuY4MaM64Cd7OW1gt4nxCHs7/ddPPZ/Ic3sg8yVGM7O9wDvZ7us6ScaUupzM+pfBolwtYhN1IxBIw==}
+    dev: true
 
   /fastq@1.15.0:
     resolution: {integrity: sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==}
@@ -5163,11 +4422,15 @@ packages:
       bser: 2.1.1
     dev: true
 
-  /figures@6.0.1:
-    resolution: {integrity: sha512-0oY/olScYD4IhQ8u//gCPA4F3mlTn2dacYmiDm/mbDQvpmLjV4uH+zhsQ5IyXRyvqkvtUkXkNdGvg5OFJTCsuQ==}
-    engines: {node: '>=18'}
+  /fdir@6.3.0(picomatch@4.0.2):
+    resolution: {integrity: sha512-QOnuT+BOtivR77wYvCWHfGt9s4Pz1VIMbD463vegT5MLqNXy8rYFT/lPVEqf/bhYeT6qmqrNHhsX+rWwe3rOCQ==}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
     dependencies:
-      is-unicode-supported: 2.0.0
+      picomatch: 4.0.2
     dev: true
 
   /file-entry-cache@6.0.1:
@@ -5177,9 +4440,22 @@ packages:
       flat-cache: 3.1.1
     dev: true
 
+  /file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      flat-cache: 4.0.1
+    dev: true
+
   /file-uri-to-path@1.0.0:
     resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
 
+  /filelist@1.0.4:
+    resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==}
+    dependencies:
+      minimatch: 5.1.6
+    dev: true
+
   /filename-reserved-regex@2.0.0:
     resolution: {integrity: sha512-lc1bnsSr4L4Bdif8Xb/qrtokGbq5zlsms/CYH8PP+WtCkGNF65DPiQY8vG3SakEdRn8Dlnm+gW/qWKKjS5sZzQ==}
     engines: {node: '>=4'}
@@ -5194,8 +4470,8 @@ packages:
       trim-repeated: 1.0.0
     dev: true
 
-  /fill-range@7.0.1:
-    resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==}
+  /fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
     dependencies:
       to-regex-range: 5.0.1
@@ -5216,16 +4492,11 @@ packages:
     dependencies:
       chalk: 4.1.2
       commander: 5.1.0
-      debug: 4.3.5
+      debug: 4.4.0
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /find-up-simple@1.0.0:
-    resolution: {integrity: sha512-q7Us7kcjj2VMePAa02hDAF6d+MzsdsAWEwYyOpwUtlerRBkOEPBCRZrAV4XfcSN8fHAgaD0hP7miwoay6DCprw==}
-    engines: {node: '>=18'}
-    dev: true
-
   /find-up@4.1.0:
     resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
     engines: {node: '>=8'}
@@ -5251,6 +4522,14 @@ packages:
       rimraf: 3.0.2
     dev: true
 
+  /flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+    dependencies:
+      flatted: 3.2.9
+      keyv: 4.5.4
+    dev: true
+
   /flat@5.0.2:
     resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
     hasBin: true
@@ -5260,8 +4539,8 @@ packages:
     resolution: {integrity: sha512-36yxDn5H7OFZQla0/jFJmbIKTdZAQHngCedGxiMmpNfEZM0sdEeT+WczLQrjK6D7o2aiyLYDnkw0R3JK0Qv1RQ==}
     dev: true
 
-  /follow-redirects@1.15.3(debug@4.3.5):
-    resolution: {integrity: sha512-1VzOtuEM8pC9SFU1E+8KfTjZyMztRsgEfwQl44z8A25uy13jSzTj6dyK2Df52iV0vgHCfBwLhDWevLn95w5v6Q==}
+  /follow-redirects@1.15.9(debug@4.4.0):
+    resolution: {integrity: sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==}
     engines: {node: '>=4.0'}
     peerDependencies:
       debug: '*'
@@ -5269,7 +4548,7 @@ packages:
       debug:
         optional: true
     dependencies:
-      debug: 4.3.5
+      debug: 4.4.0
     dev: true
 
   /for-each@0.3.3:
@@ -5307,13 +4586,6 @@ packages:
       universalify: 2.0.1
     dev: true
 
-  /fs-minipass@2.1.0:
-    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
-    engines: {node: '>= 8'}
-    dependencies:
-      minipass: 3.3.6
-    dev: true
-
   /fs.realpath@1.0.0:
     resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
     dev: true
@@ -5333,9 +4605,9 @@ packages:
     resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
       functions-have-names: 1.2.3
     dev: true
 
@@ -5343,21 +4615,6 @@ packages:
     resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
     dev: true
 
-  /gauge@3.0.2:
-    resolution: {integrity: sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==}
-    engines: {node: '>=10'}
-    dependencies:
-      aproba: 2.0.0
-      color-support: 1.1.3
-      console-control-strings: 1.1.0
-      has-unicode: 2.0.1
-      object-assign: 4.1.1
-      signal-exit: 3.0.7
-      string-width: 4.2.3
-      strip-ansi: 6.0.1
-      wide-align: 1.1.5
-    dev: true
-
   /gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
     engines: {node: '>=6.9.0'}
@@ -5368,22 +4625,15 @@ packages:
     engines: {node: 6.* || 8.* || >= 10.*}
     dev: true
 
-  /get-east-asian-width@1.2.0:
-    resolution: {integrity: sha512-2nk+7SIVb14QrgXFHcm84tD4bKQz0RxPuMT8Ag5KPOq7J5fEmAg0UbXdTOSHqNuHSU28k55qnceesxXRZGzKWA==}
-    engines: {node: '>=18'}
-    dev: true
-
-  /get-func-name@2.0.2:
-    resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==}
-    dev: true
-
-  /get-intrinsic@1.2.2:
-    resolution: {integrity: sha512-0gSo4ml/0j98Y3lngkFEot/zhiCeWsbYIlZ+uZOVgzLyLaUw7wxUL+nCTP0XJvJg1AXulJRI3UJi8GsbDuxdGA==}
+  /get-intrinsic@1.2.4:
+    resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==}
+    engines: {node: '>= 0.4'}
     dependencies:
+      es-errors: 1.3.0
       function-bind: 1.1.2
-      has-proto: 1.0.1
+      has-proto: 1.0.3
       has-symbols: 1.0.3
-      hasown: 2.0.0
+      hasown: 2.0.2
 
   /get-package-type@0.1.0:
     resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==}
@@ -5395,37 +4645,27 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /get-stream@8.0.1:
-    resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==}
-    engines: {node: '>=16'}
-    dev: true
-
-  /get-symbol-description@1.0.0:
-    resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==}
+  /get-symbol-description@1.0.2:
+    resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
-    dev: true
-
-  /get-tsconfig@4.7.5:
-    resolution: {integrity: sha512-ZCuZCnlqNzjb4QprAzXKdpp/gh6KTxSJuw3IBsPnV/7fV4NxC9ckB+vPTt8w7fJA0TaSD7c55BR47JD6MEDyDw==}
-    dependencies:
-      resolve-pkg-maps: 1.0.0
+      call-bind: 1.0.7
+      es-errors: 1.3.0
+      get-intrinsic: 1.2.4
     dev: true
 
-  /gh-pages@6.1.1:
-    resolution: {integrity: sha512-upnohfjBwN5hBP9w2dPE7HO5JJTHzSGMV1JrLrHvNuqmjoYHg6TBrCcnEoorjG/e0ejbuvnwyKMdTyM40PEByw==}
+  /gh-pages@6.3.0:
+    resolution: {integrity: sha512-Ot5lU6jK0Eb+sszG8pciXdjMXdBJ5wODvgjR+imihTqsUWF2K6dJ9HST55lgqcs8wWcw6o6wAsUzfcYRhJPXbA==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
       async: 3.2.5
-      commander: 11.1.0
+      commander: 13.0.0
       email-addresses: 5.0.0
       filenamify: 4.3.0
       find-cache-dir: 3.3.2
       fs-extra: 11.1.1
-      globby: 6.1.0
+      globby: 11.1.0
     dev: true
 
   /glob-parent@5.1.2:
@@ -5442,27 +4682,15 @@ packages:
       is-glob: 4.0.3
     dev: true
 
-  /glob@10.3.10:
-    resolution: {integrity: sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==}
-    engines: {node: '>=16 || 14 >=14.17'}
-    hasBin: true
-    dependencies:
-      foreground-child: 3.1.1
-      jackspeak: 2.3.6
-      minimatch: 9.0.4
-      minipass: 7.1.2
-      path-scurry: 1.11.1
-    dev: true
-
-  /glob@10.4.1:
-    resolution: {integrity: sha512-2jelhlq3E4ho74ZyVLN03oKdAZVUa6UDZzFLVH1H7dnoax+y9qyaq8zBkfDIggjniU19z0wU18y16jMB2eyVIw==}
-    engines: {node: '>=16 || 14 >=14.18'}
+  /glob@10.4.5:
+    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
     hasBin: true
     dependencies:
       foreground-child: 3.1.1
-      jackspeak: 3.4.0
-      minimatch: 9.0.4
+      jackspeak: 3.4.3
+      minimatch: 9.0.5
       minipass: 7.1.2
+      package-json-from-dist: 1.0.0
       path-scurry: 1.11.1
     dev: true
 
@@ -5478,29 +4706,11 @@ packages:
       path-is-absolute: 1.0.1
     dev: true
 
-  /glob@8.1.0:
-    resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
-    engines: {node: '>=12'}
-    dependencies:
-      fs.realpath: 1.0.0
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 5.1.6
-      once: 1.4.0
-    dev: true
-
   /globals@11.12.0:
     resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
     engines: {node: '>=4'}
     dev: true
 
-  /globals@13.23.0:
-    resolution: {integrity: sha512-XAmF0RjlrjY23MA51q3HltdlGxUpXPvg0GioKiD9X6HD28iMjo2dKC8Vqwm7lne4GNr78+RHTfliktR6ZH09wA==}
-    engines: {node: '>=8'}
-    dependencies:
-      type-fest: 0.20.2
-    dev: true
-
   /globals@13.24.0:
     resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==}
     engines: {node: '>=8'}
@@ -5508,6 +4718,16 @@ packages:
       type-fest: 0.20.2
     dev: true
 
+  /globals@14.0.0:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
+    dev: true
+
+  /globals@15.11.0:
+    resolution: {integrity: sha512-yeyNSjdbyVaWurlwCpcA6XNBrHTMIeDdj0/hnvX/OLJ9ekOXYbLsLinH/MucQyGvNnXhidTdNhTtJaffL2sMfw==}
+    engines: {node: '>=18'}
+    dev: true
+
   /globalthis@1.0.3:
     resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==}
     engines: {node: '>= 0.4'}
@@ -5527,33 +4747,10 @@ packages:
       slash: 3.0.0
     dev: true
 
-  /globby@14.0.0:
-    resolution: {integrity: sha512-/1WM/LNHRAOH9lZta77uGbq0dAEQM+XjNesWwhlERDVenqothRbnzTrL3/LrIoEPPjeUHC3vrS6TwoyxeHs7MQ==}
-    engines: {node: '>=18'}
-    dependencies:
-      '@sindresorhus/merge-streams': 1.0.0
-      fast-glob: 3.3.2
-      ignore: 5.3.1
-      path-type: 5.0.0
-      slash: 5.1.0
-      unicorn-magic: 0.1.0
-    dev: true
-
-  /globby@6.1.0:
-    resolution: {integrity: sha512-KVbFv2TQtbzCoxAnfD6JcHZTYCzyliEaaeM/gH8qQdkKr5s0OP9scEgvdcngyk7AVdY6YVW/TJHd+lQ/Df3Daw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      array-union: 1.0.2
-      glob: 7.2.3
-      object-assign: 4.1.1
-      pify: 2.3.0
-      pinkie-promise: 2.0.1
-    dev: true
-
   /gopd@1.0.1:
     resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==}
     dependencies:
-      get-intrinsic: 1.2.2
+      get-intrinsic: 1.2.4
 
   /graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
@@ -5567,40 +4764,31 @@ packages:
     resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==}
     dev: true
 
-  /has-flag@3.0.0:
-    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
-    engines: {node: '>=4'}
-    dev: true
-
   /has-flag@4.0.0:
     resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
     engines: {node: '>=8'}
 
-  /has-property-descriptors@1.0.1:
-    resolution: {integrity: sha512-VsX8eaIewvas0xnvinAe9bw4WfIeODpGYikiWYLH+dma0Jw6KHYqWiWfhQlgOVK8D6PvjubK5Uc4P0iIhIcNVg==}
+  /has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
     dependencies:
-      get-intrinsic: 1.2.2
+      es-define-property: 1.0.0
 
-  /has-proto@1.0.1:
-    resolution: {integrity: sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==}
+  /has-proto@1.0.3:
+    resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==}
     engines: {node: '>= 0.4'}
 
   /has-symbols@1.0.3:
     resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
     engines: {node: '>= 0.4'}
 
-  /has-tostringtag@1.0.0:
-    resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==}
+  /has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
     dependencies:
       has-symbols: 1.0.3
 
-  /has-unicode@2.0.1:
-    resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
-    dev: true
-
-  /hasown@2.0.0:
-    resolution: {integrity: sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==}
+  /hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
     dependencies:
       function-bind: 1.1.2
@@ -5614,31 +4802,11 @@ packages:
     resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
     dev: true
 
-  /https-proxy-agent@5.0.1:
-    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
-    engines: {node: '>= 6'}
-    dependencies:
-      agent-base: 6.0.2
-      debug: 4.3.5
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /human-signals@2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
     dev: true
 
-  /human-signals@4.3.1:
-    resolution: {integrity: sha512-nZXjEF2nbo7lIw3mgYjItAfgQXog3OjJogSbKa2CQIIvSGWcKgeJnQlNXip6NglNzYH45nSRiEVimMvYL8DDqQ==}
-    engines: {node: '>=14.18.0'}
-    dev: true
-
-  /human-signals@5.0.0:
-    resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}
-    engines: {node: '>=16.17.0'}
-    dev: true
-
   /humanize-ms@1.2.1:
     resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
     dependencies:
@@ -5647,11 +4815,6 @@ packages:
   /ieee754@1.2.1:
     resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
 
-  /ignore-by-default@2.1.0:
-    resolution: {integrity: sha512-yiWd4GVmJp0Q6ghmM2B/V3oZGRmjrKLXvHR3TE1nfoXsmoggllfZUQe74EN0fJdPFZu2NIvNdrMMLm3OsV7Ohw==}
-    engines: {node: '>=10 <11 || >=12 <13 || >=14'}
-    dev: true
-
   /ignore@5.2.4:
     resolution: {integrity: sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==}
     engines: {node: '>= 4'}
@@ -5684,11 +4847,6 @@ packages:
     engines: {node: '>=0.8.19'}
     dev: true
 
-  /indent-string@5.0.0:
-    resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==}
-    engines: {node: '>=12'}
-    dev: true
-
   /inflight@1.0.6:
     resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
     deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
@@ -5700,38 +4858,28 @@ packages:
   /inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
-  /internal-slot@1.0.6:
-    resolution: {integrity: sha512-Xj6dv+PsbtwyPpEflsejS+oIZxmMlV44zAhG479uYu89MsjcYOhCFnNyKrkJrihbsiasQyY0afoCl/9BLR65bg==}
+  /internal-slot@1.0.7:
+    resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.2
-      hasown: 2.0.0
+      es-errors: 1.3.0
+      hasown: 2.0.2
       side-channel: 1.0.4
     dev: true
 
-  /interpret@1.4.0:
-    resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==}
-    engines: {node: '>= 0.10'}
-    dev: true
-
-  /irregular-plurals@3.5.0:
-    resolution: {integrity: sha512-1ANGLZ+Nkv1ptFb2pa8oG8Lem4krflKuX/gINiHJHjJUKaJHk/SXk5x6K3J+39/p0h1RQ2saROclJJ+QLvETCQ==}
-    engines: {node: '>=8'}
-    dev: true
-
   /is-arguments@1.1.1:
     resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      has-tostringtag: 1.0.0
+      call-bind: 1.0.7
+      has-tostringtag: 1.0.2
 
-  /is-array-buffer@3.0.2:
-    resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==}
+  /is-array-buffer@3.0.4:
+    resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
-      is-typed-array: 1.1.12
+      call-bind: 1.0.7
+      get-intrinsic: 1.2.4
     dev: true
 
   /is-arrayish@0.2.1:
@@ -5755,44 +4903,33 @@ packages:
     resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      has-tostringtag: 1.0.0
-    dev: true
-
-  /is-builtin-module@3.2.1:
-    resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==}
-    engines: {node: '>=6'}
-    dependencies:
-      builtin-modules: 3.3.0
+      call-bind: 1.0.7
+      has-tostringtag: 1.0.2
     dev: true
 
   /is-callable@1.2.7:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
 
-  /is-core-module@2.13.1:
-    resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==}
+  /is-core-module@2.15.1:
+    resolution: {integrity: sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      hasown: 2.0.0
+      hasown: 2.0.2
     dev: true
 
-  /is-date-object@1.0.5:
-    resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==}
+  /is-data-view@1.0.1:
+    resolution: {integrity: sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==}
     engines: {node: '>= 0.4'}
     dependencies:
-      has-tostringtag: 1.0.0
+      is-typed-array: 1.1.13
     dev: true
 
-  /is-docker@2.2.1:
-    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
-    engines: {node: '>=8'}
-    hasBin: true
-    dev: true
-
-  /is-docker@3.0.0:
-    resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    hasBin: true
+  /is-date-object@1.0.5:
+    resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-tostringtag: 1.0.2
     dev: true
 
   /is-extglob@2.1.1:
@@ -5805,11 +4942,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /is-fullwidth-code-point@4.0.0:
-    resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
-    engines: {node: '>=12'}
-    dev: true
-
   /is-generator-fn@2.1.0:
     resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==}
     engines: {node: '>=6'}
@@ -5819,7 +4951,7 @@ packages:
     resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==}
     engines: {node: '>= 0.4'}
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   /is-glob@4.0.3:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
@@ -5828,29 +4960,21 @@ packages:
       is-extglob: 2.1.1
     dev: true
 
-  /is-immutable-type@3.1.0(eslint@8.57.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-EIAsgCk/4tEohdqKa5iGf1+IwoRYV/81Fe1awSspgobMxOmmxTZslvkH/PAtSKtR2NDFXGVkZZNqiLQA37GKBQ==}
+  /is-immutable-type@5.0.0(eslint@8.57.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-mcvHasqbRBWJznuPqqHRKiJgYAz60sZ0mvO3bN70JbkuK7ksfmgc489aKZYxMEjIbRvyOseaTjaRZLRF/xFeRA==}
     peerDependencies:
       eslint: '*'
       typescript: '>=4.7.4'
     dependencies:
-      '@typescript-eslint/type-utils': 7.13.1(eslint@8.57.0)(typescript@5.4.5)
+      '@typescript-eslint/type-utils': 8.12.2(eslint@8.57.0)(typescript@5.7.2)
       eslint: 8.57.0
-      ts-api-utils: 1.3.0(typescript@5.4.5)
-      ts-declaration-location: 1.0.0(typescript@5.4.5)
-      typescript: 5.4.5
+      ts-api-utils: 1.3.0(typescript@5.7.2)
+      ts-declaration-location: 1.0.4(typescript@5.7.2)
+      typescript: 5.7.2
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /is-inside-container@1.0.0:
-    resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
-    engines: {node: '>=14.16'}
-    hasBin: true
-    dependencies:
-      is-docker: 3.0.0
-    dev: true
-
   /is-module@1.0.0:
     resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==}
     dev: true
@@ -5859,11 +4983,11 @@ packages:
     resolution: {integrity: sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
 
-  /is-negative-zero@2.0.2:
-    resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==}
+  /is-negative-zero@2.0.3:
+    resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==}
     engines: {node: '>= 0.4'}
     dev: true
 
@@ -5871,7 +4995,7 @@ packages:
     resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
     dev: true
 
   /is-number@7.0.0:
@@ -5889,33 +5013,25 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /is-plain-object@5.0.0:
-    resolution: {integrity: sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /is-promise@4.0.0:
-    resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
-    dev: true
-
   /is-reference@1.2.1:
     resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
     dependencies:
-      '@types/estree': 1.0.5
+      '@types/estree': 1.0.6
     dev: true
 
   /is-regex@1.1.4:
     resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      has-tostringtag: 1.0.0
+      call-bind: 1.0.7
+      has-tostringtag: 1.0.2
     dev: true
 
-  /is-shared-array-buffer@1.0.2:
-    resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==}
+  /is-shared-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
     dev: true
 
   /is-stream@2.0.1:
@@ -5923,16 +5039,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /is-stream@3.0.0:
-    resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dev: true
-
   /is-string@1.0.7:
     resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
     dev: true
 
   /is-symbol@1.0.4:
@@ -5942,33 +5053,21 @@ packages:
       has-symbols: 1.0.3
     dev: true
 
-  /is-typed-array@1.1.12:
-    resolution: {integrity: sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==}
+  /is-typed-array@1.1.13:
+    resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      which-typed-array: 1.1.13
+      which-typed-array: 1.1.15
 
   /is-unicode-supported@0.1.0:
     resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
     engines: {node: '>=10'}
     dev: true
 
-  /is-unicode-supported@2.0.0:
-    resolution: {integrity: sha512-FRdAyx5lusK1iHG0TWpVtk9+1i+GjrzRffhDg4ovQ7mcidMQ6mj+MhKPmvh7Xwyv5gIS06ns49CA7Sqg7lC22Q==}
-    engines: {node: '>=18'}
-    dev: true
-
   /is-weakref@1.0.2:
     resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==}
     dependencies:
-      call-bind: 1.0.5
-    dev: true
-
-  /is-wsl@2.2.0:
-    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
-    engines: {node: '>=8'}
-    dependencies:
-      is-docker: 2.2.1
+      call-bind: 1.0.7
     dev: true
 
   /isarray@2.0.5:
@@ -5979,12 +5078,12 @@ packages:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
     dev: true
 
-  /isomorphic-ws@4.0.1(ws@7.5.9):
+  /isomorphic-ws@4.0.1(ws@7.5.10):
     resolution: {integrity: sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==}
     peerDependencies:
       ws: '*'
     dependencies:
-      ws: 7.5.9
+      ws: 7.5.10
 
   /istanbul-lib-coverage@3.2.1:
     resolution: {integrity: sha512-opCrKqbthmq3SKZ10mFMQG9dk3fTa3quaOLD35kJa5ejwZHd9xAr+kLuziiZz2cG32s4lMZxNdmdcEQnTDP4+g==}
@@ -5995,7 +5094,7 @@ packages:
     resolution: {integrity: sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==}
     engines: {node: '>=8'}
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/parser': 7.23.0
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.1
@@ -6008,11 +5107,24 @@ packages:
     resolution: {integrity: sha512-EAMEJBsYuyyztxMxW3g7ugGPkrZsV57v0Hmv3mm1uQsmB+QnZuepg731CRaIgeUVSdmsTngOkSnauNF8p7FIhA==}
     engines: {node: '>=10'}
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@babel/parser': 7.23.0
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.1
-      semver: 7.6.0
+      semver: 7.6.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /istanbul-lib-instrument@6.0.3:
+    resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/parser': 7.26.2
+      '@istanbuljs/schema': 0.1.3
+      istanbul-lib-coverage: 3.2.1
+      semver: 7.6.3
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -6030,13 +5142,24 @@ packages:
     resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==}
     engines: {node: '>=10'}
     dependencies:
-      debug: 4.3.5
+      debug: 4.4.0
       istanbul-lib-coverage: 3.2.1
       source-map: 0.6.1
     transitivePeerDependencies:
       - supports-color
     dev: true
 
+  /istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.25
+      debug: 4.4.0
+      istanbul-lib-coverage: 3.2.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /istanbul-reports@3.1.6:
     resolution: {integrity: sha512-TLgnMkKg3iTDsQ9PbPTdpfAK2DzjF9mqUG7RMgcQl8oFjad8ob4laGxv5XV5U9MAfx8D6tSJiUyuAwzLicaxlg==}
     engines: {node: '>=8'}
@@ -6045,26 +5168,27 @@ packages:
       istanbul-lib-report: 3.0.1
     dev: true
 
-  /jackspeak@2.3.6:
-    resolution: {integrity: sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==}
-    engines: {node: '>=14'}
+  /jackspeak@3.4.3:
+    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
     dependencies:
       '@isaacs/cliui': 8.0.2
     optionalDependencies:
       '@pkgjs/parseargs': 0.11.0
     dev: true
 
-  /jackspeak@3.4.0:
-    resolution: {integrity: sha512-JVYhQnN59LVPFCEcVa2C3CrEKYacvjRfqIQl+h8oi91aLYQVWRYbxjPcv1bUiUy/kLmQaANrYfNMCO3kuEDHfw==}
-    engines: {node: '>=14'}
+  /jake@10.9.1:
+    resolution: {integrity: sha512-61btcOHNnLnsOdtLgA5efqQWjnSi/vow5HbI7HMdKKWqvrKR1bLK3BPlJn9gcSaP2ewuamUSMB5XEy76KUIS2w==}
+    engines: {node: '>=10'}
+    hasBin: true
     dependencies:
-      '@isaacs/cliui': 8.0.2
-    optionalDependencies:
-      '@pkgjs/parseargs': 0.11.0
+      async: 3.2.5
+      chalk: 4.1.2
+      filelist: 1.0.4
+      minimatch: 3.1.2
     dev: true
 
-  /jayson@4.1.0:
-    resolution: {integrity: sha512-R6JlbyLN53Mjku329XoRT2zJAE6ZgOQ8f91ucYdMCD4nkGCF9kZSrcGXpHIU4jeKj58zUZke2p+cdQchU7Ly7A==}
+  /jayson@4.1.1:
+    resolution: {integrity: sha512-5ZWm4Q/0DHPyeMfAsrwViwUS2DMVsQgWh8bEEIVTkfb3DzHZ2L3G5WUnF+AKmGjjM9r1uAv73SaqC1/U4RL45w==}
     engines: {node: '>=8'}
     hasBin: true
     dependencies:
@@ -6076,10 +5200,10 @@ packages:
       delay: 5.0.0
       es6-promisify: 5.0.0
       eyes: 0.1.8
-      isomorphic-ws: 4.0.1(ws@7.5.9)
+      isomorphic-ws: 4.0.1(ws@7.5.10)
       json-stringify-safe: 5.0.1
       uuid: 8.3.2
-      ws: 7.5.9
+      ws: 7.5.10
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -6093,6 +5217,15 @@ packages:
       p-limit: 3.1.0
     dev: true
 
+  /jest-changed-files@30.0.0-alpha.6:
+    resolution: {integrity: sha512-Fmyt6W27L4fRBl/gReFC4WU+3XIqB7ySHu+a9QxrERapfCb43o7y81TCvTwJHSw5dxGzXLOObVB0tRMDWMafnw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      execa: 5.1.1
+      jest-util: 30.0.0-alpha.6
+      p-limit: 3.1.0
+    dev: true
+
   /jest-circus@29.7.0:
     resolution: {integrity: sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6101,7 +5234,7 @@ packages:
       '@jest/expect': 29.7.0
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       co: 4.6.0
       dedent: 1.5.1
@@ -6122,7 +5255,36 @@ packages:
       - supports-color
     dev: true
 
-  /jest-cli@29.7.0(@types/node@20.14.5)(ts-node@10.9.2):
+  /jest-circus@30.0.0-alpha.6:
+    resolution: {integrity: sha512-1C62WeTyWinn6zR61syYKe5yqVbV+ftf21vOgj8AtTxGfMUAlGCpeZ5zh4Kc9Qk7r/PiPiHWZtgZmeT4oe9Dug==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/environment': 30.0.0-alpha.6
+      '@jest/expect': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      co: 4.6.0
+      dedent: 1.5.1
+      is-generator-fn: 2.1.0
+      jest-each: 30.0.0-alpha.6
+      jest-matcher-utils: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-runtime: 30.0.0-alpha.6
+      jest-snapshot: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      p-limit: 3.1.0
+      pretty-format: 30.0.0-alpha.6
+      pure-rand: 6.0.4
+      slash: 3.0.0
+      stack-utils: 2.0.6
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - supports-color
+    dev: true
+
+  /jest-cli@29.7.0(@types/node@22.10.5)(ts-node@10.9.2):
     resolution: {integrity: sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     hasBin: true
@@ -6136,10 +5298,10 @@ packages:
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
       chalk: 4.1.2
-      create-jest: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      create-jest: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       exit: 0.1.2
       import-local: 3.1.0
-      jest-config: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      jest-config: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       jest-util: 29.7.0
       jest-validate: 29.7.0
       yargs: 17.7.2
@@ -6150,7 +5312,35 @@ packages:
       - ts-node
     dev: true
 
-  /jest-config@29.7.0(@types/node@20.14.5)(ts-node@10.9.2):
+  /jest-cli@30.0.0-alpha.6:
+    resolution: {integrity: sha512-3VYzI2KgpMNAsf+LdRAQtAbhH3IDyFnT36U6URXot+2JWwoCGQQ6w4HIfqyOSlH4aejKgTPSfxki2shRPDFtlQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/core': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      chalk: 4.1.2
+      exit: 0.1.2
+      import-local: 3.1.0
+      jest-config: 30.0.0-alpha.6(@types/node@22.10.5)
+      jest-util: 30.0.0-alpha.6
+      jest-validate: 30.0.0-alpha.6
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    dev: true
+
+  /jest-config@29.7.0(@types/node@22.10.5)(ts-node@10.9.2):
     resolution: {integrity: sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     peerDependencies:
@@ -6162,11 +5352,11 @@ packages:
       ts-node:
         optional: true
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       '@jest/test-sequencer': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
-      babel-jest: 29.7.0(@babel/core@7.23.2)
+      '@types/node': 22.10.5
+      babel-jest: 29.7.0(@babel/core@7.26.0)
       chalk: 4.1.2
       ci-info: 3.9.0
       deepmerge: 4.3.1
@@ -6180,12 +5370,57 @@ packages:
       jest-runner: 29.7.0
       jest-util: 29.7.0
       jest-validate: 29.7.0
-      micromatch: 4.0.5
+      micromatch: 4.0.8
       parse-json: 5.2.0
       pretty-format: 29.7.0
       slash: 3.0.0
       strip-json-comments: 3.1.1
-      ts-node: 10.9.2(@types/node@20.14.5)(typescript@5.4.5)
+      ts-node: 10.9.2(@types/node@22.10.5)(typescript@5.7.2)
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - supports-color
+    dev: true
+
+  /jest-config@30.0.0-alpha.6(@types/node@22.10.5):
+    resolution: {integrity: sha512-Tq9rH1mg9+nlIhh3efGwMSogFVKZ9z7c6P33ZlK74iJlnqqIAKYERZL2nNmNC5+5p8uxlTPSFZfBz9O8NGKotw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    peerDependencies:
+      '@types/node': '*'
+      esbuild-register: '>=3.4.0'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      esbuild-register:
+        optional: true
+      ts-node:
+        optional: true
+    dependencies:
+      '@babel/core': 7.26.0
+      '@jest/pattern': 30.0.0-alpha.6
+      '@jest/test-sequencer': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      babel-jest: 30.0.0-alpha.6(@babel/core@7.26.0)
+      chalk: 4.1.2
+      ci-info: 4.0.0
+      deepmerge: 4.3.1
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      jest-circus: 30.0.0-alpha.6
+      jest-docblock: 30.0.0-alpha.6
+      jest-environment-node: 30.0.0-alpha.6
+      jest-get-type: 30.0.0-alpha.6
+      jest-regex-util: 30.0.0-alpha.6
+      jest-resolve: 30.0.0-alpha.6
+      jest-runner: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      jest-validate: 30.0.0-alpha.6
+      micromatch: 4.0.8
+      parse-json: 5.2.0
+      pretty-format: 30.0.0-alpha.6
+      slash: 3.0.0
+      strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - babel-plugin-macros
       - supports-color
@@ -6201,6 +5436,16 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
+  /jest-diff@30.0.0-alpha.6:
+    resolution: {integrity: sha512-43j1DoYwVKrkbB67a2gC0ijjIY9biF0JSPXv7H6zlOkzNlqYg8hSDzrurLNo6zGKatW4JSBLE79LmXPJPj1m6A==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      chalk: 4.1.2
+      diff-sequences: 30.0.0-alpha.6
+      jest-get-type: 30.0.0-alpha.6
+      pretty-format: 30.0.0-alpha.6
+    dev: true
+
   /jest-docblock@29.7.0:
     resolution: {integrity: sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6208,6 +5453,13 @@ packages:
       detect-newline: 3.1.0
     dev: true
 
+  /jest-docblock@30.0.0-alpha.6:
+    resolution: {integrity: sha512-KXRLgRo7/rF1wqxQupsFCZa6wOp1qrDg4GdSXKfIHODYQb0dpi4rYaYA8xV5l2g9KwYc9/zV7l1tPe9TOr27ew==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      detect-newline: 3.1.0
+    dev: true
+
   /jest-each@29.7.0:
     resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6219,6 +5471,17 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
+  /jest-each@30.0.0-alpha.6:
+    resolution: {integrity: sha512-snLI2JNYkoBMlZRrNk67XiauUy+uEzRCszKdj+cqHyZ4/MU8fz7gCxbn3g0zmiGUxr0RX0534UxMjc82Sk++tg==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      chalk: 4.1.2
+      jest-get-type: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      pretty-format: 30.0.0-alpha.6
+    dev: true
+
   /jest-environment-node@29.7.0:
     resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6226,30 +5489,65 @@ packages:
       '@jest/environment': 29.7.0
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       jest-mock: 29.7.0
       jest-util: 29.7.0
     dev: true
 
+  /jest-environment-node@30.0.0-alpha.6:
+    resolution: {integrity: sha512-UN9W3dFzO150Bqj1x+1pq7dMUqw/QhpqhdtmC3B1P6GD9eKEMFGuRw3EButx5SGzrZOqRNlF+tUNC8CoWGW2Og==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/environment': 30.0.0-alpha.6
+      '@jest/fake-timers': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      jest-mock: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+    dev: true
+
   /jest-get-type@29.6.3:
     resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dev: true
 
+  /jest-get-type@30.0.0-alpha.6:
+    resolution: {integrity: sha512-lJEoQdCY4ICN6+T0lJ9BODKuqPOEpCv2NnJsEO1nmsK0fbWZmN/pgOPHVqLfK8i3jZpUmgupJ1w8r36mc8iiBQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dev: true
+
   /jest-haste-map@29.7.0:
     resolution: {integrity: sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/types': 29.6.3
       '@types/graceful-fs': 4.1.9
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       anymatch: 3.1.3
       fb-watchman: 2.0.2
       graceful-fs: 4.2.11
       jest-regex-util: 29.6.3
       jest-util: 29.7.0
       jest-worker: 29.7.0
-      micromatch: 4.0.5
+      micromatch: 4.0.8
+      walker: 1.0.8
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: true
+
+  /jest-haste-map@30.0.0-alpha.6:
+    resolution: {integrity: sha512-NR/Kw8HyOkuWIdT8ynsp9KnsTDvWnlz8WSOmtQxySTIzOWbZaeJ2FJi9LoDL6+vhKpdlLfUvhgZVtnFJSLCzew==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      anymatch: 3.1.3
+      fb-watchman: 2.0.2
+      graceful-fs: 4.2.11
+      jest-regex-util: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      jest-worker: 30.0.0-alpha.6
+      micromatch: 4.0.8
       walker: 1.0.8
     optionalDependencies:
       fsevents: 2.3.3
@@ -6263,6 +5561,14 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
+  /jest-leak-detector@30.0.0-alpha.6:
+    resolution: {integrity: sha512-a6fh/6h6dCDyj+aplGqkajVqzmi+qYHs5X8orMZv+u56++gUezJZJf8GCiQqw2vtxcsWVPUuQXa3kF33tAYzNQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      jest-get-type: 30.0.0-alpha.6
+      pretty-format: 30.0.0-alpha.6
+    dev: true
+
   /jest-matcher-utils@29.7.0:
     resolution: {integrity: sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6273,30 +5579,64 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
+  /jest-matcher-utils@30.0.0-alpha.6:
+    resolution: {integrity: sha512-jaq7+HznsK54G0qzu96ZwfMEKHmlPiDqg6qG2p/hVQzr6Y/qVMRh8abI9Y1lX6SSXkr+S9mPAkmOsuJNLTLYmQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      chalk: 4.1.2
+      jest-diff: 30.0.0-alpha.6
+      jest-get-type: 30.0.0-alpha.6
+      pretty-format: 30.0.0-alpha.6
+    dev: true
+
   /jest-message-util@29.7.0:
     resolution: {integrity: sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@babel/code-frame': 7.24.2
+      '@babel/code-frame': 7.26.2
       '@jest/types': 29.6.3
       '@types/stack-utils': 2.0.3
       chalk: 4.1.2
       graceful-fs: 4.2.11
-      micromatch: 4.0.5
+      micromatch: 4.0.8
       pretty-format: 29.7.0
       slash: 3.0.0
       stack-utils: 2.0.6
     dev: true
 
+  /jest-message-util@30.0.0-alpha.6:
+    resolution: {integrity: sha512-XAGJqkrBo7m3bFxWqiNqL0PyAWGf1XHR6bTve90MjBKJuIzhJsounGTzBNUw8JoU7Uzcj5Z6ZmEhaE3CDnwjfw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@babel/code-frame': 7.26.2
+      '@jest/types': 30.0.0-alpha.6
+      '@types/stack-utils': 2.0.3
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      micromatch: 4.0.8
+      pretty-format: 30.0.0-alpha.6
+      slash: 3.0.0
+      stack-utils: 2.0.6
+    dev: true
+
   /jest-mock@29.7.0:
     resolution: {integrity: sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       jest-util: 29.7.0
     dev: true
 
+  /jest-mock@30.0.0-alpha.6:
+    resolution: {integrity: sha512-ezW02IXiKyFYAgDuxfAlONWULitSaB66t411fq2BJxQtgyMGtv59CsnhgbKb0gQp+9vig5MO5ytDCUPalTbarg==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      jest-util: 30.0.0-alpha.6
+    dev: true
+
   /jest-pnp-resolver@1.2.3(jest-resolve@29.7.0):
     resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==}
     engines: {node: '>=6'}
@@ -6309,11 +5649,28 @@ packages:
       jest-resolve: 29.7.0
     dev: true
 
+  /jest-pnp-resolver@1.2.3(jest-resolve@30.0.0-alpha.6):
+    resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==}
+    engines: {node: '>=6'}
+    peerDependencies:
+      jest-resolve: '*'
+    peerDependenciesMeta:
+      jest-resolve:
+        optional: true
+    dependencies:
+      jest-resolve: 30.0.0-alpha.6
+    dev: true
+
   /jest-regex-util@29.6.3:
     resolution: {integrity: sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dev: true
 
+  /jest-regex-util@30.0.0-alpha.6:
+    resolution: {integrity: sha512-XcsAVaqc69QyMz1/FChyhWSoAMaKcDPhFOuWJz/H51LppsyZRAJPXkPnMopsS+qfut8cggExr9QLcsYaX6hqqA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dev: true
+
   /jest-resolve-dependencies@29.7.0:
     resolution: {integrity: sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6324,6 +5681,16 @@ packages:
       - supports-color
     dev: true
 
+  /jest-resolve-dependencies@30.0.0-alpha.6:
+    resolution: {integrity: sha512-G+st0nBR4FNIvVCHq8YNJBiG6t7u0+cxM099lbtOoJNJU+ZTdIxSyzPnnmp/C+YHd1QOlDNlplvL+xe1KHhPUA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      jest-regex-util: 30.0.0-alpha.6
+      jest-snapshot: 30.0.0-alpha.6
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /jest-resolve@29.7.0:
     resolution: {integrity: sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6339,6 +5706,21 @@ packages:
       slash: 3.0.0
     dev: true
 
+  /jest-resolve@30.0.0-alpha.6:
+    resolution: {integrity: sha512-0EyeId+RFng52qHvuxOzKjZd2uDF/2Hdzpzt54+biGgY/VVAvf8mYE9UV7g6154Ozpq6KLztSqqMCfPgVs4CbA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.0.0-alpha.6
+      jest-pnp-resolver: 1.2.3(jest-resolve@30.0.0-alpha.6)
+      jest-util: 30.0.0-alpha.6
+      jest-validate: 30.0.0-alpha.6
+      resolve: 1.22.8
+      resolve.exports: 2.0.2
+      slash: 3.0.0
+    dev: true
+
   /jest-runner@29.7.0:
     resolution: {integrity: sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6348,7 +5730,7 @@ packages:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       emittery: 0.13.1
       graceful-fs: 4.2.11
@@ -6368,6 +5750,35 @@ packages:
       - supports-color
     dev: true
 
+  /jest-runner@30.0.0-alpha.6:
+    resolution: {integrity: sha512-SoADy4YnspMpXLNnRCXNIoinm1N5SMci+iF6Y29Duv3wnWhcL14XjEOcyUKBB+AIL52YwouLeUHkCyCspbBk1Q==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/console': 30.0.0-alpha.6
+      '@jest/environment': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/transform': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      emittery: 0.13.1
+      graceful-fs: 4.2.11
+      jest-docblock: 30.0.0-alpha.6
+      jest-environment-node: 30.0.0-alpha.6
+      jest-haste-map: 30.0.0-alpha.6
+      jest-leak-detector: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-resolve: 30.0.0-alpha.6
+      jest-runtime: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      jest-watcher: 30.0.0-alpha.6
+      jest-worker: 30.0.0-alpha.6
+      p-limit: 3.1.0
+      source-map-support: 0.5.13
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /jest-runtime@29.7.0:
     resolution: {integrity: sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6379,7 +5790,7 @@ packages:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       cjs-module-lexer: 1.2.3
       collect-v8-coverage: 1.0.2
@@ -6398,19 +5809,49 @@ packages:
       - supports-color
     dev: true
 
+  /jest-runtime@30.0.0-alpha.6:
+    resolution: {integrity: sha512-p7w7DSFFzwHyR4HsNXca/p32VpL9MLT1c71+VplFJIEgeRHvyqxrARentlul6uJniwtlqvZrVVf5baCQ5a5GUw==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/environment': 30.0.0-alpha.6
+      '@jest/fake-timers': 30.0.0-alpha.6
+      '@jest/globals': 30.0.0-alpha.6
+      '@jest/source-map': 30.0.0-alpha.6
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/transform': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      cjs-module-lexer: 1.2.3
+      collect-v8-coverage: 1.0.2
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-mock: 30.0.0-alpha.6
+      jest-regex-util: 30.0.0-alpha.6
+      jest-resolve: 30.0.0-alpha.6
+      jest-snapshot: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      slash: 3.0.0
+      strip-bom: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /jest-snapshot@29.7.0:
     resolution: {integrity: sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@babel/core': 7.23.2
-      '@babel/generator': 7.23.0
-      '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.23.2)
-      '@babel/plugin-syntax-typescript': 7.22.5(@babel/core@7.23.2)
-      '@babel/types': 7.23.0
+      '@babel/core': 7.26.0
+      '@babel/generator': 7.26.2
+      '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.26.0)
+      '@babel/plugin-syntax-typescript': 7.22.5(@babel/core@7.26.0)
+      '@babel/types': 7.26.0
       '@jest/expect-utils': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.23.2)
+      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.26.0)
       chalk: 4.1.2
       expect: 29.7.0
       graceful-fs: 4.2.11
@@ -6421,7 +5862,36 @@ packages:
       jest-util: 29.7.0
       natural-compare: 1.4.0
       pretty-format: 29.7.0
-      semver: 7.6.0
+      semver: 7.6.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /jest-snapshot@30.0.0-alpha.6:
+    resolution: {integrity: sha512-YCBUxSNJ9YGch3tyQdxQkOUitbmXahHL6UhSQeSMERFfX1UMrHyEDHggglocCUg4G3jdU8YzshxOJ/oaR6Ph8w==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@babel/core': 7.26.0
+      '@babel/generator': 7.26.2
+      '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.26.0)
+      '@babel/plugin-syntax-typescript': 7.22.5(@babel/core@7.26.0)
+      '@babel/types': 7.26.0
+      '@jest/expect-utils': 30.0.0-alpha.6
+      '@jest/snapshot-utils': 30.0.0-alpha.6
+      '@jest/transform': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      babel-preset-current-node-syntax: 1.0.1(@babel/core@7.26.0)
+      chalk: 4.1.2
+      expect: 30.0.0-alpha.6
+      graceful-fs: 4.2.11
+      jest-diff: 30.0.0-alpha.6
+      jest-get-type: 30.0.0-alpha.6
+      jest-matcher-utils: 30.0.0-alpha.6
+      jest-message-util: 30.0.0-alpha.6
+      jest-util: 30.0.0-alpha.6
+      pretty-format: 30.0.0-alpha.6
+      semver: 7.6.3
+      synckit: 0.9.1
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -6431,13 +5901,25 @@ packages:
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       chalk: 4.1.2
       ci-info: 3.9.0
       graceful-fs: 4.2.11
       picomatch: 2.3.1
     dev: true
 
+  /jest-util@30.0.0-alpha.6:
+    resolution: {integrity: sha512-JlimakOVDyoMC8TEG+knoufxUqLG+Btihf1G8o5sHxz54C6oL54Wetfepp+Nhuj/1hSL0sQtkovvjlEycf9i0w==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      chalk: 4.1.2
+      ci-info: 4.0.0
+      graceful-fs: 4.2.11
+      picomatch: 4.0.2
+    dev: true
+
   /jest-validate@29.7.0:
     resolution: {integrity: sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -6450,13 +5932,25 @@ packages:
       pretty-format: 29.7.0
     dev: true
 
+  /jest-validate@30.0.0-alpha.6:
+    resolution: {integrity: sha512-sINLwCenOUeJVzS5p+o1NhwKsY0de5Es0J7bsaSuZJQGRY67W20idceflr+aZ2akrKgvvqU8Tsg6lkFQyq+a6Q==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/types': 30.0.0-alpha.6
+      camelcase: 6.3.0
+      chalk: 4.1.2
+      jest-get-type: 30.0.0-alpha.6
+      leven: 3.1.0
+      pretty-format: 30.0.0-alpha.6
+    dev: true
+
   /jest-watcher@29.7.0:
     resolution: {integrity: sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       emittery: 0.13.1
@@ -6464,17 +5958,42 @@ packages:
       string-length: 4.0.2
     dev: true
 
+  /jest-watcher@30.0.0-alpha.6:
+    resolution: {integrity: sha512-+zL1y3GSJG8EOxVSc2p0dndis0rNDcwKTs4b1bpNTI0XneeTiZlCpRBNYI+sqBl/eZtJBrQdiBRSYz7kJqg7NQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@jest/test-result': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      '@types/node': 22.10.5
+      ansi-escapes: 4.3.2
+      chalk: 4.1.2
+      emittery: 0.13.1
+      jest-util: 30.0.0-alpha.6
+      string-length: 4.0.2
+    dev: true
+
   /jest-worker@29.7.0:
     resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     dependencies:
-      '@types/node': 20.14.5
+      '@types/node': 22.10.5
       jest-util: 29.7.0
       merge-stream: 2.0.0
       supports-color: 8.1.1
     dev: true
 
-  /jest@29.7.0(@types/node@20.14.5)(ts-node@10.9.2):
+  /jest-worker@30.0.0-alpha.6:
+    resolution: {integrity: sha512-qlzX7zFT/QdUV/LWsJwZBlaIBaJ+E2VH3d1gArGVP+9hUHGpJkEzCSBK7yuZrkt+M/U0Jre5+maPRmkinEF4DA==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    dependencies:
+      '@types/node': 22.10.5
+      '@ungap/structured-clone': 1.2.0
+      jest-util: 30.0.0-alpha.6
+      merge-stream: 2.0.0
+      supports-color: 8.1.1
+    dev: true
+
+  /jest@29.7.0(@types/node@22.10.5)(ts-node@10.9.2):
     resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
     hasBin: true
@@ -6487,20 +6006,42 @@ packages:
       '@jest/core': 29.7.0(ts-node@10.9.2)
       '@jest/types': 29.6.3
       import-local: 3.1.0
-      jest-cli: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      jest-cli: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - supports-color
+      - ts-node
+    dev: true
+
+  /jest@30.0.0-alpha.6:
+    resolution: {integrity: sha512-9T3nAcIAcEpCX2MdxcjG2IDfG/0tjumnCkVNGh+AKkRXcWF4Er5jLROKvXsgXUJCmr/nMqLF6LG0GrDJ0kjFag==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/core': 30.0.0-alpha.6
+      '@jest/types': 30.0.0-alpha.6
+      import-local: 3.1.0
+      jest-cli: 30.0.0-alpha.6
     transitivePeerDependencies:
       - '@types/node'
       - babel-plugin-macros
+      - esbuild-register
       - supports-color
       - ts-node
     dev: true
 
-  /joi@17.11.0:
-    resolution: {integrity: sha512-NgB+lZLNoqISVy1rZocE9PZI36bL/77ie924Ri43yEvi9GUUMPeyVIr8KdFTMUlby1p0PBYMk9spIxEUQYqrJQ==}
+  /joi@17.13.3:
+    resolution: {integrity: sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==}
     dependencies:
       '@hapi/hoek': 9.3.0
       '@hapi/topo': 5.1.0
-      '@sideway/address': 4.1.4
+      '@sideway/address': 4.1.5
       '@sideway/formula': 3.0.1
       '@sideway/pinpoint': 2.0.0
     dev: true
@@ -6513,11 +6054,6 @@ packages:
     resolution: {integrity: sha512-BcJPCQeLg6WjEx3FE591wVAevlli8lxsxm9/FzV4HXkV49TmBH38Yvrpce6fjbADGMKFrBMGTqrVz3qPIZ88Gg==}
     dev: false
 
-  /js-string-escape@1.0.1:
-    resolution: {integrity: sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==}
-    engines: {node: '>= 0.8'}
-    dev: true
-
   /js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
@@ -6537,9 +6073,9 @@ packages:
       argparse: 2.0.1
     dev: true
 
-  /jsesc@2.5.2:
-    resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==}
-    engines: {node: '>=4'}
+  /jsesc@3.0.2:
+    resolution: {integrity: sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==}
+    engines: {node: '>=6'}
     hasBin: true
     dev: true
 
@@ -6579,10 +6115,6 @@ packages:
     hasBin: true
     dev: true
 
-  /jsonc-parser@3.2.0:
-    resolution: {integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==}
-    dev: true
-
   /jsonfile@6.1.0:
     resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
     dependencies:
@@ -6628,9 +6160,10 @@ packages:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
 
-  /load-json-file@7.0.1:
-    resolution: {integrity: sha512-Gnxj3ev3mB5TkVBGad0JM6dmLiQL+o0t23JPBZ9sd+yvSLk05mFoqKBw5N8gbbkU4TNXyqCgIrl/VM17OgUIgQ==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+  /linkify-it@5.0.0:
+    resolution: {integrity: sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==}
+    dependencies:
+      uc.micro: 2.1.0
     dev: true
 
   /locate-path@5.0.0:
@@ -6667,21 +6200,14 @@ packages:
       is-unicode-supported: 0.1.0
     dev: true
 
-  /loupe@3.1.0:
-    resolution: {integrity: sha512-qKl+FrLXUhFuHUoDJG7f8P8gEMHq9NFS0c6ghXG1J0rldmZFQZoNVv/vyirE9qwCIhWZDsvEFd1sbFu3GvRQFg==}
-    dependencies:
-      get-func-name: 2.0.2
-    dev: true
-
   /lower-case@2.0.2:
     resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==}
     dependencies:
-      tslib: 2.6.3
+      tslib: 2.8.1
     dev: true
 
-  /lru-cache@10.2.2:
-    resolution: {integrity: sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==}
-    engines: {node: 14 || >=16.14}
+  /lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
     dev: true
 
   /lru-cache@5.1.1:
@@ -6690,13 +6216,6 @@ packages:
       yallist: 3.1.1
     dev: true
 
-  /lru-cache@6.0.0:
-    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
-    engines: {node: '>=10'}
-    dependencies:
-      yallist: 4.0.0
-    dev: true
-
   /lunr@2.3.9:
     resolution: {integrity: sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==}
     dev: true
@@ -6718,7 +6237,7 @@ packages:
     resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
     engines: {node: '>=10'}
     dependencies:
-      semver: 7.6.0
+      semver: 7.6.3
     dev: true
 
   /make-error@1.3.6:
@@ -6735,39 +6254,20 @@ packages:
     resolution: {integrity: sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g==}
     dev: true
 
-  /marked@4.3.0:
-    resolution: {integrity: sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==}
-    engines: {node: '>= 12'}
+  /markdown-it@14.1.0:
+    resolution: {integrity: sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==}
     hasBin: true
-    dev: true
-
-  /matched@5.0.1:
-    resolution: {integrity: sha512-E1fhSTPRyhAlNaNvGXAgZQlq1hL0bgYMTk/6bktVlIhzUnX/SZs7296ACdVeNJE8xFNGSuvd9IpI7vSnmcqLvw==}
-    engines: {node: '>=10'}
-    dependencies:
-      glob: 7.2.3
-      picomatch: 2.3.1
-    dev: true
-
-  /matcher@5.0.0:
-    resolution: {integrity: sha512-s2EMBOWtXFc8dgqvoAzKJXxNHibcdJMV0gwqKUaw9E2JBJuGUK7DrNKrA6g/i+v72TT16+6sVm5mS3thaMLQUw==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dependencies:
-      escape-string-regexp: 5.0.0
-    dev: true
-
-  /md5-hex@3.0.1:
-    resolution: {integrity: sha512-BUiRtTtV39LIJwinWBjqVsU9xhdnz7/i889V859IBFpuqGAj6LuOvHv5XLbgZ2R7ptJoJaEcxkv88/h25T7Ciw==}
-    engines: {node: '>=8'}
-    dependencies:
-      blueimp-md5: 2.19.0
+      argparse: 2.0.1
+      entities: 4.5.0
+      linkify-it: 5.0.0
+      mdurl: 2.0.0
+      punycode.js: 2.3.1
+      uc.micro: 2.1.0
     dev: true
 
-  /memoize@10.0.0:
-    resolution: {integrity: sha512-H6cBLgsi6vMWOcCpvVCdFFnl3kerEXbrYh9q+lY6VXvQSmM6CkmV08VOwT+WE2tzIEqRPFfAq3fm4v/UIW6mSA==}
-    engines: {node: '>=18'}
-    dependencies:
-      mimic-function: 5.0.0
+  /mdurl@2.0.0:
+    resolution: {integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==}
     dev: true
 
   /merge-stream@2.0.0:
@@ -6783,7 +6283,15 @@ packages:
     resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
     engines: {node: '>=8.6'}
     dependencies:
-      braces: 3.0.2
+      braces: 3.0.3
+      picomatch: 2.3.1
+    dev: true
+
+  /micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+    dependencies:
+      braces: 3.0.3
       picomatch: 2.3.1
     dev: true
 
@@ -6804,14 +6312,11 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /mimic-fn@4.0.0:
-    resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
-    engines: {node: '>=12'}
-    dev: true
-
-  /mimic-function@5.0.0:
-    resolution: {integrity: sha512-RBfQ+9X9DpXdEoK7Bu+KeEU6vFhumEIiXKWECPzRBmDserEq4uR2b/VCm0LwpMSosoq2k+Zuxj/GzOr0Fn6h/g==}
-    engines: {node: '>=18'}
+  /minimatch@10.0.1:
+    resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==}
+    engines: {node: 20 || >=22}
+    dependencies:
+      brace-expansion: 2.0.1
     dev: true
 
   /minimatch@3.1.2:
@@ -6820,13 +6325,6 @@ packages:
       brace-expansion: 1.1.11
     dev: true
 
-  /minimatch@5.0.1:
-    resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==}
-    engines: {node: '>=10'}
-    dependencies:
-      brace-expansion: 2.0.1
-    dev: true
-
   /minimatch@5.1.6:
     resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==}
     engines: {node: '>=10'}
@@ -6834,15 +6332,8 @@ packages:
       brace-expansion: 2.0.1
     dev: true
 
-  /minimatch@9.0.3:
-    resolution: {integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==}
-    engines: {node: '>=16 || 14 >=14.17'}
-    dependencies:
-      brace-expansion: 2.0.1
-    dev: true
-
-  /minimatch@9.0.4:
-    resolution: {integrity: sha512-KqWh+VchfxcMNRAJjj2tnsSJdNbHsVgnkBhTNrW7AjVo6OvLtxw8zfT9oLw1JSohlFzJ8jCoTgaoXvJ+kHt6fw==}
+  /minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
     engines: {node: '>=16 || 14 >=14.17'}
     dependencies:
       brace-expansion: 2.0.1
@@ -6852,66 +6343,41 @@ packages:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
     dev: true
 
-  /minipass@3.3.6:
-    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
-    engines: {node: '>=8'}
-    dependencies:
-      yallist: 4.0.0
-    dev: true
-
-  /minipass@5.0.0:
-    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
-    engines: {node: '>=8'}
-    dev: true
-
   /minipass@7.1.2:
     resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
     engines: {node: '>=16 || 14 >=14.17'}
     dev: true
 
-  /minizlib@2.1.2:
-    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
-    engines: {node: '>= 8'}
-    dependencies:
-      minipass: 3.3.6
-      yallist: 4.0.0
-    dev: true
-
-  /mkdirp@1.0.4:
-    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dev: true
-
-  /mocha@10.4.0:
-    resolution: {integrity: sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==}
-    engines: {node: '>= 14.0.0'}
+  /mocha@11.0.1:
+    resolution: {integrity: sha512-+3GkODfsDG71KSCQhc4IekSW+ItCK/kiez1Z28ksWvYhKXV/syxMlerR/sC7whDp7IyreZ4YxceMLdTs5hQE8A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     hasBin: true
     dependencies:
-      ansi-colors: 4.1.1
+      ansi-colors: 4.1.3
       browser-stdout: 1.3.1
       chokidar: 3.5.3
-      debug: 4.3.4(supports-color@8.1.1)
-      diff: 5.0.0
+      debug: 4.3.7(supports-color@8.1.1)
+      diff: 5.2.0
       escape-string-regexp: 4.0.0
       find-up: 5.0.0
-      glob: 8.1.0
+      glob: 10.4.5
       he: 1.2.0
       js-yaml: 4.1.0
       log-symbols: 4.1.0
-      minimatch: 5.0.1
+      minimatch: 5.1.6
       ms: 2.1.3
-      serialize-javascript: 6.0.0
+      serialize-javascript: 6.0.2
       strip-json-comments: 3.1.1
       supports-color: 8.1.1
-      workerpool: 6.2.1
+      workerpool: 6.5.1
       yargs: 16.2.0
-      yargs-parser: 20.2.4
+      yargs-parser: 20.2.9
       yargs-unparser: 2.0.0
     dev: true
 
   /ms@2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+    dev: true
 
   /ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
@@ -6928,7 +6394,7 @@ packages:
     resolution: {integrity: sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==}
     dependencies:
       lower-case: 2.0.2
-      tslib: 2.6.3
+      tslib: 2.8.1
     dev: true
 
   /node-fetch@2.7.0:
@@ -6951,21 +6417,8 @@ packages:
     resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
     dev: true
 
-  /node-releases@2.0.13:
-    resolution: {integrity: sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ==}
-    dev: true
-
-  /nofilter@3.1.0:
-    resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==}
-    engines: {node: '>=12.19'}
-    dev: true
-
-  /nopt@5.0.0:
-    resolution: {integrity: sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==}
-    engines: {node: '>=6'}
-    hasBin: true
-    dependencies:
-      abbrev: 1.1.1
+  /node-releases@2.0.18:
+    resolution: {integrity: sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==}
     dev: true
 
   /normalize-path@3.0.0:
@@ -6980,76 +6433,56 @@ packages:
       path-key: 3.1.1
     dev: true
 
-  /npm-run-path@5.1.0:
-    resolution: {integrity: sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dependencies:
-      path-key: 4.0.0
-    dev: true
-
-  /npmlog@5.0.1:
-    resolution: {integrity: sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==}
-    dependencies:
-      are-we-there-yet: 2.0.0
-      console-control-strings: 1.1.0
-      gauge: 3.0.2
-      set-blocking: 2.0.0
-    dev: true
-
-  /object-assign@4.1.1:
-    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /object-inspect@1.13.1:
     resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==}
     dev: true
 
-  /object-is@1.1.5:
-    resolution: {integrity: sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==}
+  /object-is@1.1.6:
+    resolution: {integrity: sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
 
   /object-keys@1.1.1:
     resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
     engines: {node: '>= 0.4'}
 
-  /object.assign@4.1.4:
-    resolution: {integrity: sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==}
+  /object.assign@4.1.5:
+    resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
       has-symbols: 1.0.3
       object-keys: 1.1.1
 
-  /object.fromentries@2.0.7:
-    resolution: {integrity: sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==}
+  /object.fromentries@2.0.8:
+    resolution: {integrity: sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
+      es-object-atoms: 1.0.0
     dev: true
 
-  /object.groupby@1.0.1:
-    resolution: {integrity: sha512-HqaQtqLnp/8Bn4GL16cj+CUYbnpe1bh0TtEaWvybszDG4tgxCJuRpV8VGuvNaI1fAnI4lUJzDG55MXcOH4JZcQ==}
+  /object.groupby@1.0.3:
+    resolution: {integrity: sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
-      get-intrinsic: 1.2.2
+      es-abstract: 1.23.3
     dev: true
 
-  /object.values@1.1.7:
-    resolution: {integrity: sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==}
+  /object.values@1.2.0:
+    resolution: {integrity: sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-object-atoms: 1.0.0
     dev: true
 
   /once@1.4.0:
@@ -7065,23 +6498,6 @@ packages:
       mimic-fn: 2.1.0
     dev: true
 
-  /onetime@6.0.0:
-    resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
-    engines: {node: '>=12'}
-    dependencies:
-      mimic-fn: 4.0.0
-    dev: true
-
-  /open@9.1.0:
-    resolution: {integrity: sha512-OS+QTnw1/4vrf+9hh1jc1jnYjzSG4ttTBB8UxOwAnInG3Uo4ssetzC1ihqaIHjLJnA5GGlRl6QlZXOTQhRBUvg==}
-    engines: {node: '>=14.16'}
-    dependencies:
-      default-browser: 4.0.0
-      define-lazy-prop: 3.0.0
-      is-inside-container: 1.0.0
-      is-wsl: 2.2.0
-    dev: true
-
   /optionator@0.9.3:
     resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==}
     engines: {node: '>= 0.8.0'}
@@ -7122,22 +6538,13 @@ packages:
       p-limit: 3.1.0
     dev: true
 
-  /p-map@7.0.1:
-    resolution: {integrity: sha512-2wnaR0XL/FDOj+TgpDuRb2KTjLnu3Fma6b1ZUwGY7LcqenMcvP/YFpjpbPKY6WVGsbuJZRuoUz8iPrt8ORnAFw==}
-    engines: {node: '>=18'}
-    dev: true
-
   /p-try@2.2.0:
     resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
     engines: {node: '>=6'}
     dev: true
 
-  /package-config@5.0.0:
-    resolution: {integrity: sha512-GYTTew2slBcYdvRHqjhwaaydVMvn/qrGC323+nKclYioNSLTDUM/lGgtGTgyHVtYcozb+XkE8CNhwcraOmZ9Mg==}
-    engines: {node: '>=18'}
-    dependencies:
-      find-up-simple: 1.0.0
-      load-json-file: 7.0.1
+  /package-json-from-dist@1.0.0:
+    resolution: {integrity: sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==}
     dev: true
 
   /pako@2.1.0:
@@ -7155,15 +6562,10 @@ packages:
     resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
     engines: {node: '>=8'}
     dependencies:
-      '@babel/code-frame': 7.24.2
+      '@babel/code-frame': 7.26.2
       error-ex: 1.3.2
       json-parse-even-better-errors: 2.3.1
-      lines-and-columns: 1.2.4
-    dev: true
-
-  /parse-ms@4.0.0:
-    resolution: {integrity: sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==}
-    engines: {node: '>=18'}
+      lines-and-columns: 1.2.4
     dev: true
 
   /path-exists@4.0.0:
@@ -7181,11 +6583,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /path-key@4.0.0:
-    resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==}
-    engines: {node: '>=12'}
-    dev: true
-
   /path-parse@1.0.7:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
     dev: true
@@ -7194,7 +6591,7 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
     dependencies:
-      lru-cache: 10.2.2
+      lru-cache: 10.4.3
       minipass: 7.1.2
     dev: true
 
@@ -7203,16 +6600,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /path-type@5.0.0:
-    resolution: {integrity: sha512-5HviZNaZcfqP95rwpv+1HDgUamezbqdSYTyzjTvwtJSnIH+3vnbmWsItli8OFEndS984VT55M3jduxZbX351gg==}
-    engines: {node: '>=12'}
-    dev: true
-
-  /pathval@2.0.0:
-    resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==}
-    engines: {node: '>= 14.16'}
-    dev: true
-
   /pause-stream@0.0.11:
     resolution: {integrity: sha512-e3FBlXLmN/D1S+zHzanP4E/4Z60oFAa3O051qt1pxa7DEJWKAyil6upYVXCWadEnuoqa4Pkc9oUx9zsxYeRv8A==}
     dependencies:
@@ -7223,31 +6610,18 @@ packages:
     resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
     dev: true
 
+  /picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+    dev: true
+
   /picomatch@2.3.1:
     resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
     engines: {node: '>=8.6'}
     dev: true
 
-  /picomatch@3.0.1:
-    resolution: {integrity: sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /pify@2.3.0:
-    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /pinkie-promise@2.0.1:
-    resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      pinkie: 2.0.4
-    dev: true
-
-  /pinkie@2.0.4:
-    resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==}
-    engines: {node: '>=0.10.0'}
+  /picomatch@4.0.2:
+    resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==}
+    engines: {node: '>=12'}
     dev: true
 
   /pirates@4.0.6:
@@ -7262,12 +6636,9 @@ packages:
       find-up: 4.1.0
     dev: true
 
-  /plur@5.1.0:
-    resolution: {integrity: sha512-VP/72JeXqak2KiOzjgKtQen5y3IZHn+9GOuLDafPv0eXa47xq0At93XahYBs26MsifCQ4enGKwbjBTKgb9QJXg==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dependencies:
-      irregular-plurals: 3.5.0
-    dev: true
+  /possible-typed-array-names@1.0.0:
+    resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==}
+    engines: {node: '>= 0.4'}
 
   /prelude-ls@1.2.1:
     resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
@@ -7287,8 +6658,8 @@ packages:
     hasBin: true
     dev: true
 
-  /prettier@3.3.2:
-    resolution: {integrity: sha512-rAVeHYMcv8ATV5d508CFdn+8/pHPpXeIid1DdrPwXnaAdH7cqjVbpJaT5eq4yRAFU/lsbwYwSF/n5iNrdJHPQA==}
+  /prettier@3.4.2:
+    resolution: {integrity: sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==}
     engines: {node: '>=14'}
     hasBin: true
     dev: true
@@ -7302,16 +6673,13 @@ packages:
       react-is: 18.2.0
     dev: true
 
-  /pretty-ms@9.0.0:
-    resolution: {integrity: sha512-E9e9HJ9R9NasGOgPaPE8VMeiPKAyWR5jcFpNnwIejslIhWqdqOrb2wShBsncMPUb+BcCd2OPYfh7p2W6oemTng==}
-    engines: {node: '>=18'}
+  /pretty-format@30.0.0-alpha.6:
+    resolution: {integrity: sha512-xkeffkZoqQmRrcNewpOsUCKNOl+CkPqjt3Ld749uz1S7/O7GuPNPv2fZk3v/1U/FE8/B4Zz0llVL80MKON1tOQ==}
+    engines: {node: ^16.10.0 || ^18.12.0 || >=20.0.0}
     dependencies:
-      parse-ms: 4.0.0
-    dev: true
-
-  /process@0.11.10:
-    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
-    engines: {node: '>= 0.6.0'}
+      '@jest/schemas': 30.0.0-alpha.6
+      ansi-styles: 5.2.0
+      react-is: 18.2.0
     dev: true
 
   /prompts@2.4.2:
@@ -7334,6 +6702,11 @@ packages:
       event-stream: 3.3.4
     dev: true
 
+  /punycode.js@2.3.1:
+    resolution: {integrity: sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==}
+    engines: {node: '>=6'}
+    dev: true
+
   /punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
@@ -7361,15 +6734,6 @@ packages:
     resolution: {integrity: sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==}
     dev: true
 
-  /readable-stream@3.6.2:
-    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
-    engines: {node: '>= 6'}
-    dependencies:
-      inherits: 2.0.4
-      string_decoder: 1.3.0
-      util-deprecate: 1.0.2
-    dev: true
-
   /readdirp@3.6.0:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
@@ -7377,22 +6741,16 @@ packages:
       picomatch: 2.3.1
     dev: true
 
-  /rechoir@0.6.2:
-    resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==}
-    engines: {node: '>= 0.10'}
-    dependencies:
-      resolve: 1.22.8
-    dev: true
-
   /regenerator-runtime@0.14.0:
     resolution: {integrity: sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==}
 
-  /regexp.prototype.flags@1.5.1:
-    resolution: {integrity: sha512-sy6TXMN+hnP/wMy+ISxg3krXx7BAtWVO4UouuCN/ziM9UEne0euamVNafDfvC83bRNr95y0V5iijeDQFUNpvrg==}
+  /regexp.prototype.flags@1.5.2:
+    resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
+      es-errors: 1.3.0
       set-function-name: 2.0.1
     dev: true
 
@@ -7423,10 +6781,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /resolve-pkg-maps@1.0.0:
-    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
-    dev: true
-
   /resolve.exports@2.0.2:
     resolution: {integrity: sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==}
     engines: {node: '>=10'}
@@ -7436,7 +6790,7 @@ packages:
     resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==}
     hasBin: true
     dependencies:
-      is-core-module: 2.13.1
+      is-core-module: 2.15.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
     dev: true
@@ -7448,80 +6802,55 @@ packages:
 
   /rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
+    deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
     dependencies:
       glob: 7.2.3
     dev: true
 
-  /rimraf@5.0.7:
-    resolution: {integrity: sha512-nV6YcJo5wbLW77m+8KjH8aB/7/rxQy9SZ0HY5shnwULfS+9nmTtVXAJET5NdZmCzA4fPI/Hm1wo/Po/4mopOdg==}
-    engines: {node: '>=14.18'}
-    hasBin: true
-    dependencies:
-      glob: 10.3.10
-    dev: true
-
-  /rollup-plugin-dts@6.1.1(rollup@4.18.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-aSHRcJ6KG2IHIioYlvAOcEq6U99sVtqDDKVhnwt70rW6tsz3tv5OSjEiWcgzfsHdLyGXZ/3b/7b/+Za3Y6r1XA==}
-    engines: {node: '>=16'}
-    peerDependencies:
-      rollup: ^3.29.4 || ^4
-      typescript: ^4.5 || ^5.0
-    dependencies:
-      magic-string: 0.30.10
-      rollup: 4.18.0
-      typescript: 5.4.5
-    optionalDependencies:
-      '@babel/code-frame': 7.24.2
-    dev: true
-
-  /rollup@4.18.0:
-    resolution: {integrity: sha512-QmJz14PX3rzbJCN1SG4Xe/bAAX2a6NpCP8ab2vfu2GiUr8AQcr2nCV/oEO3yneFarB67zk8ShlIyWb2LGTb3Sg==}
+  /rollup@4.30.1:
+    resolution: {integrity: sha512-mlJ4glW020fPuLi7DkM/lN97mYEZGWeqBnrljzN0gs7GLctqX3lNWxKQ7Gl712UAX+6fog/L3jh4gb7R6aVi3w==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
     dependencies:
-      '@types/estree': 1.0.5
+      '@types/estree': 1.0.6
     optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.18.0
-      '@rollup/rollup-android-arm64': 4.18.0
-      '@rollup/rollup-darwin-arm64': 4.18.0
-      '@rollup/rollup-darwin-x64': 4.18.0
-      '@rollup/rollup-linux-arm-gnueabihf': 4.18.0
-      '@rollup/rollup-linux-arm-musleabihf': 4.18.0
-      '@rollup/rollup-linux-arm64-gnu': 4.18.0
-      '@rollup/rollup-linux-arm64-musl': 4.18.0
-      '@rollup/rollup-linux-powerpc64le-gnu': 4.18.0
-      '@rollup/rollup-linux-riscv64-gnu': 4.18.0
-      '@rollup/rollup-linux-s390x-gnu': 4.18.0
-      '@rollup/rollup-linux-x64-gnu': 4.18.0
-      '@rollup/rollup-linux-x64-musl': 4.18.0
-      '@rollup/rollup-win32-arm64-msvc': 4.18.0
-      '@rollup/rollup-win32-ia32-msvc': 4.18.0
-      '@rollup/rollup-win32-x64-msvc': 4.18.0
+      '@rollup/rollup-android-arm-eabi': 4.30.1
+      '@rollup/rollup-android-arm64': 4.30.1
+      '@rollup/rollup-darwin-arm64': 4.30.1
+      '@rollup/rollup-darwin-x64': 4.30.1
+      '@rollup/rollup-freebsd-arm64': 4.30.1
+      '@rollup/rollup-freebsd-x64': 4.30.1
+      '@rollup/rollup-linux-arm-gnueabihf': 4.30.1
+      '@rollup/rollup-linux-arm-musleabihf': 4.30.1
+      '@rollup/rollup-linux-arm64-gnu': 4.30.1
+      '@rollup/rollup-linux-arm64-musl': 4.30.1
+      '@rollup/rollup-linux-loongarch64-gnu': 4.30.1
+      '@rollup/rollup-linux-powerpc64le-gnu': 4.30.1
+      '@rollup/rollup-linux-riscv64-gnu': 4.30.1
+      '@rollup/rollup-linux-s390x-gnu': 4.30.1
+      '@rollup/rollup-linux-x64-gnu': 4.30.1
+      '@rollup/rollup-linux-x64-musl': 4.30.1
+      '@rollup/rollup-win32-arm64-msvc': 4.30.1
+      '@rollup/rollup-win32-ia32-msvc': 4.30.1
+      '@rollup/rollup-win32-x64-msvc': 4.30.1
       fsevents: 2.3.3
     dev: true
 
-  /rpc-websockets@9.0.0:
-    resolution: {integrity: sha512-1yf8FM6PY6Uhip2Fe+UrgPq9EhUu0qxr5mcVSEGOTWhpzffTh5IBKy5S+C68zJv0Gg0k9ey0pw7K06+EfbnN3g==}
+  /rpc-websockets@9.0.2:
+    resolution: {integrity: sha512-YzggvfItxMY3Lwuax5rC18inhbjJv9Py7JXRHxTIi94JOLrqBsSsUUc5bbl5W6c11tXhdfpDPK0KzBhoGe8jjw==}
     dependencies:
       '@swc/helpers': 0.5.11
       '@types/uuid': 8.3.4
       '@types/ws': 8.5.10
       buffer: 6.0.3
-      eventemitter3: 4.0.7
+      eventemitter3: 5.0.1
       uuid: 8.3.2
       ws: 8.14.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)
     optionalDependencies:
       bufferutil: 4.0.8
       utf-8-validate: 5.0.10
 
-  /run-applescript@5.0.0:
-    resolution: {integrity: sha512-XcT5rBksx1QdIhlFOCtgZkB99ZEouFZ1E2Kc2LHqNW13U3/74YGdkQRmThTwxy4QIyookibDKYZOPqX//6BlAg==}
-    engines: {node: '>=12'}
-    dependencies:
-      execa: 5.1.1
-    dev: true
-
   /run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
     dependencies:
@@ -7531,15 +6860,15 @@ packages:
   /rxjs@7.8.1:
     resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==}
     dependencies:
-      tslib: 2.6.3
+      tslib: 2.8.1
     dev: true
 
-  /safe-array-concat@1.0.1:
-    resolution: {integrity: sha512-6XbUAseYE2KtOuGueyeobCySj9L4+66Tn6KQMOPQJrAJEowYKW/YR/MGJZl7FdydUdaFu4LYyDZjxf4/Nmo23Q==}
+  /safe-array-concat@1.1.2:
+    resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==}
     engines: {node: '>=0.4'}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
+      call-bind: 1.0.7
+      get-intrinsic: 1.2.4
       has-symbols: 1.0.3
       isarray: 2.0.5
     dev: true
@@ -7547,11 +6876,12 @@ packages:
   /safe-buffer@5.2.1:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
 
-  /safe-regex-test@1.0.0:
-    resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==}
+  /safe-regex-test@1.0.3:
+    resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
+      call-bind: 1.0.7
+      es-errors: 1.3.0
       is-regex: 1.1.4
     dev: true
 
@@ -7560,61 +6890,36 @@ packages:
     hasBin: true
     dev: true
 
-  /semver@7.5.4:
-    resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dependencies:
-      lru-cache: 6.0.0
-    dev: true
-
-  /semver@7.6.0:
-    resolution: {integrity: sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==}
+  /semver@7.6.3:
+    resolution: {integrity: sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==}
     engines: {node: '>=10'}
     hasBin: true
-    dependencies:
-      lru-cache: 6.0.0
-    dev: true
-
-  /serialize-error@7.0.1:
-    resolution: {integrity: sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==}
-    engines: {node: '>=10'}
-    dependencies:
-      type-fest: 0.13.1
-    dev: true
-
-  /serialize-javascript@6.0.0:
-    resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==}
-    dependencies:
-      randombytes: 2.1.0
     dev: true
 
-  /serialize-javascript@6.0.1:
-    resolution: {integrity: sha512-owoXEFjWRllis8/M1Q+Cw5k8ZH40e3zhp/ovX+Xr/vi1qj6QesbyXXViFbpNvWvPNAD62SutwEXavefrLJWj7w==}
+  /serialize-javascript@6.0.2:
+    resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
     dependencies:
       randombytes: 2.1.0
     dev: true
 
-  /set-blocking@2.0.0:
-    resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
-    dev: true
-
-  /set-function-length@1.1.1:
-    resolution: {integrity: sha512-VoaqjbBJKiWtg4yRcKBQ7g7wnGnLV3M8oLvVWwOk2PdYY6PEFegR1vezXR0tw6fZGF9csVakIRjrJiy2veSBFQ==}
+  /set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-data-property: 1.1.1
-      get-intrinsic: 1.2.2
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.2.4
       gopd: 1.0.1
-      has-property-descriptors: 1.0.1
+      has-property-descriptors: 1.0.2
 
   /set-function-name@2.0.1:
     resolution: {integrity: sha512-tMNCiqYVkXIZgc2Hnoy2IvC/f8ezc5koaRFkCjrpWzGpCd3qbZXPzVy9MAZzK1ch/X0jvSkojys3oqJN0qCmdA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-data-property: 1.1.1
+      define-data-property: 1.1.4
       functions-have-names: 1.2.3
-      has-property-descriptors: 1.0.1
+      has-property-descriptors: 1.0.2
     dev: true
 
   /shebang-command@2.0.0:
@@ -7629,39 +6934,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /shelljs@0.8.5:
-    resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==}
-    engines: {node: '>=4'}
-    hasBin: true
-    dependencies:
-      glob: 7.2.3
-      interpret: 1.4.0
-      rechoir: 0.6.2
-    dev: true
-
-  /shiki@0.14.7:
-    resolution: {integrity: sha512-dNPAPrxSc87ua2sKJ3H5dQ/6ZaY8RNnaAqK+t0eG7p0Soi2ydiqbGOTaZCqaYvA/uZYfS1LJnemt3Q+mSfcPCg==}
-    dependencies:
-      ansi-sequence-parser: 1.1.1
-      jsonc-parser: 3.2.0
-      vscode-oniguruma: 1.7.0
-      vscode-textmate: 8.0.0
-    dev: true
-
-  /shx@0.3.4:
-    resolution: {integrity: sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g==}
-    engines: {node: '>=6'}
-    hasBin: true
-    dependencies:
-      minimist: 1.2.8
-      shelljs: 0.8.5
-    dev: true
-
   /side-channel@1.0.4:
     resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
+      call-bind: 1.0.7
+      get-intrinsic: 1.2.4
       object-inspect: 1.13.1
     dev: true
 
@@ -7683,95 +6960,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /slash@4.0.0:
-    resolution: {integrity: sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==}
-    engines: {node: '>=12'}
-    dev: true
-
-  /slash@5.1.0:
-    resolution: {integrity: sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==}
-    engines: {node: '>=14.16'}
-    dev: true
-
-  /slice-ansi@5.0.0:
-    resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
-    engines: {node: '>=12'}
-    dependencies:
-      ansi-styles: 6.2.1
-      is-fullwidth-code-point: 4.0.0
-    dev: true
-
-  /smob@1.4.1:
-    resolution: {integrity: sha512-9LK+E7Hv5R9u4g4C3p+jjLstaLe11MDsL21UpYaCNmapvMkYhqCV4A/f/3gyH8QjMyh6l68q9xC85vihY9ahMQ==}
-    dev: true
-
   /snake-case@3.0.4:
     resolution: {integrity: sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==}
     dependencies:
       dot-case: 3.0.4
-      tslib: 2.6.3
-    dev: true
-
-  /solana-bankrun-darwin-arm64@0.2.0:
-    resolution: {integrity: sha512-ENQ5Z/CYeY8ZVWIc2VutY/gMlBaHi93/kDw9w0iVwewoV+/YpQmP2irwrshIKu6ggRPTF3Ehlh2V6fGVIYWcXw==}
-    engines: {node: '>= 10'}
-    cpu: [arm64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /solana-bankrun-darwin-universal@0.2.0:
-    resolution: {integrity: sha512-HE45TvZXzBipm1fMn87+fkHeIuQ/KFAi5G/S29y/TLuBYt4RDI935RkWiT0rEQ7KwnwO6Y1aTsOaQXldY5R7uQ==}
-    engines: {node: '>= 10'}
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /solana-bankrun-darwin-x64@0.2.0:
-    resolution: {integrity: sha512-42UsVrnac2Oo4UaIDo60zfI3Xn1i8W6fmcc9ixJQZNTtdO8o2/sY4mFxcJx9lhLMhda5FPHrQbGYgYdIs0kK0g==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /solana-bankrun-linux-x64-gnu@0.2.0:
-    resolution: {integrity: sha512-WnqQjfBBdcI0ZLysjvRStI8gX7vm1c3CI6CC03lgkUztH+Chcq9C4LI9m2M8mXza8Xkn9ryeKAmX36Bx/yoVzg==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /solana-bankrun-linux-x64-musl@0.2.0:
-    resolution: {integrity: sha512-8mtf14ZBoah30+MIJBUwb5BlGLRZyK5cZhCkYnC/ROqaIDN8RxMM44NL63gTUIaNHsFwWGA9xR0KSeljeh3PKQ==}
-    engines: {node: '>= 10'}
-    cpu: [x64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /solana-bankrun@0.2.0:
-    resolution: {integrity: sha512-TS6vYoO/9YJZng7oiLOVyuz8V7yLow5Hp4SLYWW71XM3702v+z9f1fvUBKudRfa4dfpta4tRNufApSiBIALxJQ==}
-    engines: {node: '>= 10'}
-    dependencies:
-      '@solana/web3.js': 1.93.0
-      bs58: 4.0.1
-    optionalDependencies:
-      solana-bankrun-darwin-arm64: 0.2.0
-      solana-bankrun-darwin-universal: 0.2.0
-      solana-bankrun-darwin-x64: 0.2.0
-      solana-bankrun-linux-x64-gnu: 0.2.0
-      solana-bankrun-linux-x64-musl: 0.2.0
-    transitivePeerDependencies:
-      - bufferutil
-      - encoding
-      - utf-8-validate
+      tslib: 2.8.1
     dev: true
 
   /source-map-support@0.5.13:
@@ -7781,13 +6974,6 @@ packages:
       source-map: 0.6.1
     dev: true
 
-  /source-map-support@0.5.21:
-    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
-    dependencies:
-      buffer-from: 1.1.2
-      source-map: 0.6.1
-    dev: true
-
   /source-map@0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
@@ -7819,19 +7005,19 @@ packages:
       escape-string-regexp: 2.0.0
     dev: true
 
-  /start-server-and-test@2.0.4:
-    resolution: {integrity: sha512-CKNeBTcP0hVqIlNismHMudb9q3lLdAjcVPO13/7gfI66fcJpeIb/o4NzQd1JK/CD+lfWVqr10ZH9Y14+OwlJuw==}
+  /start-server-and-test@2.0.9:
+    resolution: {integrity: sha512-DDceIvc4wdpr+z3Aqkot2QMho8TcUBh5qH0wEHDpEexBTzlheOcmh53d3dExABY4J5C7qS2UbSXqRWLtxpbWIQ==}
     engines: {node: '>=16'}
     hasBin: true
     dependencies:
       arg: 5.0.2
       bluebird: 3.7.2
       check-more-types: 2.24.0
-      debug: 4.3.5
+      debug: 4.4.0
       execa: 5.1.1
       lazy-ass: 1.6.0
       ps-tree: 1.2.0
-      wait-on: 7.2.0(debug@4.3.5)
+      wait-on: 8.0.1(debug@4.4.0)
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -7868,44 +7054,31 @@ packages:
       strip-ansi: 7.1.0
     dev: true
 
-  /string-width@7.0.0:
-    resolution: {integrity: sha512-GPQHj7row82Hjo9hKZieKcHIhaAIKOJvFSIZXuCU9OASVZrMNUaZuz++SPVrBjnLsnk4k+z9f2EIypgxf2vNFw==}
-    engines: {node: '>=18'}
-    dependencies:
-      emoji-regex: 10.3.0
-      get-east-asian-width: 1.2.0
-      strip-ansi: 7.1.0
-    dev: true
-
-  /string.prototype.trim@1.2.8:
-    resolution: {integrity: sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==}
+  /string.prototype.trim@1.2.9:
+    resolution: {integrity: sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-abstract: 1.23.3
+      es-object-atoms: 1.0.0
     dev: true
 
-  /string.prototype.trimend@1.0.7:
-    resolution: {integrity: sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==}
+  /string.prototype.trimend@1.0.8:
+    resolution: {integrity: sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
+      es-object-atoms: 1.0.0
     dev: true
 
-  /string.prototype.trimstart@1.0.7:
-    resolution: {integrity: sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==}
+  /string.prototype.trimstart@1.0.8:
+    resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       define-properties: 1.2.1
-      es-abstract: 1.22.3
-    dev: true
-
-  /string_decoder@1.3.0:
-    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
-    dependencies:
-      safe-buffer: 5.2.1
+      es-object-atoms: 1.0.0
     dev: true
 
   /strip-ansi@6.0.1:
@@ -7937,11 +7110,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /strip-final-newline@3.0.0:
-    resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
-    engines: {node: '>=12'}
-    dev: true
-
   /strip-json-comments@3.1.1:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
@@ -7958,27 +7126,10 @@ packages:
     resolution: {integrity: sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ==}
     dev: true
 
-  /superstruct@1.0.4:
-    resolution: {integrity: sha512-7JpaAoX2NGyoFlI9NBh66BQXGONc+uE+MRS5i2iOBKuS4e+ccgMDjATgZldkah+33DakBxDHiss9kvUcGAO8UQ==}
+  /superstruct@2.0.2:
+    resolution: {integrity: sha512-uV+TFRZdXsqXTL2pRvujROjdZQ4RAlBUS5BTh9IGm+jTqQntYThciG/qu57Gs69yjnVUSqdxF9YLmSnpupBW9A==}
     engines: {node: '>=14.0.0'}
 
-  /supertap@3.0.1:
-    resolution: {integrity: sha512-u1ZpIBCawJnO+0QePsEiOknOfCRq0yERxiAchT0i4li0WHNUJbf0evXXSXOcCAR4M8iMDoajXYmstm/qO81Isw==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dependencies:
-      indent-string: 5.0.0
-      js-yaml: 3.14.1
-      serialize-error: 7.0.1
-      strip-ansi: 7.1.0
-    dev: true
-
-  /supports-color@5.5.0:
-    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
-    engines: {node: '>=4'}
-    dependencies:
-      has-flag: 3.0.0
-    dev: true
-
   /supports-color@7.2.0:
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
@@ -7997,40 +7148,12 @@ packages:
     engines: {node: '>= 0.4'}
     dev: true
 
-  /synckit@0.8.6:
-    resolution: {integrity: sha512-laHF2savN6sMeHCjLRkheIU4wo3Zg9Ln5YOjOo7sZ5dVQW8yF5pPE5SIw1dsPhq3TRp1jisKRCdPhfs/1WMqDA==}
+  /synckit@0.9.1:
+    resolution: {integrity: sha512-7gr8p9TQP6RAHusBOSLs46F4564ZrjV8xFmw5zCmgmhGUcw2hxsShhJ6CEiHQMgPDwAQ1fWHPM0ypc4RMAig4A==}
     engines: {node: ^14.18.0 || >=16.0.0}
     dependencies:
-      '@pkgr/utils': 2.4.2
-      tslib: 2.6.3
-    dev: true
-
-  /tar@6.2.0:
-    resolution: {integrity: sha512-/Wo7DcT0u5HUV486xg675HtjNd3BXZ6xDbzsCUZPt5iw8bTQ63bP0Raut3mvro9u+CUyq7YQd8Cx55fsZXxqLQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      chownr: 2.0.0
-      fs-minipass: 2.1.0
-      minipass: 5.0.0
-      minizlib: 2.1.2
-      mkdirp: 1.0.4
-      yallist: 4.0.0
-    dev: true
-
-  /temp-dir@3.0.0:
-    resolution: {integrity: sha512-nHc6S/bwIilKHNRgK/3jlhDoIHcp45YgyiwcAk46Tr0LfEqGBVpmiAyuiuxeVE44m3mXnEeVhaipLOEWmH+Njw==}
-    engines: {node: '>=14.16'}
-    dev: true
-
-  /terser@5.24.0:
-    resolution: {integrity: sha512-ZpGR4Hy3+wBEzVEnHvstMvqpD/nABNelQn/z2r0fjVWGQsN3bpOLzQlqDxmb4CDZnXq5lpjnQ+mHQLAOpfM5iw==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dependencies:
-      '@jridgewell/source-map': 0.3.5
-      acorn: 8.11.3
-      commander: 2.20.3
-      source-map-support: 0.5.21
+      '@pkgr/core': 0.1.1
+      tslib: 2.8.1
     dev: true
 
   /test-exclude@6.0.0:
@@ -8052,25 +7175,10 @@ packages:
   /through@2.3.8:
     resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
 
-  /time-zone@1.0.0:
-    resolution: {integrity: sha512-TIsDdtKo6+XrPtiTm1ssmMngN1sAhyKnTO2kunQWqNPWIVvCm15Wmw4SWInwTVgJ5u/Tr04+8Ei9TNcw4x4ONA==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /titleize@3.0.0:
-    resolution: {integrity: sha512-KxVu8EYHDPBdUYdKZdKtU2aj2XfEx9AfjXxE/Aj0vT06w2icA09Vus1rh6eSu1y01akYg6BjIK/hxyLJINoMLQ==}
-    engines: {node: '>=12'}
-    dev: true
-
   /tmpl@1.0.5:
     resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
     dev: true
 
-  /to-fast-properties@2.0.0:
-    resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
-    engines: {node: '>=4'}
-    dev: true
-
   /to-regex-range@5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
@@ -8092,22 +7200,31 @@ packages:
       escape-string-regexp: 1.0.5
     dev: true
 
-  /ts-api-utils@1.3.0(typescript@5.4.5):
+  /ts-api-utils@1.3.0(typescript@5.7.2):
     resolution: {integrity: sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==}
     engines: {node: '>=16'}
     peerDependencies:
       typescript: '>=4.2.0'
     dependencies:
-      typescript: 5.4.5
+      typescript: 5.7.2
+    dev: true
+
+  /ts-api-utils@2.0.0(typescript@5.7.2):
+    resolution: {integrity: sha512-xCt/TOAc+EOHS1XPnijD3/yzpH6qg2xppZO1YDqGoVsNXfQfzHpOdNuXwrwOU8u4ITXJyDCTyt8w5g1sZv9ynQ==}
+    engines: {node: '>=18.12'}
+    peerDependencies:
+      typescript: '>=4.8.4'
+    dependencies:
+      typescript: 5.7.2
     dev: true
 
-  /ts-declaration-location@1.0.0(typescript@5.4.5):
-    resolution: {integrity: sha512-/C+R0e1CLF1KtwbE59IFhCg4jLwfU7Puob+uVIl4iUVQhepN/bHmWXy3Gt3mAgvdLQybEZ4yb4qhnJQbphnEgA==}
+  /ts-declaration-location@1.0.4(typescript@5.7.2):
+    resolution: {integrity: sha512-r4JoxYhKULbZuH81Pjrp9OEG5St7XWk7zXwGkLKhmVcjiBVHTJXV5wK6dEa9JKW5QGSTW6b1lOjxAKp8R1SQhg==}
     peerDependencies:
       typescript: '>=4.0.0'
     dependencies:
-      fast-glob: 3.3.2
-      typescript: 5.4.5
+      minimatch: 10.0.1
+      typescript: 5.7.2
     dev: true
 
   /ts-jest-resolver@2.0.1:
@@ -8116,8 +7233,8 @@ packages:
       jest-resolve: 29.7.0
     dev: true
 
-  /ts-jest@29.1.5(@babel/core@7.23.2)(jest@29.7.0)(typescript@5.4.5):
-    resolution: {integrity: sha512-UuClSYxM7byvvYfyWdFI+/2UxMmwNyJb0NPkZPQE2hew3RurV7l7zURgOHAd/1I1ZdPpe3GUsXNXAcN8TFKSIg==}
+  /ts-jest@29.2.5(@babel/core@7.26.0)(jest@29.7.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA==}
     engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0}
     hasBin: true
     peerDependencies:
@@ -8140,20 +7257,21 @@ packages:
       esbuild:
         optional: true
     dependencies:
-      '@babel/core': 7.23.2
+      '@babel/core': 7.26.0
       bs-logger: 0.2.6
+      ejs: 3.1.10
       fast-json-stable-stringify: 2.1.0
-      jest: 29.7.0(@types/node@20.14.5)(ts-node@10.9.2)
+      jest: 29.7.0(@types/node@22.10.5)(ts-node@10.9.2)
       jest-util: 29.7.0
       json5: 2.2.3
       lodash.memoize: 4.1.2
       make-error: 1.3.6
-      semver: 7.6.0
-      typescript: 5.4.5
+      semver: 7.6.3
+      typescript: 5.7.2
       yargs-parser: 21.1.1
     dev: true
 
-  /ts-node@10.9.2(@types/node@20.14.5)(typescript@5.4.5):
+  /ts-node@10.9.2(@types/node@22.10.5)(typescript@5.7.2):
     resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==}
     hasBin: true
     peerDependencies:
@@ -8172,14 +7290,14 @@ packages:
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 20.14.5
-      acorn: 8.11.2
-      acorn-walk: 8.3.0
+      '@types/node': 22.10.5
+      acorn: 8.14.0
+      acorn-walk: 8.3.4
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 5.4.5
+      typescript: 5.7.2
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
     dev: true
@@ -8197,88 +7315,77 @@ packages:
     resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
     dev: true
 
-  /tslib@2.6.3:
-    resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==}
+  /tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  /tsutils@3.21.0(typescript@5.4.5):
+  /tsutils@3.21.0(typescript@5.7.2):
     resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
     engines: {node: '>= 6'}
     peerDependencies:
       typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
     dependencies:
       tslib: 1.14.1
-      typescript: 5.4.5
+      typescript: 5.7.2
     dev: true
 
-  /tsx@4.15.6:
-    resolution: {integrity: sha512-is0VQQlfNZRHEuSSTKA6m4xw74IU4AizmuB6lAYLRt9XtuyeQnyJYexhNZOPCB59SqC4JzmSzPnHGBXxf3k0hA==}
-    engines: {node: '>=18.0.0'}
-    hasBin: true
-    dependencies:
-      esbuild: 0.21.5
-      get-tsconfig: 4.7.5
-    optionalDependencies:
-      fsevents: 2.3.3
-    dev: true
-
-  /turbo-darwin-64@2.0.4:
-    resolution: {integrity: sha512-x9mvmh4wudBstML8Z8IOmokLWglIhSfhQwnh2gBCSqabgVBKYvzl8Y+i+UCNPxheCGTgtsPepTcIaKBIyFIcvw==}
+  /turbo-darwin-64@2.3.3:
+    resolution: {integrity: sha512-bxX82xe6du/3rPmm4aCC5RdEilIN99VUld4HkFQuw+mvFg6darNBuQxyWSHZTtc25XgYjQrjsV05888w1grpaA==}
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-darwin-arm64@2.0.4:
-    resolution: {integrity: sha512-/B1Ih8zPRGVw5vw4SlclOf3C/woJ/2T6ieH6u54KT4wypoaVyaiyMqBcziIXycdObIYr7jQ+raHO7q3mhay9/A==}
+  /turbo-darwin-arm64@2.3.3:
+    resolution: {integrity: sha512-DYbQwa3NsAuWkCUYVzfOUBbSUBVQzH5HWUFy2Kgi3fGjIWVZOFk86ss+xsWu//rlEAfYwEmopigsPYSmW4X15A==}
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-64@2.0.4:
-    resolution: {integrity: sha512-6aG670e5zOWu6RczEYcB81nEl8EhiGJEvWhUrnAfNEUIMBEH1pR5SsMmG2ol5/m3PgiRM12r13dSqTxCLcHrVg==}
+  /turbo-linux-64@2.3.3:
+    resolution: {integrity: sha512-eHj9OIB0dFaP6BxB88jSuaCLsOQSYWBgmhy2ErCu6D2GG6xW3b6e2UWHl/1Ho9FsTg4uVgo4DB9wGsKa5erjUA==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-arm64@2.0.4:
-    resolution: {integrity: sha512-AXfVOjst+mCtPDFT4tCu08Qrfv12Nj7NDd33AjGwV79NYN1Y1rcFY59UQ4nO3ij3rbcvV71Xc+TZJ4csEvRCSg==}
+  /turbo-linux-arm64@2.3.3:
+    resolution: {integrity: sha512-NmDE/NjZoDj1UWBhMtOPmqFLEBKhzGS61KObfrDEbXvU3lekwHeoPvAMfcovzswzch+kN2DrtbNIlz+/rp8OCg==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-64@2.0.4:
-    resolution: {integrity: sha512-QOnUR9hKl0T5gq5h1fAhVEqBSjpcBi/BbaO71YGQNgsr6pAnCQdbG8/r3MYXet53efM0KTdOhieWeO3KLNKybA==}
+  /turbo-windows-64@2.3.3:
+    resolution: {integrity: sha512-O2+BS4QqjK3dOERscXqv7N2GXNcqHr9hXumkMxDj/oGx9oCatIwnnwx34UmzodloSnJpgSqjl8iRWiY65SmYoQ==}
     cpu: [x64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-arm64@2.0.4:
-    resolution: {integrity: sha512-3v8WpdZy1AxZw0gha0q3caZmm+0gveBQ40OspD6mxDBIS+oBtO5CkxhIXkFJJW+jDKmDlM7wXDIGfMEq+QyNCQ==}
+  /turbo-windows-arm64@2.3.3:
+    resolution: {integrity: sha512-dW4ZK1r6XLPNYLIKjC4o87HxYidtRRcBeo/hZ9Wng2XM/MqqYkAyzJXJGgRMsc0MMEN9z4+ZIfnSNBrA0b08ag==}
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo@2.0.4:
-    resolution: {integrity: sha512-Ilme/2Q5kYw0AeRr+aw3s02+WrEYaY7U8vPnqSZU/jaDG/qd6jHVN6nRWyd/9KXvJGYM69vE6JImoGoyNjLwaw==}
+  /turbo@2.3.3:
+    resolution: {integrity: sha512-DUHWQAcC8BTiUZDRzAYGvpSpGLiaOQPfYXlCieQbwUvmml/LRGIe3raKdrOPOoiX0DYlzxs2nH6BoWJoZrj8hA==}
     hasBin: true
     optionalDependencies:
-      turbo-darwin-64: 2.0.4
-      turbo-darwin-arm64: 2.0.4
-      turbo-linux-64: 2.0.4
-      turbo-linux-arm64: 2.0.4
-      turbo-windows-64: 2.0.4
-      turbo-windows-arm64: 2.0.4
+      turbo-darwin-64: 2.3.3
+      turbo-darwin-arm64: 2.3.3
+      turbo-linux-64: 2.3.3
+      turbo-linux-arm64: 2.3.3
+      turbo-windows-64: 2.3.3
+      turbo-windows-arm64: 2.3.3
     dev: true
 
   /type-check@0.4.0:
@@ -8293,11 +7400,6 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
-  /type-fest@0.13.1:
-    resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==}
-    engines: {node: '>=10'}
-    dev: true
-
   /type-fest@0.20.2:
     resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==}
     engines: {node: '>=10'}
@@ -8308,104 +7410,123 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /typed-array-buffer@1.0.0:
-    resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==}
+  /typed-array-buffer@1.0.2:
+    resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
-      get-intrinsic: 1.2.2
-      is-typed-array: 1.1.12
+      call-bind: 1.0.7
+      es-errors: 1.3.0
+      is-typed-array: 1.1.13
     dev: true
 
-  /typed-array-byte-length@1.0.0:
-    resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==}
+  /typed-array-byte-length@1.0.1:
+    resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       for-each: 0.3.3
-      has-proto: 1.0.1
-      is-typed-array: 1.1.12
+      gopd: 1.0.1
+      has-proto: 1.0.3
+      is-typed-array: 1.1.13
     dev: true
 
-  /typed-array-byte-offset@1.0.0:
-    resolution: {integrity: sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==}
+  /typed-array-byte-offset@1.0.2:
+    resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.5
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.7
       for-each: 0.3.3
-      has-proto: 1.0.1
-      is-typed-array: 1.1.12
+      gopd: 1.0.1
+      has-proto: 1.0.3
+      is-typed-array: 1.1.13
     dev: true
 
-  /typed-array-length@1.0.4:
-    resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==}
+  /typed-array-length@1.0.6:
+    resolution: {integrity: sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       for-each: 0.3.3
-      is-typed-array: 1.1.12
+      gopd: 1.0.1
+      has-proto: 1.0.3
+      is-typed-array: 1.1.13
+      possible-typed-array-names: 1.0.0
     dev: true
 
-  /typedoc@0.25.13(typescript@5.4.5):
-    resolution: {integrity: sha512-pQqiwiJ+Z4pigfOnnysObszLiU3mVLWAExSPf+Mu06G/qsc3wzbuM56SZQvONhHLncLUhYzOVkjFFpFfL5AzhQ==}
-    engines: {node: '>= 16'}
+  /typedoc@0.27.6(typescript@5.7.2):
+    resolution: {integrity: sha512-oBFRoh2Px6jFx366db0lLlihcalq/JzyCVp7Vaq1yphL/tbgx2e+bkpkCgJPunaPvPwoTOXSwasfklWHm7GfAw==}
+    engines: {node: '>= 18'}
     hasBin: true
     peerDependencies:
-      typescript: 4.6.x || 4.7.x || 4.8.x || 4.9.x || 5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x
+      typescript: 5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x
     dependencies:
+      '@gerrit0/mini-shiki': 1.24.1
       lunr: 2.3.9
-      marked: 4.3.0
-      minimatch: 9.0.3
-      shiki: 0.14.7
-      typescript: 5.4.5
+      markdown-it: 14.1.0
+      minimatch: 9.0.5
+      typescript: 5.7.2
+      yaml: 2.6.1
     dev: true
 
   /typescript-collections@1.3.3:
     resolution: {integrity: sha512-7sI4e/bZijOzyURng88oOFZCISQPTHozfE2sUu5AviFYk5QV7fYGb6YiDl+vKjF/pICA354JImBImL9XJWUvdQ==}
     dev: false
 
-  /typescript@5.4.5:
-    resolution: {integrity: sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ==}
+  /typescript-eslint@8.12.2(eslint@9.13.0)(typescript@5.7.2):
+    resolution: {integrity: sha512-UbuVUWSrHVR03q9CWx+JDHeO6B/Hr9p4U5lRH++5tq/EbFq1faYZe50ZSBePptgfIKLEti0aPQ3hFgnPVcd8ZQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.12.2(@typescript-eslint/parser@8.12.2)(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/parser': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      '@typescript-eslint/utils': 8.12.2(eslint@9.13.0)(typescript@5.7.2)
+      typescript: 5.7.2
+    transitivePeerDependencies:
+      - eslint
+      - supports-color
+    dev: true
+
+  /typescript@5.7.2:
+    resolution: {integrity: sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==}
     engines: {node: '>=14.17'}
     hasBin: true
     dev: true
 
+  /uc.micro@2.1.0:
+    resolution: {integrity: sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==}
+    dev: true
+
   /unbox-primitive@1.0.2:
     resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==}
     dependencies:
-      call-bind: 1.0.5
+      call-bind: 1.0.7
       has-bigints: 1.0.2
       has-symbols: 1.0.3
       which-boxed-primitive: 1.0.2
     dev: true
 
-  /undici-types@5.26.5:
-    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
-
-  /unicorn-magic@0.1.0:
-    resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==}
-    engines: {node: '>=18'}
-    dev: true
+  /undici-types@6.20.0:
+    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}
 
   /universalify@2.0.1:
     resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
     engines: {node: '>= 10.0.0'}
     dev: true
 
-  /untildify@4.0.0:
-    resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /update-browserslist-db@1.0.13(browserslist@4.22.1):
-    resolution: {integrity: sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==}
+  /update-browserslist-db@1.1.1(browserslist@4.24.2):
+    resolution: {integrity: sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==}
     hasBin: true
     peerDependencies:
       browserslist: '>= 4.21.0'
     dependencies:
-      browserslist: 4.22.1
-      escalade: 3.1.1
-      picocolors: 1.0.0
+      browserslist: 4.24.2
+      escalade: 3.2.0
+      picocolors: 1.1.1
     dev: true
 
   /uri-js@4.4.1:
@@ -8421,18 +7542,14 @@ packages:
     dependencies:
       node-gyp-build: 4.6.1
 
-  /util-deprecate@1.0.2:
-    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
-    dev: true
-
   /util@0.12.5:
     resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==}
     dependencies:
       inherits: 2.0.4
       is-arguments: 1.1.1
       is-generator-function: 1.0.10
-      is-typed-array: 1.1.12
-      which-typed-array: 1.1.13
+      is-typed-array: 1.1.13
+      which-typed-array: 1.1.15
 
   /uuid@8.3.2:
     resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
@@ -8446,26 +7563,18 @@ packages:
     resolution: {integrity: sha512-9lDD+EVI2fjFsMWXc6dy5JJzBsVTcQ2fVkfBvncZ6xJWG9wtBhOldG+mHkSL0+V1K/xgZz0JDO5UT5hFwHUghg==}
     engines: {node: '>=10.12.0'}
     dependencies:
-      '@jridgewell/trace-mapping': 0.3.20
+      '@jridgewell/trace-mapping': 0.3.25
       '@types/istanbul-lib-coverage': 2.0.6
       convert-source-map: 2.0.0
     dev: true
 
-  /vscode-oniguruma@1.7.0:
-    resolution: {integrity: sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==}
-    dev: true
-
-  /vscode-textmate@8.0.0:
-    resolution: {integrity: sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==}
-    dev: true
-
-  /wait-on@7.2.0(debug@4.3.5):
-    resolution: {integrity: sha512-wCQcHkRazgjG5XoAq9jbTMLpNIjoSlZslrJ2+N9MxDsGEv1HnFoVjOCexL0ESva7Y9cu350j+DWADdk54s4AFQ==}
+  /wait-on@8.0.1(debug@4.4.0):
+    resolution: {integrity: sha512-1wWQOyR2LVVtaqrcIL2+OM+x7bkpmzVROa0Nf6FryXkS+er5Sa1kzFGjzZRqLnHa3n1rACFLeTwUqE1ETL9Mig==}
     engines: {node: '>=12.0.0'}
     hasBin: true
     dependencies:
-      axios: 1.6.2(debug@4.3.5)
-      joi: 17.11.0
+      axios: 1.7.7(debug@4.4.0)
+      joi: 17.13.3
       lodash: 4.17.21
       minimist: 1.2.8
       rxjs: 7.8.1
@@ -8482,11 +7591,6 @@ packages:
   /webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
-  /well-known-symbols@2.0.0:
-    resolution: {integrity: sha512-ZMjC3ho+KXo0BfJb7JgtQ5IBuvnShdlACNkKkdsqBmYw3bPAaJfPeYUo6tLUaT5tG/Gkh7xkpBhKRQ9e7pyg9Q==}
-    engines: {node: '>=6'}
-    dev: true
-
   /whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
     dependencies:
@@ -8503,15 +7607,15 @@ packages:
       is-symbol: 1.0.4
     dev: true
 
-  /which-typed-array@1.1.13:
-    resolution: {integrity: sha512-P5Nra0qjSncduVPEAr7xhoF5guty49ArDTwzJ/yNuPIbZppyRxFQsRCWrocxIY+CnMVG+qfbU2FmDKyvSGClow==}
+  /which-typed-array@1.1.15:
+    resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.5
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.7
       for-each: 0.3.3
       gopd: 1.0.1
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   /which@2.0.2:
     resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
@@ -8521,14 +7625,8 @@ packages:
       isexe: 2.0.0
     dev: true
 
-  /wide-align@1.1.5:
-    resolution: {integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==}
-    dependencies:
-      string-width: 4.2.3
-    dev: true
-
-  /workerpool@6.2.1:
-    resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==}
+  /workerpool@6.5.1:
+    resolution: {integrity: sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==}
     dev: true
 
   /wrap-ansi@7.0.0:
@@ -8569,8 +7667,8 @@ packages:
       signal-exit: 4.1.0
     dev: true
 
-  /ws@7.5.9:
-    resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==}
+  /ws@7.5.10:
+    resolution: {integrity: sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==}
     engines: {node: '>=8.3.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -8605,12 +7703,14 @@ packages:
     resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
     dev: true
 
-  /yallist@4.0.0:
-    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+  /yaml@2.6.1:
+    resolution: {integrity: sha512-7r0XPzioN/Q9kXBro/XPnA6kznR73DHq+GXh5ON7ZozRO6aMjbmiBuKste2wslTFkC5d1dw0GooOCepZXJ2SAg==}
+    engines: {node: '>= 14'}
+    hasBin: true
     dev: true
 
-  /yargs-parser@20.2.4:
-    resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==}
+  /yargs-parser@20.2.9:
+    resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==}
     engines: {node: '>=10'}
     dev: true
 
@@ -8634,12 +7734,12 @@ packages:
     engines: {node: '>=10'}
     dependencies:
       cliui: 7.0.4
-      escalade: 3.1.1
+      escalade: 3.2.0
       get-caller-file: 2.0.5
       require-directory: 2.1.1
       string-width: 4.2.3
       y18n: 5.0.8
-      yargs-parser: 20.2.4
+      yargs-parser: 20.2.9
     dev: true
 
   /yargs@17.7.2:
@@ -8647,7 +7747,7 @@ packages:
     engines: {node: '>=12'}
     dependencies:
       cliui: 8.0.1
-      escalade: 3.1.1
+      escalade: 3.2.0
       get-caller-file: 2.0.5
       require-directory: 2.1.1
       string-width: 4.2.3
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index e1424560139..3e3548b6355 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,7 +1,6 @@
 packages:
   - "account-compression/sdk"
   - "libraries/type-length-value/js"
-  - "memo/js"
   - "name-service/js"
   - "single-pool/js/packages/*"
   - "stake-pool/js"
diff --git a/record/README.md b/record/README.md
new file mode 100644
index 00000000000..8a80596b395
--- /dev/null
+++ b/record/README.md
@@ -0,0 +1,2 @@
+NOTE: The record program and clients are now maintained at
+[solana-program/record](https://github.com/solana-program/record).
diff --git a/record/program/Cargo.toml b/record/program/Cargo.toml
deleted file mode 100644
index 208b35b9c75..00000000000
--- a/record/program/Cargo.toml
+++ /dev/null
@@ -1,30 +0,0 @@
-[package]
-name = "spl-record"
-version = "0.2.0"
-description = "Solana Program Library Record Program"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-bytemuck = { version = "1.16.0", features = ["derive"] }
-num-derive = "0.4"
-num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-thiserror = "1.0"
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/record/program/Xargo.toml b/record/program/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/record/program/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/record/program/program-id.md b/record/program/program-id.md
deleted file mode 100644
index 09f28307584..00000000000
--- a/record/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-ReciQBw6sQKH9TVVJQDnbnJ5W7FP539tPHjZhRF4E9r
diff --git a/record/program/src/entrypoint.rs b/record/program/src/entrypoint.rs
deleted file mode 100644
index 62a02f2a465..00000000000
--- a/record/program/src/entrypoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Program entrypoint
-
-#![cfg(all(target_os = "solana", not(feature = "no-entrypoint")))]
-
-use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    crate::processor::process_instruction(program_id, accounts, instruction_data)
-}
diff --git a/record/program/src/error.rs b/record/program/src/error.rs
deleted file mode 100644
index d52354a89ff..00000000000
--- a/record/program/src/error.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! Error types
-
-use {
-    num_derive::FromPrimitive,
-    solana_program::{decode_error::DecodeError, program_error::ProgramError},
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the program.
-#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
-pub enum RecordError {
-    /// Incorrect authority provided on update or delete
-    #[error("Incorrect authority provided on update or delete")]
-    IncorrectAuthority,
-
-    /// Calculation overflow
-    #[error("Calculation overflow")]
-    Overflow,
-}
-impl From<RecordError> for ProgramError {
-    fn from(e: RecordError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for RecordError {
-    fn type_of() -> &'static str {
-        "Record Error"
-    }
-}
diff --git a/record/program/src/instruction.rs b/record/program/src/instruction.rs
deleted file mode 100644
index 93d4f3ea946..00000000000
--- a/record/program/src/instruction.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-//! Program instructions
-
-use {
-    crate::id,
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    std::mem::size_of,
-};
-
-/// Instructions supported by the program
-#[derive(Clone, Debug, PartialEq)]
-pub enum RecordInstruction<'a> {
-    /// Create a new record
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writable]` Record account, must be uninitialized
-    /// 1. `[]` Record authority
-    Initialize,
-
-    /// Write to the provided record account
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writable]` Record account, must be previously initialized
-    /// 1. `[signer]` Current record authority
-    Write {
-        /// Offset to start writing record, expressed as `u64`.
-        offset: u64,
-        /// Data to replace the existing record data
-        data: &'a [u8],
-    },
-
-    /// Update the authority of the provided record account
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writable]` Record account, must be previously initialized
-    /// 1. `[signer]` Current record authority
-    /// 2. `[]` New record authority
-    SetAuthority,
-
-    /// Close the provided record account, draining lamports to recipient
-    /// account
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writable]` Record account, must be previously initialized
-    /// 1. `[signer]` Record authority
-    /// 2. `[]` Receiver of account lamports
-    CloseAccount,
-
-    /// Reallocate additional space in a record account
-    ///
-    /// If the record account already has enough space to hold the specified
-    /// data length, then the instruction does nothing.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    /// 0. `[writable]` The record account to reallocate
-    /// 1. `[signer]` The account's owner
-    Reallocate {
-        /// The length of the data to hold in the record account excluding meta
-        /// data
-        data_length: u64,
-    },
-}
-
-impl<'a> RecordInstruction<'a> {
-    /// Unpacks a byte buffer into a [RecordInstruction].
-    pub fn unpack(input: &'a [u8]) -> Result<Self, ProgramError> {
-        const U32_BYTES: usize = 4;
-        const U64_BYTES: usize = 8;
-
-        let (&tag, rest) = input
-            .split_first()
-            .ok_or(ProgramError::InvalidInstructionData)?;
-        Ok(match tag {
-            0 => Self::Initialize,
-            1 => {
-                let offset = rest
-                    .get(..U64_BYTES)
-                    .and_then(|slice| slice.try_into().ok())
-                    .map(u64::from_le_bytes)
-                    .ok_or(ProgramError::InvalidInstructionData)?;
-                let (length, data) = rest[U64_BYTES..].split_at(U32_BYTES);
-                let length = u32::from_le_bytes(
-                    length
-                        .try_into()
-                        .map_err(|_| ProgramError::InvalidInstructionData)?,
-                ) as usize;
-
-                Self::Write {
-                    offset,
-                    data: &data[..length],
-                }
-            }
-            2 => Self::SetAuthority,
-            3 => Self::CloseAccount,
-            4 => {
-                let data_length = rest
-                    .get(..U64_BYTES)
-                    .and_then(|slice| slice.try_into().ok())
-                    .map(u64::from_le_bytes)
-                    .ok_or(ProgramError::InvalidInstructionData)?;
-
-                Self::Reallocate { data_length }
-            }
-            _ => return Err(ProgramError::InvalidInstructionData),
-        })
-    }
-
-    /// Packs a [RecordInstruction] into a byte buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = Vec::with_capacity(size_of::<Self>());
-        match self {
-            Self::Initialize => buf.push(0),
-            Self::Write { offset, data } => {
-                buf.push(1);
-                buf.extend_from_slice(&offset.to_le_bytes());
-                buf.extend_from_slice(&(data.len() as u32).to_le_bytes());
-                buf.extend_from_slice(data);
-            }
-            Self::SetAuthority => buf.push(2),
-            Self::CloseAccount => buf.push(3),
-            Self::Reallocate { data_length } => {
-                buf.push(4);
-                buf.extend_from_slice(&data_length.to_le_bytes());
-            }
-        };
-        buf
-    }
-}
-
-/// Create a `RecordInstruction::Initialize` instruction
-pub fn initialize(record_account: &Pubkey, authority: &Pubkey) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*record_account, false),
-            AccountMeta::new_readonly(*authority, false),
-        ],
-        data: RecordInstruction::Initialize.pack(),
-    }
-}
-
-/// Create a `RecordInstruction::Write` instruction
-pub fn write(record_account: &Pubkey, signer: &Pubkey, offset: u64, data: &[u8]) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*record_account, false),
-            AccountMeta::new_readonly(*signer, true),
-        ],
-        data: RecordInstruction::Write { offset, data }.pack(),
-    }
-}
-
-/// Create a `RecordInstruction::SetAuthority` instruction
-pub fn set_authority(
-    record_account: &Pubkey,
-    signer: &Pubkey,
-    new_authority: &Pubkey,
-) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*record_account, false),
-            AccountMeta::new_readonly(*signer, true),
-            AccountMeta::new_readonly(*new_authority, false),
-        ],
-        data: RecordInstruction::SetAuthority.pack(),
-    }
-}
-
-/// Create a `RecordInstruction::CloseAccount` instruction
-pub fn close_account(record_account: &Pubkey, signer: &Pubkey, receiver: &Pubkey) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*record_account, false),
-            AccountMeta::new_readonly(*signer, true),
-            AccountMeta::new(*receiver, false),
-        ],
-        data: RecordInstruction::CloseAccount.pack(),
-    }
-}
-
-/// Create a `RecordInstruction::Reallocate` instruction
-pub fn reallocate(record_account: &Pubkey, signer: &Pubkey, data_length: u64) -> Instruction {
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*record_account, false),
-            AccountMeta::new_readonly(*signer, true),
-        ],
-        data: RecordInstruction::Reallocate { data_length }.pack(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::state::tests::TEST_BYTES, solana_program::program_error::ProgramError};
-
-    #[test]
-    fn serialize_initialize() {
-        let instruction = RecordInstruction::Initialize;
-        let expected = vec![0];
-        assert_eq!(instruction.pack(), expected);
-        assert_eq!(RecordInstruction::unpack(&expected).unwrap(), instruction);
-    }
-
-    #[test]
-    fn serialize_write() {
-        let data = &TEST_BYTES;
-        let offset = 0u64;
-        let instruction = RecordInstruction::Write { offset: 0, data };
-        let mut expected = vec![1];
-        expected.extend_from_slice(&offset.to_le_bytes());
-        expected.extend_from_slice(&(data.len() as u32).to_le_bytes());
-        expected.extend_from_slice(data);
-        assert_eq!(instruction.pack(), expected);
-        assert_eq!(RecordInstruction::unpack(&expected).unwrap(), instruction);
-    }
-
-    #[test]
-    fn serialize_set_authority() {
-        let instruction = RecordInstruction::SetAuthority;
-        let expected = vec![2];
-        assert_eq!(instruction.pack(), expected);
-        assert_eq!(RecordInstruction::unpack(&expected).unwrap(), instruction);
-    }
-
-    #[test]
-    fn serialize_close_account() {
-        let instruction = RecordInstruction::CloseAccount;
-        let expected = vec![3];
-        assert_eq!(instruction.pack(), expected);
-        assert_eq!(RecordInstruction::unpack(&expected).unwrap(), instruction);
-    }
-
-    #[test]
-    fn serialize_reallocate() {
-        let data_length = 16u64;
-        let instruction = RecordInstruction::Reallocate { data_length };
-        let mut expected = vec![4];
-        expected.extend_from_slice(&data_length.to_le_bytes());
-        assert_eq!(instruction.pack(), expected);
-        assert_eq!(RecordInstruction::unpack(&expected).unwrap(), instruction);
-    }
-
-    #[test]
-    fn deserialize_invalid_instruction() {
-        let mut expected = vec![12];
-        expected.extend_from_slice(&TEST_BYTES);
-        let err: ProgramError = RecordInstruction::unpack(&expected).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidInstructionData);
-    }
-}
diff --git a/record/program/src/lib.rs b/record/program/src/lib.rs
deleted file mode 100644
index 72a77a70a90..00000000000
--- a/record/program/src/lib.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Record program
-#![deny(missing_docs)]
-
-mod entrypoint;
-pub mod error;
-pub mod instruction;
-pub mod processor;
-pub mod state;
-
-// Export current SDK types for downstream users building with a different SDK
-// version
-pub use solana_program;
-
-solana_program::declare_id!("recr1L3PCGKLbckBqMNcJhuuyU1zgo8nBhfLVsJNwr5");
diff --git a/record/program/src/processor.rs b/record/program/src/processor.rs
deleted file mode 100644
index 4d626cc7b96..00000000000
--- a/record/program/src/processor.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{error::RecordError, instruction::RecordInstruction, state::RecordData},
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        program_pack::IsInitialized,
-        pubkey::Pubkey,
-    },
-    spl_pod::bytemuck::{pod_from_bytes, pod_from_bytes_mut, pod_get_packed_len},
-};
-
-fn check_authority(authority_info: &AccountInfo, expected_authority: &Pubkey) -> ProgramResult {
-    if expected_authority != authority_info.key {
-        msg!("Incorrect record authority provided");
-        return Err(RecordError::IncorrectAuthority.into());
-    }
-    if !authority_info.is_signer {
-        msg!("Record authority signature missing");
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    Ok(())
-}
-
-/// Instruction processor
-pub fn process_instruction(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let instruction = RecordInstruction::unpack(input)?;
-    let account_info_iter = &mut accounts.iter();
-
-    match instruction {
-        RecordInstruction::Initialize => {
-            msg!("RecordInstruction::Initialize");
-
-            let data_info = next_account_info(account_info_iter)?;
-            let authority_info = next_account_info(account_info_iter)?;
-
-            let raw_data = &mut data_info.data.borrow_mut();
-            if raw_data.len() < RecordData::WRITABLE_START_INDEX {
-                return Err(ProgramError::InvalidAccountData);
-            }
-
-            let account_data = pod_from_bytes_mut::<RecordData>(
-                &mut raw_data[..RecordData::WRITABLE_START_INDEX],
-            )?;
-            if account_data.is_initialized() {
-                msg!("Record account already initialized");
-                return Err(ProgramError::AccountAlreadyInitialized);
-            }
-
-            account_data.authority = *authority_info.key;
-            account_data.version = RecordData::CURRENT_VERSION;
-            Ok(())
-        }
-
-        RecordInstruction::Write { offset, data } => {
-            msg!("RecordInstruction::Write");
-            let data_info = next_account_info(account_info_iter)?;
-            let authority_info = next_account_info(account_info_iter)?;
-            {
-                let raw_data = &data_info.data.borrow();
-                if raw_data.len() < RecordData::WRITABLE_START_INDEX {
-                    return Err(ProgramError::InvalidAccountData);
-                }
-                let account_data =
-                    pod_from_bytes::<RecordData>(&raw_data[..RecordData::WRITABLE_START_INDEX])?;
-                if !account_data.is_initialized() {
-                    msg!("Record account not initialized");
-                    return Err(ProgramError::UninitializedAccount);
-                }
-                check_authority(authority_info, &account_data.authority)?;
-            }
-            let start = RecordData::WRITABLE_START_INDEX.saturating_add(offset as usize);
-            let end = start.saturating_add(data.len());
-            if end > data_info.data.borrow().len() {
-                Err(ProgramError::AccountDataTooSmall)
-            } else {
-                data_info.data.borrow_mut()[start..end].copy_from_slice(data);
-                Ok(())
-            }
-        }
-
-        RecordInstruction::SetAuthority => {
-            msg!("RecordInstruction::SetAuthority");
-            let data_info = next_account_info(account_info_iter)?;
-            let authority_info = next_account_info(account_info_iter)?;
-            let new_authority_info = next_account_info(account_info_iter)?;
-            let raw_data = &mut data_info.data.borrow_mut();
-            if raw_data.len() < RecordData::WRITABLE_START_INDEX {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            let account_data = pod_from_bytes_mut::<RecordData>(
-                &mut raw_data[..RecordData::WRITABLE_START_INDEX],
-            )?;
-            if !account_data.is_initialized() {
-                msg!("Record account not initialized");
-                return Err(ProgramError::UninitializedAccount);
-            }
-            check_authority(authority_info, &account_data.authority)?;
-            account_data.authority = *new_authority_info.key;
-            Ok(())
-        }
-
-        RecordInstruction::CloseAccount => {
-            msg!("RecordInstruction::CloseAccount");
-            let data_info = next_account_info(account_info_iter)?;
-            let authority_info = next_account_info(account_info_iter)?;
-            let destination_info = next_account_info(account_info_iter)?;
-            let raw_data = &mut data_info.data.borrow_mut();
-            if raw_data.len() < RecordData::WRITABLE_START_INDEX {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            let account_data = pod_from_bytes_mut::<RecordData>(
-                &mut raw_data[..RecordData::WRITABLE_START_INDEX],
-            )?;
-            if !account_data.is_initialized() {
-                msg!("Record not initialized");
-                return Err(ProgramError::UninitializedAccount);
-            }
-            check_authority(authority_info, &account_data.authority)?;
-            let destination_starting_lamports = destination_info.lamports();
-            let data_lamports = data_info.lamports();
-            **data_info.lamports.borrow_mut() = 0;
-            **destination_info.lamports.borrow_mut() = destination_starting_lamports
-                .checked_add(data_lamports)
-                .ok_or(RecordError::Overflow)?;
-            Ok(())
-        }
-
-        RecordInstruction::Reallocate { data_length } => {
-            msg!("RecordInstruction::Reallocate");
-            let data_info = next_account_info(account_info_iter)?;
-            let authority_info = next_account_info(account_info_iter)?;
-
-            {
-                let raw_data = &mut data_info.data.borrow_mut();
-                if raw_data.len() < RecordData::WRITABLE_START_INDEX {
-                    return Err(ProgramError::InvalidAccountData);
-                }
-                let account_data = pod_from_bytes_mut::<RecordData>(
-                    &mut raw_data[..RecordData::WRITABLE_START_INDEX],
-                )?;
-                if !account_data.is_initialized() {
-                    msg!("Record not initialized");
-                    return Err(ProgramError::UninitializedAccount);
-                }
-                check_authority(authority_info, &account_data.authority)?;
-            }
-
-            // needed account length is the sum of the meta data length and the specified
-            // data length
-            let needed_account_length = pod_get_packed_len::<RecordData>()
-                .checked_add(
-                    usize::try_from(data_length).map_err(|_| ProgramError::InvalidArgument)?,
-                )
-                .unwrap();
-
-            // reallocate
-            if data_info.data_len() >= needed_account_length {
-                msg!("no additional reallocation needed");
-                return Ok(());
-            }
-            msg!(
-                "reallocating +{:?} bytes",
-                needed_account_length
-                    .checked_sub(data_info.data_len())
-                    .unwrap(),
-            );
-            data_info.realloc(needed_account_length, false)?;
-            Ok(())
-        }
-    }
-}
diff --git a/record/program/src/state.rs b/record/program/src/state.rs
deleted file mode 100644
index c809ec0a98d..00000000000
--- a/record/program/src/state.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-//! Program state
-use {
-    bytemuck::{Pod, Zeroable},
-    solana_program::{program_pack::IsInitialized, pubkey::Pubkey},
-};
-
-/// Header type for recorded account data
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-pub struct RecordData {
-    /// Struct version, allows for upgrades to the program
-    pub version: u8,
-
-    /// The account allowed to update the data
-    pub authority: Pubkey,
-}
-
-impl RecordData {
-    /// Version to fill in on new created accounts
-    pub const CURRENT_VERSION: u8 = 1;
-
-    /// Start of writable account data, after version and authority
-    pub const WRITABLE_START_INDEX: usize = 33;
-}
-
-impl IsInitialized for RecordData {
-    /// Is initialized
-    fn is_initialized(&self) -> bool {
-        self.version == Self::CURRENT_VERSION
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use {
-        super::*,
-        solana_program::program_error::ProgramError,
-        spl_pod::bytemuck::{pod_bytes_of, pod_from_bytes},
-    };
-
-    /// Version for tests
-    pub const TEST_VERSION: u8 = 1;
-    /// Pubkey for tests
-    pub const TEST_PUBKEY: Pubkey = Pubkey::new_from_array([100; 32]);
-    /// Bytes for tests
-    pub const TEST_BYTES: [u8; 8] = [42; 8];
-    /// RecordData for tests
-    pub const TEST_RECORD_DATA: RecordData = RecordData {
-        version: TEST_VERSION,
-        authority: TEST_PUBKEY,
-    };
-
-    #[test]
-    fn serialize_data() {
-        let mut expected = vec![TEST_VERSION];
-        expected.extend_from_slice(&TEST_PUBKEY.to_bytes());
-        assert_eq!(pod_bytes_of(&TEST_RECORD_DATA), expected);
-        assert_eq!(
-            *pod_from_bytes::<RecordData>(&expected).unwrap(),
-            TEST_RECORD_DATA,
-        );
-    }
-
-    #[test]
-    fn deserialize_invalid_slice() {
-        let mut expected = vec![TEST_VERSION];
-        expected.extend_from_slice(&TEST_PUBKEY.to_bytes());
-        expected.extend_from_slice(&TEST_BYTES);
-        let err: ProgramError = pod_from_bytes::<RecordData>(&expected).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidArgument);
-    }
-}
diff --git a/record/program/tests/functional.rs b/record/program/tests/functional.rs
deleted file mode 100644
index 4f4d325f286..00000000000
--- a/record/program/tests/functional.rs
+++ /dev/null
@@ -1,696 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program::{
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-        rent::Rent,
-        system_instruction,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_pod::bytemuck::{pod_from_bytes, pod_get_packed_len},
-    spl_record::{
-        error::RecordError, id, instruction, processor::process_instruction, state::RecordData,
-    },
-};
-
-fn program_test() -> ProgramTest {
-    ProgramTest::new("spl_record", id(), processor!(process_instruction))
-}
-
-async fn initialize_storage_account(
-    context: &mut ProgramTestContext,
-    authority: &Keypair,
-    account: &Keypair,
-    data: &[u8],
-) {
-    let account_length = pod_get_packed_len::<RecordData>()
-        .checked_add(data.len())
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &account.pubkey(),
-                1.max(Rent::default().minimum_balance(account_length)),
-                account_length as u64,
-                &id(),
-            ),
-            instruction::initialize(&account.pubkey(), &authority.pubkey()),
-            instruction::write(&account.pubkey(), &authority.pubkey(), 0, data),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, account, authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn initialize_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[111u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let account = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let account_data =
-        pod_from_bytes::<RecordData>(&account.data[..RecordData::WRITABLE_START_INDEX]).unwrap();
-    assert_eq!(account_data.authority, authority.pubkey());
-    assert_eq!(account_data.version, RecordData::CURRENT_VERSION);
-    assert_eq!(&account.data[RecordData::WRITABLE_START_INDEX..], data);
-}
-
-#[tokio::test]
-async fn initialize_with_seed_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let seed = "storage";
-    let account = Pubkey::create_with_seed(&authority.pubkey(), seed, &id()).unwrap();
-    let data = &[111u8; 8];
-    let account_length = pod_get_packed_len::<RecordData>()
-        .checked_add(data.len())
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account_with_seed(
-                &context.payer.pubkey(),
-                &account,
-                &authority.pubkey(),
-                seed,
-                1.max(Rent::default().minimum_balance(account_length)),
-                account_length as u64,
-                &id(),
-            ),
-            instruction::initialize(&account, &authority.pubkey()),
-            instruction::write(&account, &authority.pubkey(), 0, data),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-    let account = context
-        .banks_client
-        .get_account(account)
-        .await
-        .unwrap()
-        .unwrap();
-    let account_data =
-        pod_from_bytes::<RecordData>(&account.data[..RecordData::WRITABLE_START_INDEX]).unwrap();
-    assert_eq!(account_data.authority, authority.pubkey());
-    assert_eq!(account_data.version, RecordData::CURRENT_VERSION);
-    assert_eq!(&account.data[RecordData::WRITABLE_START_INDEX..], data);
-}
-
-#[tokio::test]
-async fn initialize_twice_fail() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[111u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::initialize(
-            &account.pubkey(),
-            &authority.pubkey(),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::AccountAlreadyInitialized)
-    );
-}
-
-#[tokio::test]
-async fn write_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let new_data = &[200u8; 8];
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::write(
-            &account.pubkey(),
-            &authority.pubkey(),
-            0,
-            new_data,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let account_data =
-        pod_from_bytes::<RecordData>(&account.data[..RecordData::WRITABLE_START_INDEX]).unwrap();
-    assert_eq!(account_data.authority, authority.pubkey());
-    assert_eq!(account_data.version, RecordData::CURRENT_VERSION);
-    assert_eq!(&account.data[RecordData::WRITABLE_START_INDEX..], new_data);
-}
-
-#[tokio::test]
-async fn write_fail_wrong_authority() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let new_data = &[200u8; 8];
-    let wrong_authority = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::write(
-            &account.pubkey(),
-            &wrong_authority.pubkey(),
-            0,
-            new_data,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(RecordError::IncorrectAuthority as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn write_fail_unsigned() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let data = &[200u8; 8];
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new(account.pubkey(), false),
-                AccountMeta::new_readonly(authority.pubkey(), false),
-            ],
-            data: instruction::RecordInstruction::Write { offset: 0, data }.pack(),
-        }],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-}
-
-#[tokio::test]
-async fn close_account_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    let account_length = pod_get_packed_len::<RecordData>()
-        .checked_add(data.len())
-        .unwrap();
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-    let recipient = Pubkey::new_unique();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::close_account(
-            &account.pubkey(),
-            &authority.pubkey(),
-            &recipient,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account = context
-        .banks_client
-        .get_account(recipient)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        account.lamports,
-        1.max(Rent::default().minimum_balance(account_length))
-    );
-}
-
-#[tokio::test]
-async fn close_account_fail_wrong_authority() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let wrong_authority = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new(account.pubkey(), false),
-                AccountMeta::new_readonly(wrong_authority.pubkey(), true),
-                AccountMeta::new(Pubkey::new_unique(), false),
-            ],
-            data: instruction::RecordInstruction::CloseAccount.pack(),
-        }],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(RecordError::IncorrectAuthority as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn close_account_fail_unsigned() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8, 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new(account.pubkey(), false),
-                AccountMeta::new_readonly(authority.pubkey(), false),
-                AccountMeta::new(Pubkey::new_unique(), false),
-            ],
-            data: instruction::RecordInstruction::CloseAccount.pack(),
-        }],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-}
-
-#[tokio::test]
-async fn set_authority_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-    let new_authority = Keypair::new();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_authority(
-            &account.pubkey(),
-            &authority.pubkey(),
-            &new_authority.pubkey(),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account_handle = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let account_data =
-        pod_from_bytes::<RecordData>(&account_handle.data[..RecordData::WRITABLE_START_INDEX])
-            .unwrap();
-    assert_eq!(account_data.authority, new_authority.pubkey());
-
-    let new_data = &[200u8; 8];
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::write(
-            &account.pubkey(),
-            &new_authority.pubkey(),
-            0,
-            new_data,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &new_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account_handle = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let account_data =
-        pod_from_bytes::<RecordData>(&account_handle.data[..RecordData::WRITABLE_START_INDEX])
-            .unwrap();
-    assert_eq!(account_data.authority, new_authority.pubkey());
-    assert_eq!(account_data.version, RecordData::CURRENT_VERSION);
-    assert_eq!(
-        &account_handle.data[RecordData::WRITABLE_START_INDEX..],
-        new_data,
-    );
-}
-
-#[tokio::test]
-async fn set_authority_fail_wrong_authority() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let wrong_authority = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new(account.pubkey(), false),
-                AccountMeta::new_readonly(wrong_authority.pubkey(), true),
-                AccountMeta::new(Pubkey::new_unique(), false),
-            ],
-            data: instruction::RecordInstruction::SetAuthority.pack(),
-        }],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(RecordError::IncorrectAuthority as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn set_authority_fail_unsigned() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id: id(),
-            accounts: vec![
-                AccountMeta::new(account.pubkey(), false),
-                AccountMeta::new_readonly(authority.pubkey(), false),
-                AccountMeta::new(Pubkey::new_unique(), false),
-            ],
-            data: instruction::RecordInstruction::SetAuthority.pack(),
-        }],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-}
-
-#[tokio::test]
-async fn reallocate_success() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let new_data_length = 16u64;
-    let expected_account_data_length = RecordData::WRITABLE_START_INDEX
-        .checked_add(new_data_length as usize)
-        .unwrap();
-
-    let delta_account_data_length = new_data_length.saturating_sub(data.len() as u64);
-    let additional_lamports_needed =
-        Rent::default().minimum_balance(delta_account_data_length as usize);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::reallocate(&account.pubkey(), &authority.pubkey(), new_data_length),
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &account.pubkey(),
-                additional_lamports_needed,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account_handle = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(account_handle.data.len(), expected_account_data_length);
-
-    // reallocate to a smaller length
-    let old_data_length = 8u64;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::reallocate(
-            &account.pubkey(),
-            &authority.pubkey(),
-            old_data_length,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let account = context
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(account.data.len(), expected_account_data_length);
-}
-
-#[tokio::test]
-async fn reallocate_fail_wrong_authority() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let new_data_length = 16u64;
-    let delta_account_data_length = new_data_length.saturating_sub(data.len() as u64);
-    let additional_lamports_needed =
-        Rent::default().minimum_balance(delta_account_data_length as usize);
-
-    let wrong_authority = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            Instruction {
-                program_id: id(),
-                accounts: vec![
-                    AccountMeta::new(account.pubkey(), false),
-                    AccountMeta::new(wrong_authority.pubkey(), true),
-                ],
-                data: instruction::RecordInstruction::Reallocate {
-                    data_length: new_data_length,
-                }
-                .pack(),
-            },
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &account.pubkey(),
-                additional_lamports_needed,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_authority],
-        context.last_blockhash,
-    );
-
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(RecordError::IncorrectAuthority as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn reallocate_fail_unsigned() {
-    let mut context = program_test().start_with_context().await;
-
-    let authority = Keypair::new();
-    let account = Keypair::new();
-    let data = &[222u8; 8];
-    initialize_storage_account(&mut context, &authority, &account, data).await;
-
-    let new_data_length = 16u64;
-    let delta_account_data_length = new_data_length.saturating_sub(data.len() as u64);
-    let additional_lamports_needed =
-        Rent::default().minimum_balance(delta_account_data_length as usize);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            Instruction {
-                program_id: id(),
-                accounts: vec![
-                    AccountMeta::new(account.pubkey(), false),
-                    AccountMeta::new(authority.pubkey(), false),
-                ],
-                data: instruction::RecordInstruction::Reallocate {
-                    data_length: new_data_length,
-                }
-                .pack(),
-            },
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &account.pubkey(),
-                additional_lamports_needed,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-}
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 624eb0ea639..1de01fa45c4 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.76.0"
+channel = "1.81.0"
diff --git a/shared-memory/program/Cargo.toml b/shared-memory/program/Cargo.toml
index 663fed52f07..b02656a05e9 100644
--- a/shared-memory/program/Cargo.toml
+++ b/shared-memory/program/Cargo.toml
@@ -11,12 +11,12 @@ edition = "2021"
 test-sbf = []
 
 [dependencies]
-arrayref = "0.3.7"
-solana-program = ">=1.18.11,<=2"
+arrayref = "0.3.9"
+solana-program = "2.1.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/shared-memory/program/tests/shared-memory.rs b/shared-memory/program/tests/shared-memory.rs
index c8a327c8c14..cbed1e5d467 100644
--- a/shared-memory/program/tests/shared-memory.rs
+++ b/shared-memory/program/tests/shared-memory.rs
@@ -35,7 +35,7 @@ async fn assert_instruction_count() {
         },
     );
     program_test.set_compute_max_units(480);
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
+    let (banks_client, payer, recent_blockhash) = program_test.start().await;
 
     // success
     let content = vec![42; NUM_TO_SHARE];
@@ -74,7 +74,7 @@ async fn test_helloworld() {
             ..Account::default()
         },
     );
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
+    let (banks_client, payer, recent_blockhash) = program_test.start().await;
 
     // success
     let content = vec![42; NUM_TO_SHARE];
diff --git a/single-pool/README.md b/single-pool/README.md
index 9b8bba716d2..4c2a2cfad01 100644
--- a/single-pool/README.md
+++ b/single-pool/README.md
@@ -1,9 +1,2 @@
-## Solana Program Library Single-Validator Stake Pool
-
-The single-validator stake pool program is an upcoming SPL program that enables liquid staking with zero fees, no counterparty, and 100% capital efficiency.
-
-The program defines a canonical pool for every vote account, which can be initialized permissionlessly, and mints tokens in exchange for stake delegated to its designated validator.
-
-The program is a stripped-down adaptation of the existing multi-validator stake pool program, with approximately 80% less code, to minimize execution risk.
-
-On launch, users will only be able to deposit and withdraw active stake, but pending future stake program development, we hope to support instant sol deposits and withdrawals as well.
+NOTE: The single-pool program and clients are now maintained at
+[solana-program/single-pool](https://github.com/solana-program/single-pool).
diff --git a/single-pool/cli/Cargo.toml b/single-pool/cli/Cargo.toml
deleted file mode 100644
index ca77a8371f5..00000000000
--- a/single-pool/cli/Cargo.toml
+++ /dev/null
@@ -1,49 +0,0 @@
-[package]
-name = "spl-single-pool-cli"
-version = "1.0.0"
-description = "Solana Program Library Single-Validator Stake Pool Command-line Utility"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-tokio = "1.38"
-clap = { version = "3.2.23", features = ["derive"] }
-console = "0.15.8"
-borsh = "1.5.1"
-bincode = "1.3.1"
-serde = "1.0.203"
-serde_derive = "1.0.103"
-serde_json = "1.0.117"
-serde_with = "3.8.1"
-solana-account-decoder = ">=1.18.11,<=2"
-solana-clap-v3-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-cli-output = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-remote-wallet = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-solana-transaction-status = ">=1.18.11,<=2"
-solana-vote-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-spl-single-pool = { version = "1.0.0", path = "../program", features = [
-  "no-entrypoint",
-] }
-
-[dev-dependencies]
-solana-test-validator = ">=1.18.11,<=2"
-serial_test = "3.1.1"
-test-case = "3.3"
-tempfile = "3.10.1"
-
-[[bin]]
-name = "spl-single-pool"
-path = "src/main.rs"
diff --git a/single-pool/cli/src/cli.rs b/single-pool/cli/src/cli.rs
deleted file mode 100644
index ae6351fc02d..00000000000
--- a/single-pool/cli/src/cli.rs
+++ /dev/null
@@ -1,473 +0,0 @@
-use {
-    crate::config::Error,
-    clap::{
-        builder::{PossibleValuesParser, TypedValueParser},
-        ArgGroup, ArgMatches, Args, Parser, Subcommand,
-    },
-    solana_clap_v3_utils::{
-        input_parsers::{parse_url_or_moniker, Amount},
-        input_validators::{is_valid_pubkey, is_valid_signer},
-        keypair::{pubkey_from_path, signer_from_path},
-    },
-    solana_cli_output::OutputFormat,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{pubkey::Pubkey, signer::Signer},
-    spl_single_pool::{self, find_pool_address},
-    std::{rc::Rc, str::FromStr, sync::Arc},
-};
-
-#[derive(Clone, Debug, Parser)]
-#[clap(author, version, about, long_about = None)]
-pub struct Cli {
-    /// Configuration file to use
-    #[clap(global(true), short = 'C', long = "config", id = "PATH")]
-    pub config_file: Option<String>,
-
-    /// Show additional information
-    #[clap(global(true), short, long)]
-    pub verbose: bool,
-
-    /// Simulate transaction instead of executing
-    #[clap(global(true), long, alias = "dryrun")]
-    pub dry_run: bool,
-
-    /// URL for Solana's JSON RPC or moniker (or their first letter):
-    /// [mainnet-beta, testnet, devnet, localhost].
-    /// Default from the configuration file.
-    #[clap(
-        global(true),
-        short = 'u',
-        long = "url",
-        id = "URL_OR_MONIKER",
-        value_parser = parse_url_or_moniker,
-    )]
-    pub json_rpc_url: Option<String>,
-
-    /// Specify the fee-payer account. This may be a keypair file, the ASK
-    /// keyword or the pubkey of an offline signer, provided an appropriate
-    /// --signer argument is also passed. Defaults to the client keypair.
-    #[clap(
-        global(true),
-        long,
-        id = "PAYER_KEYPAIR",
-        validator = |s| is_valid_signer(s),
-    )]
-    pub fee_payer: Option<SignerArg>,
-
-    /// Return information in specified output format
-    #[clap(
-        global(true),
-        long = "output",
-        id = "FORMAT",
-        conflicts_with = "verbose",
-        value_parser = PossibleValuesParser::new(["json", "json-compact"]).map(|o| parse_output_format(&o)),
-    )]
-    pub output_format: Option<OutputFormat>,
-
-    #[clap(subcommand)]
-    pub command: Command,
-}
-
-#[derive(Clone, Debug, Subcommand)]
-pub enum Command {
-    /// Commands used to initialize or manage existing single-validator stake
-    /// pools. Other than initializing new pools, most users should never
-    /// need to use these.
-    Manage(ManageCli),
-
-    /// Deposit delegated stake into a pool in exchange for pool tokens, closing
-    /// out the original stake account. Provide either a stake account
-    /// address, or a pool or vote account address along with the
-    /// --default-stake-account flag to use an account created with
-    /// create-stake.
-    Deposit(DepositCli),
-
-    /// Withdraw stake into a new stake account, burning tokens in exchange.
-    /// Provide either pool or vote account address, plus either an amount of
-    /// tokens to burn or the ALL keyword to burn all.
-    Withdraw(WithdrawCli),
-
-    /// Create and delegate a new stake account to a given validator, using a
-    /// default address linked to the intended depository pool
-    CreateDefaultStake(CreateStakeCli),
-
-    /// Display info for one or all single-validator stake pool(s)
-    Display(DisplayCli),
-}
-
-#[derive(Clone, Debug, Parser)]
-pub struct ManageCli {
-    #[clap(subcommand)]
-    pub manage: ManageCommand,
-}
-
-#[derive(Clone, Debug, Subcommand)]
-pub enum ManageCommand {
-    /// Permissionlessly create the single-validator stake pool for a given
-    /// validator vote account if one does not already exist. The fee payer
-    /// also pays rent-exemption for accounts, along with the
-    /// cluster-configured minimum stake delegation
-    Initialize(InitializeCli),
-
-    /// Permissionlessly re-stake the pool stake account in the case when it has
-    /// been deactivated. This may happen if the validator is
-    /// force-deactivated, and then later reactivated using the same address
-    /// for its vote account.
-    ReactivatePoolStake(ReactivateCli),
-
-    /// Permissionlessly create default MPL token metadata for the pool mint.
-    /// Normally this is done automatically upon initialization, so this
-    /// does not need to be called.
-    CreateTokenMetadata(CreateMetadataCli),
-
-    /// Modify the MPL token metadata associated with the pool mint. This action
-    /// can only be performed by the validator vote account's withdraw
-    /// authority
-    UpdateTokenMetadata(UpdateMetadataCli),
-}
-
-#[derive(Clone, Debug, Args)]
-pub struct InitializeCli {
-    /// The vote account to create the pool for
-    #[clap(value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Pubkey,
-
-    /// Do not create MPL metadata for the pool mint
-    #[clap(long)]
-    pub skip_metadata: bool,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group()))]
-pub struct ReactivateCli {
-    /// The pool to reactivate
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to reactivate
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    // backdoor for testing, theres no reason to ever use this
-    #[clap(long, hide = true)]
-    pub skip_deactivation_check: bool,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(ArgGroup::new("stake-source").required(true).args(&["stake-account-address", "default-stake-account"])))]
-#[clap(group(pool_source_group().required(false)))]
-pub struct DepositCli {
-    /// The stake account to deposit from. Must be in the same activation state
-    /// as the pool's stake account
-    #[clap(value_parser = |p: &str| parse_address(p, "stake_account_address"))]
-    pub stake_account_address: Option<Pubkey>,
-
-    /// Instead of using a stake account by address, use the user's default
-    /// account for a specified pool
-    #[clap(
-        short,
-        long,
-        conflicts_with = "stake-account-address",
-        requires = "pool-source"
-    )]
-    pub default_stake_account: bool,
-
-    /// The pool to deposit into. Optional when stake account is provided
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to deposit into. Optional
-    /// when stake account or pool is provided
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    /// Signing authority on the stake account to be deposited. Defaults to the
-    /// client keypair
-    #[clap(long = "withdraw-authority", id = "STAKE_WITHDRAW_AUTHORITY_KEYPAIR", validator = |s| is_valid_signer(s))]
-    pub stake_withdraw_authority: Option<SignerArg>,
-
-    /// The token account to mint to. Defaults to the client keypair's
-    /// associated token account
-    #[clap(long = "token-account", value_parser = |p: &str| parse_address(p, "token_account_address"))]
-    pub token_account_address: Option<Pubkey>,
-
-    /// The wallet to refund stake account rent to. Defaults to the client
-    /// keypair's pubkey
-    #[clap(long = "recipient", value_parser = |p: &str| parse_address(p, "lamport_recipient_address"))]
-    pub lamport_recipient_address: Option<Pubkey>,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group()))]
-pub struct WithdrawCli {
-    /// Amount of tokens to burn for withdrawal
-    #[clap(value_parser = Amount::parse_decimal_or_all)]
-    pub token_amount: Amount,
-
-    /// The token account to withdraw from. Defaults to the associated token
-    /// account for the pool mint
-    #[clap(long = "token-account", value_parser = |p: &str| parse_address(p, "token_account_address"))]
-    pub token_account_address: Option<Pubkey>,
-
-    /// The pool to withdraw from
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to withdraw from
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    /// Signing authority on the token account. Defaults to the client keypair
-    #[clap(long = "token-authority", id = "TOKEN_AUTHORITY_KEYPAIR", validator = |s| is_valid_signer(s))]
-    pub token_authority: Option<SignerArg>,
-
-    /// Authority to assign to the new stake account. Defaults to the pubkey of
-    /// the client keypair
-    #[clap(long = "stake-authority", value_parser = |p: &str| parse_address(p, "stake_authority_address"))]
-    pub stake_authority_address: Option<Pubkey>,
-
-    /// Deactivate stake account after withdrawal
-    #[clap(long)]
-    pub deactivate: bool,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group()))]
-pub struct CreateMetadataCli {
-    /// The pool to create default MPL token metadata for
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to create metadata for
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group()))]
-pub struct UpdateMetadataCli {
-    /// New name for the pool token
-    #[clap(validator = is_valid_token_name)]
-    pub token_name: String,
-
-    /// New ticker symbol for the pool token
-    #[clap(validator = is_valid_token_symbol)]
-    pub token_symbol: String,
-
-    /// Optional external URI for the pool token. Leaving this argument blank
-    /// will clear any existing value
-    #[clap(validator = is_valid_token_uri)]
-    pub token_uri: Option<String>,
-
-    /// The pool to change MPL token metadata for
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to create metadata for
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    /// Authorized withdrawer for the vote account, to prove validator
-    /// ownership. Defaults to the client keypair
-    #[clap(long, id = "AUTHORIZED_WITHDRAWER_KEYPAIR", validator = |s| is_valid_signer(s))]
-    pub authorized_withdrawer: Option<SignerArg>,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group()))]
-pub struct CreateStakeCli {
-    /// Number of lamports to stake
-    pub lamports: u64,
-
-    /// The pool to create a stake account for
-    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to create stake for
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    /// Authority to assign to the new stake account. Defaults to the pubkey of
-    /// the client keypair
-    #[clap(long = "stake-authority", value_parser = |p: &str| parse_address(p, "stake_authority_address"))]
-    pub stake_authority_address: Option<Pubkey>,
-}
-
-#[derive(Clone, Debug, Args)]
-#[clap(group(pool_source_group().arg("all")))]
-pub struct DisplayCli {
-    /// The pool to display
-    #[clap(value_parser = |p: &str| parse_address(p, "pool_address"))]
-    pub pool_address: Option<Pubkey>,
-
-    /// The vote account corresponding to the pool to display
-    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
-    pub vote_account_address: Option<Pubkey>,
-
-    /// Display all pools
-    #[clap(long)]
-    pub all: bool,
-}
-
-fn pool_source_group() -> ArgGroup<'static> {
-    ArgGroup::new("pool-source")
-        .required(true)
-        .args(&["pool-address", "vote-account-address"])
-}
-
-pub fn parse_address(path: &str, name: &str) -> Result<Pubkey, String> {
-    if is_valid_pubkey(path).is_ok() {
-        // this all is ugly but safe
-        // wallet_manager doesn't need to be shared, it just saves cycles to cache it
-        // and the only way argmatches default fails with an unchecked lookup is in the
-        // prompt branch which seems unlikely to ever be used for pubkeys
-        // the usb lookup in signer_from_path_with_config is safe
-        // and the pubkey lookups are unreachable because pubkey_from_path short
-        // circuits that case
-        let mut wallet_manager = None;
-        pubkey_from_path(&ArgMatches::default(), path, name, &mut wallet_manager)
-            .map_err(|_| format!("Failed to load pubkey {} at {}", name, path))
-    } else {
-        Err(format!("Failed to parse pubkey {} at {}", name, path))
-    }
-}
-
-pub fn parse_output_format(output_format: &str) -> OutputFormat {
-    match output_format {
-        "json" => OutputFormat::Json,
-        "json-compact" => OutputFormat::JsonCompact,
-        _ => unreachable!(),
-    }
-}
-
-pub fn is_valid_token_name(s: &str) -> Result<(), String> {
-    if s.len() > 32 {
-        Err("Maximum token name length is 32 characters".to_string())
-    } else {
-        Ok(())
-    }
-}
-
-pub fn is_valid_token_symbol(s: &str) -> Result<(), String> {
-    if s.len() > 10 {
-        Err("Maximum token symbol length is 10 characters".to_string())
-    } else {
-        Ok(())
-    }
-}
-
-pub fn is_valid_token_uri(s: &str) -> Result<(), String> {
-    if s.len() > 200 {
-        Err("Maximum token URI length is 200 characters".to_string())
-    } else {
-        Ok(())
-    }
-}
-
-pub fn pool_address_from_args(maybe_pool: Option<Pubkey>, maybe_vote: Option<Pubkey>) -> Pubkey {
-    if let Some(pool_address) = maybe_pool {
-        pool_address
-    } else if let Some(vote_account_address) = maybe_vote {
-        find_pool_address(&spl_single_pool::id(), &vote_account_address)
-    } else {
-        unreachable!()
-    }
-}
-
-// all this is because solana clap v3 utils signer handlers dont work with
-// derive syntax which means its impossible to parse keypairs or addresses in
-// value_parser instead, we take the input into a string wrapper from the cli
-// and then once the first pass is over, we do a second manual pass converting
-// to signer wrappers
-#[derive(Clone, Debug)]
-pub enum SignerArg {
-    Source(String),
-    Signer(Arc<dyn Signer>),
-}
-impl FromStr for SignerArg {
-    type Err = std::convert::Infallible;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Self::Source(s.to_string()))
-    }
-}
-impl PartialEq for SignerArg {
-    fn eq(&self, other: &SignerArg) -> bool {
-        match (self, other) {
-            (SignerArg::Source(ref a), SignerArg::Source(ref b)) => a == b,
-            (SignerArg::Signer(ref a), SignerArg::Signer(ref b)) => a == b,
-            (_, _) => false,
-        }
-    }
-}
-
-pub fn signer_from_arg(
-    signer_arg: Option<SignerArg>,
-    default_signer: &Arc<dyn Signer>,
-) -> Result<Arc<dyn Signer>, Error> {
-    match signer_arg {
-        Some(SignerArg::Signer(signer)) => Ok(signer),
-        Some(SignerArg::Source(_)) => Err("Signer arg string must be converted to signer".into()),
-        None => Ok(default_signer.clone()),
-    }
-}
-
-impl Command {
-    pub fn with_signers(
-        mut self,
-        matches: &ArgMatches,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    ) -> Result<Self, Error> {
-        match self {
-            Command::Deposit(ref mut config) => {
-                config.stake_withdraw_authority = with_signer(
-                    matches,
-                    wallet_manager,
-                    config.stake_withdraw_authority.clone(),
-                    "stake_authority",
-                )?;
-            }
-            Command::Withdraw(ref mut config) => {
-                config.token_authority = with_signer(
-                    matches,
-                    wallet_manager,
-                    config.token_authority.clone(),
-                    "token_authority",
-                )?;
-            }
-            Command::Manage(ManageCli {
-                manage: ManageCommand::UpdateTokenMetadata(ref mut config),
-            }) => {
-                config.authorized_withdrawer = with_signer(
-                    matches,
-                    wallet_manager,
-                    config.authorized_withdrawer.clone(),
-                    "authorized_withdrawer",
-                )?;
-            }
-            _ => (),
-        }
-
-        Ok(self)
-    }
-}
-
-pub fn with_signer(
-    matches: &ArgMatches,
-    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    arg: Option<SignerArg>,
-    name: &str,
-) -> Result<Option<SignerArg>, Error> {
-    Ok(match arg {
-        Some(SignerArg::Source(path)) => {
-            let signer = if let Ok(signer) = signer_from_path(matches, &path, name, wallet_manager)
-            {
-                signer
-            } else {
-                return Err(format!("Cannot parse signer {} / {}", name, path).into());
-            };
-            Some(SignerArg::Signer(Arc::from(signer)))
-        }
-        a => a,
-    })
-}
diff --git a/single-pool/cli/src/config.rs b/single-pool/cli/src/config.rs
deleted file mode 100644
index 649c2c7ea17..00000000000
--- a/single-pool/cli/src/config.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use {
-    crate::cli::*,
-    clap::ArgMatches,
-    solana_clap_v3_utils::keypair::signer_from_path,
-    solana_cli_output::OutputFormat,
-    solana_client::nonblocking::rpc_client::RpcClient,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{commitment_config::CommitmentConfig, signature::Signer},
-    spl_token_client::client::{ProgramClient, ProgramRpcClient, ProgramRpcClientSendTransaction},
-    std::{process::exit, rc::Rc, sync::Arc},
-};
-
-pub type Error = Box<dyn std::error::Error + Send + Sync>;
-
-pub fn println_display(config: &Config, message: String) {
-    match config.output_format {
-        OutputFormat::Display | OutputFormat::DisplayVerbose => {
-            println!("{}", message);
-        }
-        _ => {}
-    }
-}
-
-pub fn eprintln_display(config: &Config, message: String) {
-    match config.output_format {
-        OutputFormat::Display | OutputFormat::DisplayVerbose => {
-            eprintln!("{}", message);
-        }
-        _ => {}
-    }
-}
-
-pub struct Config {
-    pub rpc_client: Arc<RpcClient>,
-    pub program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>>,
-    pub default_signer: Option<Arc<dyn Signer>>,
-    pub fee_payer: Option<Arc<dyn Signer>>,
-    pub output_format: OutputFormat,
-    pub dry_run: bool,
-}
-impl Config {
-    pub fn new(
-        cli: Cli,
-        matches: ArgMatches,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    ) -> Self {
-        // get the generic cli config struct
-        let cli_config = if let Some(config_file) = &cli.config_file {
-            solana_cli_config::Config::load(config_file).unwrap_or_else(|_| {
-                eprintln!("error: Could not load config file `{}`", config_file);
-                exit(1);
-            })
-        } else if let Some(config_file) = &*solana_cli_config::CONFIG_FILE {
-            solana_cli_config::Config::load(config_file).unwrap_or_default()
-        } else {
-            solana_cli_config::Config::default()
-        };
-
-        // create rpc client
-        let rpc_client = Arc::new(RpcClient::new_with_commitment(
-            cli.json_rpc_url.unwrap_or(cli_config.json_rpc_url),
-            CommitmentConfig::confirmed(),
-        ));
-
-        // and program client
-        let program_client = Arc::new(ProgramRpcClient::new(
-            rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
-        ));
-
-        // resolve default signer
-        let default_keypair = cli_config.keypair_path;
-        let default_signer =
-            signer_from_path(&matches, &default_keypair, "default", wallet_manager)
-                .ok()
-                .map(Arc::from);
-
-        // resolve fee-payer
-        let fee_payer_arg =
-            with_signer(&matches, wallet_manager, cli.fee_payer, "fee_payer").unwrap();
-        let fee_payer = default_signer
-            .clone()
-            .map(|default_signer| signer_from_arg(fee_payer_arg, &default_signer).unwrap());
-
-        // determine output format
-        let output_format = match (cli.output_format, cli.verbose) {
-            (Some(json_format), _) => json_format,
-            (None, true) => OutputFormat::DisplayVerbose,
-            (None, false) => OutputFormat::Display,
-        };
-
-        Self {
-            rpc_client,
-            program_client,
-            default_signer,
-            fee_payer,
-            output_format,
-            dry_run: cli.dry_run,
-        }
-    }
-
-    // Returns Ok(default signer), or Err if there is no default signer configured
-    pub fn default_signer(&self) -> Result<Arc<dyn Signer>, Error> {
-        if let Some(default_signer) = &self.default_signer {
-            Ok(default_signer.clone())
-        } else {
-            Err("default signer is required, please specify a valid default signer by identifying a \
-                 valid configuration file using the --config argument, or by creating a valid config \
-                 at the default location of ~/.config/solana/cli/config.yml using the solana config \
-                 command".to_string().into())
-        }
-    }
-
-    // Returns Ok(fee payer), or Err if there is no fee payer configured
-    pub fn fee_payer(&self) -> Result<Arc<dyn Signer>, Error> {
-        if let Some(fee_payer) = &self.fee_payer {
-            Ok(fee_payer.clone())
-        } else {
-            Err("fee payer is required, please specify a valid fee payer using the --payer argument, or \
-                 by identifying a valid configuration file using the --config argument, or by creating a \
-                 valid config at the default location of ~/.config/solana/cli/config.yml using the solana \
-                 config command".to_string().into())
-        }
-    }
-
-    pub fn verbose(&self) -> bool {
-        self.output_format == OutputFormat::DisplayVerbose
-    }
-}
diff --git a/single-pool/cli/src/main.rs b/single-pool/cli/src/main.rs
deleted file mode 100644
index 10aaa89afd6..00000000000
--- a/single-pool/cli/src/main.rs
+++ /dev/null
@@ -1,876 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(deprecated)]
-
-use {
-    clap::{CommandFactory, Parser},
-    solana_clap_v3_utils::input_parsers::Amount,
-    solana_client::{
-        rpc_config::RpcProgramAccountsConfig,
-        rpc_filter::{Memcmp, RpcFilterType},
-    },
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        pubkey::Pubkey,
-        signature::{Keypair, Signature, Signer},
-        stake,
-        transaction::Transaction,
-    },
-    solana_vote_program::{self as vote_program, vote_state::VoteState},
-    spl_single_pool::{
-        self, find_default_deposit_account_address, find_pool_address, find_pool_mint_address,
-        find_pool_stake_address, instruction::SinglePoolInstruction, state::SinglePool,
-    },
-    spl_token_client::token::Token,
-};
-
-mod config;
-use config::*;
-
-mod cli;
-use cli::*;
-
-mod output;
-use output::*;
-
-mod quarantine;
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    let cli = Cli::parse();
-    let matches = Cli::command().get_matches();
-    let mut wallet_manager = None;
-
-    let command = cli
-        .command
-        .clone()
-        .with_signers(&matches, &mut wallet_manager)?;
-    let config = Config::new(cli, matches, &mut wallet_manager);
-
-    solana_logger::setup_with_default("solana=info");
-
-    let res = command.execute(&config).await?;
-    println!("{}", res);
-
-    Ok(())
-}
-
-pub type CommandResult = Result<String, Error>;
-
-impl Command {
-    pub async fn execute(self, config: &Config) -> CommandResult {
-        match self {
-            Command::Manage(command) => match command.manage {
-                ManageCommand::Initialize(command_config) => {
-                    command_initialize(config, command_config).await
-                }
-                ManageCommand::ReactivatePoolStake(command_config) => {
-                    command_reactivate_pool_stake(config, command_config).await
-                }
-                ManageCommand::CreateTokenMetadata(command_config) => {
-                    command_create_metadata(config, command_config).await
-                }
-                ManageCommand::UpdateTokenMetadata(command_config) => {
-                    command_update_metadata(config, command_config).await
-                }
-            },
-            Command::Deposit(command_config) => command_deposit(config, command_config).await,
-            Command::Withdraw(command_config) => command_withdraw(config, command_config).await,
-            Command::CreateDefaultStake(command_config) => {
-                command_create_stake(config, command_config).await
-            }
-            Command::Display(command_config) => command_display(config, command_config).await,
-        }
-    }
-}
-
-// initialize a new stake pool for a vote account
-async fn command_initialize(config: &Config, command_config: InitializeCli) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let vote_account_address = command_config.vote_account_address;
-
-    println_display(
-        config,
-        format!(
-            "Initializing single-validator stake pool for vote account {}\n",
-            vote_account_address,
-        ),
-    );
-
-    // check if the vote account is valid
-    let vote_account = config
-        .program_client
-        .get_account(vote_account_address)
-        .await?;
-    if vote_account.is_none() || vote_account.unwrap().owner != vote_program::id() {
-        return Err(format!("{} is not a valid vote account", vote_account_address,).into());
-    }
-
-    let pool_address = find_pool_address(&spl_single_pool::id(), &vote_account_address);
-
-    // check if the pool has already been initialized
-    if config
-        .program_client
-        .get_account(pool_address)
-        .await?
-        .is_some()
-    {
-        return Err(format!(
-            "Pool {} for vote account {} already exists",
-            pool_address, vote_account_address
-        )
-        .into());
-    }
-
-    let mut instructions = spl_single_pool::instruction::initialize(
-        &spl_single_pool::id(),
-        &vote_account_address,
-        &payer.pubkey(),
-        &quarantine::get_rent(config).await?,
-        quarantine::get_minimum_delegation(config).await?,
-    );
-
-    // get rid of the CreateMetadata instruction if desired, eg if mpl breaks compat
-    if command_config.skip_metadata {
-        assert_eq!(
-            instructions.last().unwrap().data,
-            borsh::to_vec(&SinglePoolInstruction::CreateTokenMetadata).unwrap()
-        );
-
-        instructions.pop();
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &vec![payer],
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "Initialize".to_string(),
-        StakePoolOutput {
-            pool_address,
-            vote_account_address,
-            available_stake: 0,
-            token_supply: 0,
-            signature,
-        },
-    ))
-}
-
-// reactivate pool stake account
-async fn command_reactivate_pool_stake(
-    config: &Config,
-    command_config: ReactivateCli,
-) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    println_display(
-        config,
-        format!("Reactivating stake account for pool {}\n", pool_address),
-    );
-
-    let vote_account_address =
-        if let Some(pool_data) = config.program_client.get_account(pool_address).await? {
-            try_from_slice_unchecked::<SinglePool>(&pool_data.data)?.vote_account_address
-        } else {
-            return Err(format!("Pool {} has not been initialized", pool_address).into());
-        };
-
-    // the only reason this check is skippable is for testing, otherwise theres no
-    // reason
-    if !command_config.skip_deactivation_check {
-        let current_epoch = config.rpc_client.get_epoch_info().await?.epoch;
-        let pool_stake_address = find_pool_stake_address(&spl_single_pool::id(), &pool_address);
-        let pool_stake_deactivated = quarantine::get_stake_info(config, &pool_stake_address)
-            .await?
-            .unwrap()
-            .1
-            .delegation
-            .deactivation_epoch
-            <= current_epoch;
-
-        if !pool_stake_deactivated {
-            return Err("Pool stake account is neither deactivating nor deactivated".into());
-        }
-    }
-
-    let instruction = spl_single_pool::instruction::reactivate_pool_stake(
-        &spl_single_pool::id(),
-        &vote_account_address,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &vec![payer],
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "ReactivatePoolStake".to_string(),
-        SignatureOutput { signature },
-    ))
-}
-
-// deposit stake
-async fn command_deposit(config: &Config, command_config: DepositCli) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let owner = config.default_signer()?;
-    let stake_authority = signer_from_arg(command_config.stake_withdraw_authority, &owner)?;
-    let lamport_recipient = command_config
-        .lamport_recipient_address
-        .unwrap_or_else(|| owner.pubkey());
-
-    let current_epoch = config.rpc_client.get_epoch_info().await?.epoch;
-
-    // the cli invocation for this is conceptually simple, but a bit tricky
-    // the user can provide pool or vote and let the cli infer the stake account
-    // address but they can also provide pool or vote with the stake account, as
-    // a safety check first we want to get the pool address if they provided a
-    // pool or vote address
-    let provided_pool_address = command_config.pool_address.or_else(|| {
-        command_config
-            .vote_account_address
-            .map(|address| find_pool_address(&spl_single_pool::id(), &address))
-    });
-
-    // from there we can determine the stake account address
-    let stake_account_address =
-        if let Some(stake_account_address) = command_config.stake_account_address {
-            stake_account_address
-        } else if let Some(pool_address) = provided_pool_address {
-            assert!(command_config.default_stake_account);
-            find_default_deposit_account_address(&pool_address, &stake_authority.pubkey())
-        } else {
-            unreachable!()
-        };
-
-    // now we validate the stake account and definitively resolve the pool address
-    let (pool_address, user_stake_active) = if let Some((meta, stake)) =
-        quarantine::get_stake_info(config, &stake_account_address).await?
-    {
-        let derived_pool_address =
-            find_pool_address(&spl_single_pool::id(), &stake.delegation.voter_pubkey);
-
-        if let Some(provided_pool_address) = provided_pool_address {
-            if provided_pool_address != derived_pool_address {
-                return Err(format!(
-                    "Provided pool address {} does not match stake account-derived address {}",
-                    provided_pool_address, derived_pool_address,
-                )
-                .into());
-            }
-        }
-
-        if meta.authorized.withdrawer != stake_authority.pubkey() {
-            return Err(format!(
-                "Incorrect withdraw authority for stake account {}: got {}, expected {}",
-                stake_account_address,
-                meta.authorized.withdrawer,
-                stake_authority.pubkey(),
-            )
-            .into());
-        }
-
-        if stake.delegation.deactivation_epoch < std::u64::MAX {
-            return Err(format!(
-                "Stake account {} is deactivating or deactivated",
-                stake_account_address
-            )
-            .into());
-        }
-
-        (
-            derived_pool_address,
-            stake.delegation.activation_epoch <= current_epoch,
-        )
-    } else {
-        return Err(format!("Could not find stake account {}", stake_account_address).into());
-    };
-
-    println_display(
-        config,
-        format!(
-            "Depositing stake from account {} into pool {}\n",
-            stake_account_address, pool_address
-        ),
-    );
-
-    if config
-        .program_client
-        .get_account(pool_address)
-        .await?
-        .is_none()
-    {
-        return Err(format!("Pool {} has not been initialized", pool_address).into());
-    }
-
-    let pool_stake_address = find_pool_stake_address(&spl_single_pool::id(), &pool_address);
-    let pool_stake_active = quarantine::get_stake_info(config, &pool_stake_address)
-        .await?
-        .unwrap()
-        .1
-        .delegation
-        .activation_epoch
-        <= current_epoch;
-
-    if user_stake_active != pool_stake_active {
-        return Err("Activation status mismatch; try again next epoch".into());
-    }
-
-    let pool_mint_address = find_pool_mint_address(&spl_single_pool::id(), &pool_address);
-    let token = Token::new(
-        config.program_client.clone(),
-        &spl_token::id(),
-        &pool_mint_address,
-        None,
-        payer.clone(),
-    );
-
-    // use token account provided, or get/create the associated account for the
-    // client keypair
-    let token_account_address = if let Some(account) = command_config.token_account_address {
-        account
-    } else {
-        token
-            .get_or_create_associated_account_info(&owner.pubkey())
-            .await?;
-        token.get_associated_token_address(&owner.pubkey())
-    };
-
-    let previous_token_amount = token
-        .get_account_info(&token_account_address)
-        .await?
-        .base
-        .amount;
-
-    let instructions = spl_single_pool::instruction::deposit(
-        &spl_single_pool::id(),
-        &pool_address,
-        &stake_account_address,
-        &token_account_address,
-        &lamport_recipient,
-        &stake_authority.pubkey(),
-    );
-
-    let mut signers = vec![];
-    for signer in [payer.clone(), stake_authority] {
-        if !signers.contains(&signer) {
-            signers.push(signer);
-        }
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &signers,
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-    let token_amount = token
-        .get_account_info(&token_account_address)
-        .await?
-        .base
-        .amount
-        - previous_token_amount;
-
-    Ok(format_output(
-        config,
-        "Deposit".to_string(),
-        DepositOutput {
-            pool_address,
-            token_amount,
-            signature,
-        },
-    ))
-}
-
-// withdraw stake
-async fn command_withdraw(config: &Config, command_config: WithdrawCli) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let owner = config.default_signer()?;
-    let token_authority = signer_from_arg(command_config.token_authority, &owner)?;
-    let stake_authority_address = command_config
-        .stake_authority_address
-        .unwrap_or_else(|| owner.pubkey());
-
-    let stake_account = Keypair::new();
-    let stake_account_address = stake_account.pubkey();
-
-    // since we can't infer pool from token account, the withdraw invocation is
-    // rather simpler first get the pool address
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    if config
-        .program_client
-        .get_account(pool_address)
-        .await?
-        .is_none()
-    {
-        return Err(format!("Pool {} has not been initialized", pool_address).into());
-    }
-
-    // now all the mint and token info
-    let pool_mint_address = find_pool_mint_address(&spl_single_pool::id(), &pool_address);
-    let token = Token::new(
-        config.program_client.clone(),
-        &spl_token::id(),
-        &pool_mint_address,
-        None,
-        payer.clone(),
-    );
-
-    let token_account_address = command_config
-        .token_account_address
-        .unwrap_or_else(|| token.get_associated_token_address(&owner.pubkey()));
-
-    let token_account = token.get_account_info(&token_account_address).await?;
-
-    let token_amount = match command_config.token_amount.sol_to_lamport() {
-        Amount::All => token_account.base.amount,
-        Amount::Raw(amount) => amount,
-        Amount::Decimal(_) => unreachable!(),
-    };
-
-    println_display(
-        config,
-        format!(
-            "Withdrawing from pool {} into new stake account {}; burning {} tokens from {}\n",
-            pool_address, stake_account_address, token_amount, token_account_address,
-        ),
-    );
-
-    if token_amount == 0 {
-        return Err("Cannot withdraw zero tokens".into());
-    }
-
-    if token_amount > token_account.base.amount {
-        return Err(format!(
-            "Withdraw amount {} exceeds tokens in account ({})",
-            token_amount, token_account.base.amount
-        )
-        .into());
-    }
-
-    // note a delegate authority is not allowed here because we must authorize the
-    // pool authority
-    if token_account.base.owner != token_authority.pubkey() {
-        return Err(format!(
-            "Invalid token authority: got {}, actual {}",
-            token_account.base.owner,
-            token_authority.pubkey()
-        )
-        .into());
-    }
-
-    // create a blank stake account to withdraw into
-    let mut instructions = vec![
-        quarantine::create_uninitialized_stake_account_instruction(
-            config,
-            &payer.pubkey(),
-            &stake_account_address,
-        )
-        .await?,
-    ];
-
-    // perform the withdrawal
-    instructions.extend(spl_single_pool::instruction::withdraw(
-        &spl_single_pool::id(),
-        &pool_address,
-        &stake_account_address,
-        &stake_authority_address,
-        &token_account_address,
-        &token_authority.pubkey(),
-        token_amount,
-    ));
-
-    // possibly deactivate the new stake account
-    if command_config.deactivate {
-        instructions.push(stake::instruction::deactivate_stake(
-            &stake_account_address,
-            &stake_authority_address,
-        ));
-    }
-
-    let mut signers = vec![];
-    for signer in [payer.as_ref(), token_authority.as_ref(), &stake_account] {
-        if !signers.contains(&signer) {
-            signers.push(signer);
-        }
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &signers,
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-    let stake_amount = if let Some((_, stake)) =
-        quarantine::get_stake_info(config, &stake_account_address).await?
-    {
-        stake.delegation.stake
-    } else {
-        0
-    };
-
-    Ok(format_output(
-        config,
-        "Withdraw".to_string(),
-        WithdrawOutput {
-            pool_address,
-            stake_account_address,
-            stake_amount,
-            signature,
-        },
-    ))
-}
-
-// create token metadata
-async fn command_create_metadata(
-    config: &Config,
-    command_config: CreateMetadataCli,
-) -> CommandResult {
-    let payer = config.fee_payer()?;
-
-    // first get the pool address
-    // i dont check metadata because i dont want to get entangled with mpl
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    println_display(
-        config,
-        format!(
-            "Creating default token metadata for pool {}\n",
-            pool_address
-        ),
-    );
-
-    if config
-        .program_client
-        .get_account(pool_address)
-        .await?
-        .is_none()
-    {
-        return Err(format!("Pool {} has not been initialized", pool_address).into());
-    }
-
-    // and... i guess thats it?
-
-    let instruction = spl_single_pool::instruction::create_token_metadata(
-        &spl_single_pool::id(),
-        &pool_address,
-        &payer.pubkey(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &vec![payer],
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "CreateTokenMetadata".to_string(),
-        SignatureOutput { signature },
-    ))
-}
-
-// update token metadata
-async fn command_update_metadata(
-    config: &Config,
-    command_config: UpdateMetadataCli,
-) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let owner = config.default_signer()?;
-    let authorized_withdrawer = signer_from_arg(command_config.authorized_withdrawer, &owner)?;
-
-    // first get the pool address
-    // i dont check metadata because i dont want to get entangled with mpl
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    println_display(
-        config,
-        format!("Updating token metadata for pool {}\n", pool_address),
-    );
-
-    // we always need the vote account
-    let vote_account_address =
-        if let Some(pool_data) = config.program_client.get_account(pool_address).await? {
-            try_from_slice_unchecked::<SinglePool>(&pool_data.data)?.vote_account_address
-        } else {
-            return Err(format!("Pool {} has not been initialized", pool_address).into());
-        };
-
-    if let Some(vote_account_data) = config
-        .program_client
-        .get_account(vote_account_address)
-        .await?
-    {
-        let vote_account = VoteState::deserialize(&vote_account_data.data)?;
-
-        if authorized_withdrawer.pubkey() != vote_account.authorized_withdrawer {
-            return Err(format!(
-                "Invalid authorized withdrawer: got {}, actual {}",
-                authorized_withdrawer.pubkey(),
-                vote_account.authorized_withdrawer,
-            )
-            .into());
-        }
-    } else {
-        // we know the pool exists so the vote account must exist
-        unreachable!();
-    }
-
-    let instruction = spl_single_pool::instruction::update_token_metadata(
-        &spl_single_pool::id(),
-        &vote_account_address,
-        &authorized_withdrawer.pubkey(),
-        command_config.token_name,
-        command_config.token_symbol,
-        command_config.token_uri.unwrap_or_default(),
-    );
-
-    let mut signers = vec![];
-    for signer in [payer.clone(), authorized_withdrawer] {
-        if !signers.contains(&signer) {
-            signers.push(signer);
-        }
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &signers,
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "UpdateTokenMetadata".to_string(),
-        SignatureOutput { signature },
-    ))
-}
-
-// create default stake account
-async fn command_create_stake(config: &Config, command_config: CreateStakeCli) -> CommandResult {
-    let payer = config.fee_payer()?;
-    let owner = config.default_signer()?;
-    let stake_authority_address = command_config
-        .stake_authority_address
-        .unwrap_or_else(|| owner.pubkey());
-
-    let pool_address = pool_address_from_args(
-        command_config.pool_address,
-        command_config.vote_account_address,
-    );
-
-    println_display(
-        config,
-        format!("Creating default stake account for pool {}\n", pool_address),
-    );
-
-    let vote_account_address =
-        if let Some(vote_account_address) = command_config.vote_account_address {
-            vote_account_address
-        } else if let Some(pool_data) = config.program_client.get_account(pool_address).await? {
-            try_from_slice_unchecked::<SinglePool>(&pool_data.data)?.vote_account_address
-        } else {
-            return Err(format!(
-                "Cannot determine vote account address from uninitialized pool {}",
-                pool_address,
-            )
-            .into());
-        };
-
-    if command_config.vote_account_address.is_some()
-        && config
-            .program_client
-            .get_account(pool_address)
-            .await?
-            .is_none()
-    {
-        eprintln_display(
-            config,
-            format!("warning: Pool {} has not been initialized", pool_address),
-        );
-    }
-
-    let instructions = spl_single_pool::instruction::create_and_delegate_user_stake(
-        &spl_single_pool::id(),
-        &vote_account_address,
-        &stake_authority_address,
-        &quarantine::get_rent(config).await?,
-        command_config.lamports,
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &vec![payer],
-        config.program_client.get_latest_blockhash().await?,
-    );
-
-    let signature = process_transaction(config, transaction).await?;
-
-    Ok(format_output(
-        config,
-        "CreateDefaultStake".to_string(),
-        CreateStakeOutput {
-            pool_address,
-            stake_account_address: find_default_deposit_account_address(
-                &pool_address,
-                &stake_authority_address,
-            ),
-            signature,
-        },
-    ))
-}
-
-// display stake pool(s)
-async fn command_display(config: &Config, command_config: DisplayCli) -> CommandResult {
-    if command_config.all {
-        // the filter isn't necessary now but makes the cli forward-compatible
-        let pools = config
-            .rpc_client
-            .get_program_accounts_with_config(
-                &spl_single_pool::id(),
-                RpcProgramAccountsConfig {
-                    filters: Some(vec![RpcFilterType::Memcmp(Memcmp::new_raw_bytes(
-                        0,
-                        vec![1],
-                    ))]),
-                    ..RpcProgramAccountsConfig::default()
-                },
-            )
-            .await?;
-
-        let mut displays = vec![];
-        for pool in pools {
-            let vote_account_address =
-                try_from_slice_unchecked::<SinglePool>(&pool.1.data)?.vote_account_address;
-            displays.push(get_pool_display(config, pool.0, Some(vote_account_address)).await?);
-        }
-
-        Ok(format_output(
-            config,
-            "DisplayAll".to_string(),
-            StakePoolListOutput(displays),
-        ))
-    } else {
-        let pool_address = pool_address_from_args(
-            command_config.pool_address,
-            command_config.vote_account_address,
-        );
-
-        Ok(format_output(
-            config,
-            "Display".to_string(),
-            get_pool_display(config, pool_address, None).await?,
-        ))
-    }
-}
-
-async fn get_pool_display(
-    config: &Config,
-    pool_address: Pubkey,
-    maybe_vote_account: Option<Pubkey>,
-) -> Result<StakePoolOutput, Error> {
-    let vote_account_address = if let Some(address) = maybe_vote_account {
-        address
-    } else if let Some(pool_data) = config.program_client.get_account(pool_address).await? {
-        if let Ok(data) = try_from_slice_unchecked::<SinglePool>(&pool_data.data) {
-            data.vote_account_address
-        } else {
-            return Err(format!(
-                "Failed to parse account at {}; is this a pool?",
-                pool_address
-            )
-            .into());
-        }
-    } else {
-        return Err(format!("Pool {} does not exist", pool_address).into());
-    };
-
-    let pool_stake_address = find_pool_stake_address(&spl_single_pool::id(), &pool_address);
-    let available_stake =
-        if let Some((_, stake)) = quarantine::get_stake_info(config, &pool_stake_address).await? {
-            stake.delegation.stake - quarantine::get_minimum_delegation(config).await?
-        } else {
-            unreachable!()
-        };
-
-    let pool_mint_address = find_pool_mint_address(&spl_single_pool::id(), &pool_address);
-    let token_supply = config
-        .rpc_client
-        .get_token_supply(&pool_mint_address)
-        .await?
-        .amount
-        .parse::<u64>()?;
-
-    Ok(StakePoolOutput {
-        pool_address,
-        vote_account_address,
-        available_stake,
-        token_supply,
-        signature: None,
-    })
-}
-
-async fn process_transaction(
-    config: &Config,
-    transaction: Transaction,
-) -> Result<Option<Signature>, Error> {
-    if config.dry_run {
-        let simulation_data = config.rpc_client.simulate_transaction(&transaction).await?;
-
-        if config.verbose() {
-            if let Some(logs) = simulation_data.value.logs {
-                for log in logs {
-                    println!("    {}", log);
-                }
-            }
-
-            println!(
-                "\nSimulation succeeded, consumed {} compute units",
-                simulation_data.value.units_consumed.unwrap()
-            );
-        } else {
-            println_display(config, "Simulation succeeded".to_string());
-        }
-
-        Ok(None)
-    } else {
-        Ok(Some(
-            config
-                .rpc_client
-                .send_and_confirm_transaction_with_spinner(&transaction)
-                .await?,
-        ))
-    }
-}
diff --git a/single-pool/cli/src/output.rs b/single-pool/cli/src/output.rs
deleted file mode 100644
index 060986542a5..00000000000
--- a/single-pool/cli/src/output.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-use {
-    crate::config::Config,
-    console::style,
-    serde::{Deserialize, Serialize},
-    serde_with::{serde_as, DisplayFromStr},
-    solana_cli_output::{display::writeln_name_value, QuietDisplay, VerboseDisplay},
-    solana_sdk::{pubkey::Pubkey, signature::Signature},
-    spl_single_pool::{
-        self, find_pool_mint_address, find_pool_mint_authority_address,
-        find_pool_mpl_authority_address, find_pool_stake_address,
-        find_pool_stake_authority_address,
-    },
-    std::fmt::{Display, Formatter, Result, Write},
-};
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    pub(crate) command_name: String,
-    pub(crate) command_output: T,
-}
-
-impl<T> Display for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.command_output, f)
-    }
-}
-
-impl<T> QuietDisplay for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        QuietDisplay::write_str(&self.command_output, w)
-    }
-}
-
-impl<T> VerboseDisplay for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        writeln_name_value(w, "Command:", &self.command_name)?;
-        VerboseDisplay::write_str(&self.command_output, w)
-    }
-}
-
-pub fn format_output<T>(config: &Config, command_name: String, command_output: T) -> String
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    config.output_format.formatted_string(&CommandOutput {
-        command_name,
-        command_output,
-    })
-}
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SignatureOutput {
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for SignatureOutput {}
-impl VerboseDisplay for SignatureOutput {}
-
-impl Display for SignatureOutput {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        writeln!(f)?;
-
-        if let Some(signature) = self.signature {
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct StakePoolOutput {
-    #[serde_as(as = "DisplayFromStr")]
-    pub pool_address: Pubkey,
-    #[serde_as(as = "DisplayFromStr")]
-    pub vote_account_address: Pubkey,
-    pub available_stake: u64,
-    pub token_supply: u64,
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for StakePoolOutput {}
-impl VerboseDisplay for StakePoolOutput {
-    fn write_str(&self, w: &mut dyn Write) -> Result {
-        writeln!(w)?;
-        writeln!(w, "{}", style("SPL Single-Validator Stake Pool").bold())?;
-        writeln_name_value(w, "  Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(
-            w,
-            "  Vote account address:",
-            &self.vote_account_address.to_string(),
-        )?;
-
-        writeln_name_value(
-            w,
-            "  Pool stake address:",
-            &find_pool_stake_address(&spl_single_pool::id(), &self.pool_address).to_string(),
-        )?;
-        writeln_name_value(
-            w,
-            "  Pool mint address:",
-            &find_pool_mint_address(&spl_single_pool::id(), &self.pool_address).to_string(),
-        )?;
-        writeln_name_value(
-            w,
-            "  Pool stake authority address:",
-            &find_pool_stake_authority_address(&spl_single_pool::id(), &self.pool_address)
-                .to_string(),
-        )?;
-        writeln_name_value(
-            w,
-            "  Pool mint authority address:",
-            &find_pool_mint_authority_address(&spl_single_pool::id(), &self.pool_address)
-                .to_string(),
-        )?;
-        writeln_name_value(
-            w,
-            "  Pool MPL authority address:",
-            &find_pool_mpl_authority_address(&spl_single_pool::id(), &self.pool_address)
-                .to_string(),
-        )?;
-
-        writeln_name_value(w, "  Available stake:", &self.available_stake.to_string())?;
-        writeln_name_value(w, "  Token supply:", &self.token_supply.to_string())?;
-
-        if let Some(signature) = self.signature {
-            writeln!(w)?;
-            writeln_name_value(w, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Display for StakePoolOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f)?;
-        writeln!(f, "{}", style("SPL Single-Validator Stake Pool").bold())?;
-        writeln_name_value(f, "  Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(
-            f,
-            "  Vote account address:",
-            &self.vote_account_address.to_string(),
-        )?;
-        writeln_name_value(f, "  Available stake:", &self.available_stake.to_string())?;
-        writeln_name_value(f, "  Token supply:", &self.token_supply.to_string())?;
-
-        if let Some(signature) = self.signature {
-            writeln!(f)?;
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct StakePoolListOutput(pub Vec<StakePoolOutput>);
-
-impl QuietDisplay for StakePoolListOutput {}
-impl VerboseDisplay for StakePoolListOutput {
-    fn write_str(&self, w: &mut dyn Write) -> Result {
-        let mut stake = 0;
-        for svsp in &self.0 {
-            VerboseDisplay::write_str(svsp, w)?;
-            stake += svsp.available_stake;
-        }
-
-        writeln!(w)?;
-        writeln_name_value(w, "Total stake:", &stake.to_string())?;
-
-        Ok(())
-    }
-}
-
-impl Display for StakePoolListOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let mut stake = 0;
-        for svsp in &self.0 {
-            svsp.fmt(f)?;
-            stake += svsp.available_stake;
-        }
-
-        writeln!(f)?;
-        writeln_name_value(f, "Total stake:", &stake.to_string())?;
-
-        Ok(())
-    }
-}
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DepositOutput {
-    #[serde_as(as = "DisplayFromStr")]
-    pub pool_address: Pubkey,
-    pub token_amount: u64,
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for DepositOutput {}
-impl VerboseDisplay for DepositOutput {}
-
-impl Display for DepositOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(f, "Token amount:", &self.token_amount.to_string())?;
-
-        if let Some(signature) = self.signature {
-            writeln!(f)?;
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct WithdrawOutput {
-    #[serde_as(as = "DisplayFromStr")]
-    pub pool_address: Pubkey,
-    #[serde_as(as = "DisplayFromStr")]
-    pub stake_account_address: Pubkey,
-    pub stake_amount: u64,
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for WithdrawOutput {}
-impl VerboseDisplay for WithdrawOutput {}
-
-impl Display for WithdrawOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(
-            f,
-            "Stake account address:",
-            &self.stake_account_address.to_string(),
-        )?;
-        writeln_name_value(f, "Stake amount:", &self.stake_amount.to_string())?;
-
-        if let Some(signature) = self.signature {
-            writeln!(f)?;
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
-
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateStakeOutput {
-    #[serde_as(as = "DisplayFromStr")]
-    pub pool_address: Pubkey,
-    #[serde_as(as = "DisplayFromStr")]
-    pub stake_account_address: Pubkey,
-    #[serde_as(as = "Option<DisplayFromStr>")]
-    pub signature: Option<Signature>,
-}
-
-impl QuietDisplay for CreateStakeOutput {}
-impl VerboseDisplay for CreateStakeOutput {}
-
-impl Display for CreateStakeOutput {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Pool address:", &self.pool_address.to_string())?;
-        writeln_name_value(
-            f,
-            "Stake account address:",
-            &self.stake_account_address.to_string(),
-        )?;
-
-        if let Some(signature) = self.signature {
-            writeln!(f)?;
-            writeln_name_value(f, "Signature:", &signature.to_string())?;
-        }
-
-        Ok(())
-    }
-}
diff --git a/single-pool/cli/src/quarantine.rs b/single-pool/cli/src/quarantine.rs
deleted file mode 100644
index 530f865b8b2..00000000000
--- a/single-pool/cli/src/quarantine.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-// XXX this file will be deleted and replaced with a stake program client once i
-// write one
-
-use {
-    crate::config::*,
-    solana_sdk::{
-        instruction::Instruction,
-        native_token::LAMPORTS_PER_SOL,
-        pubkey::Pubkey,
-        stake::{
-            self,
-            state::{Meta, Stake, StakeStateV2},
-        },
-        system_instruction,
-        sysvar::{self, rent::Rent},
-    },
-};
-
-pub async fn get_rent(config: &Config) -> Result<Rent, Error> {
-    let rent_data = config
-        .program_client
-        .get_account(sysvar::rent::id())
-        .await?
-        .unwrap();
-    let rent = bincode::deserialize::<Rent>(&rent_data.data)?;
-
-    Ok(rent)
-}
-
-pub async fn get_minimum_delegation(config: &Config) -> Result<u64, Error> {
-    Ok(std::cmp::max(
-        config.rpc_client.get_stake_minimum_delegation().await?,
-        LAMPORTS_PER_SOL,
-    ))
-}
-
-pub async fn get_stake_info(
-    config: &Config,
-    stake_account_address: &Pubkey,
-) -> Result<Option<(Meta, Stake)>, Error> {
-    if let Some(stake_account) = config
-        .program_client
-        .get_account(*stake_account_address)
-        .await?
-    {
-        match bincode::deserialize::<StakeStateV2>(&stake_account.data)? {
-            StakeStateV2::Stake(meta, stake, _) => Ok(Some((meta, stake))),
-            StakeStateV2::Initialized(_) => {
-                Err(format!("Stake account {} is undelegated", stake_account_address).into())
-            }
-            StakeStateV2::Uninitialized => {
-                Err(format!("Stake account {} is uninitialized", stake_account_address).into())
-            }
-            StakeStateV2::RewardsPool => unimplemented!(),
-        }
-    } else {
-        Ok(None)
-    }
-}
-
-pub async fn create_uninitialized_stake_account_instruction(
-    config: &Config,
-    payer: &Pubkey,
-    stake_account: &Pubkey,
-) -> Result<Instruction, Error> {
-    let rent_amount = config
-        .program_client
-        .get_minimum_balance_for_rent_exemption(std::mem::size_of::<StakeStateV2>())
-        .await?;
-
-    Ok(system_instruction::create_account(
-        payer,
-        stake_account,
-        rent_amount,
-        std::mem::size_of::<StakeStateV2>() as u64,
-        &stake::program::id(),
-    ))
-}
diff --git a/single-pool/cli/tests/test.rs b/single-pool/cli/tests/test.rs
deleted file mode 100644
index bceafc59d44..00000000000
--- a/single-pool/cli/tests/test.rs
+++ /dev/null
@@ -1,429 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-
-use {
-    serial_test::serial,
-    solana_cli_config::Config as SolanaConfig,
-    solana_client::nonblocking::rpc_client::RpcClient,
-    solana_sdk::{
-        bpf_loader_upgradeable,
-        clock::Epoch,
-        epoch_schedule::{EpochSchedule, MINIMUM_SLOTS_PER_EPOCH},
-        native_token::LAMPORTS_PER_SOL,
-        pubkey::Pubkey,
-        signature::{write_keypair_file, Keypair, Signer},
-        stake::{
-            self,
-            state::{Authorized, Lockup, StakeStateV2},
-        },
-        system_instruction, system_program,
-        transaction::Transaction,
-    },
-    solana_test_validator::{TestValidator, TestValidatorGenesis, UpgradeableProgramInfo},
-    solana_vote_program::{
-        vote_instruction::{self, CreateVoteAccountConfig},
-        vote_state::{VoteInit, VoteState},
-    },
-    spl_token_client::client::{ProgramClient, ProgramRpcClient, ProgramRpcClientSendTransaction},
-    std::{path::PathBuf, process::Command, str::FromStr, sync::Arc, time::Duration},
-    tempfile::NamedTempFile,
-    test_case::test_case,
-    tokio::time::sleep,
-};
-
-type PClient = Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>>;
-const SVSP_CLI: &str = "../../target/debug/spl-single-pool";
-
-#[allow(dead_code)]
-pub struct Env {
-    pub rpc_client: Arc<RpcClient>,
-    pub program_client: PClient,
-    pub payer: Keypair,
-    pub keypair_file_path: String,
-    pub config_file_path: String,
-    pub vote_account: Pubkey,
-
-    // persist in struct so they dont scope out but callers dont need to make them
-    validator: TestValidator,
-    keypair_file: NamedTempFile,
-    config_file: NamedTempFile,
-}
-
-async fn setup(initialize: bool) -> Env {
-    // start test validator
-    let (validator, payer) = start_validator().await;
-
-    // make clients
-    let rpc_client = Arc::new(validator.get_async_rpc_client());
-    let program_client: PClient = Arc::new(ProgramRpcClient::new(
-        rpc_client.clone(),
-        ProgramRpcClientSendTransaction,
-    ));
-
-    // write the payer to disk
-    let keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&payer, &keypair_file).unwrap();
-
-    // write a full config file with our rpc and payer to disk
-    let config_file = NamedTempFile::new().unwrap();
-    let config_file_path = config_file.path().to_str().unwrap();
-    let solana_config = SolanaConfig {
-        json_rpc_url: validator.rpc_url(),
-        websocket_url: validator.rpc_pubsub_url(),
-        keypair_path: keypair_file.path().to_str().unwrap().to_string(),
-        ..SolanaConfig::default()
-    };
-    solana_config.save(config_file_path).unwrap();
-
-    // make vote and stake accounts
-    let vote_account = create_vote_account(&program_client, &payer, &payer.pubkey()).await;
-    if initialize {
-        let status = Command::new(SVSP_CLI)
-            .args([
-                "manage",
-                "initialize",
-                "-C",
-                config_file_path,
-                &vote_account.to_string(),
-            ])
-            .status()
-            .unwrap();
-        assert!(status.success());
-    }
-
-    Env {
-        rpc_client,
-        program_client,
-        payer,
-        keypair_file_path: keypair_file.path().to_str().unwrap().to_string(),
-        config_file_path: config_file_path.to_string(),
-        vote_account,
-        validator,
-        keypair_file,
-        config_file,
-    }
-}
-
-async fn start_validator() -> (TestValidator, Keypair) {
-    solana_logger::setup();
-    let mut test_validator_genesis = TestValidatorGenesis::default();
-
-    test_validator_genesis.epoch_schedule(EpochSchedule::custom(
-        MINIMUM_SLOTS_PER_EPOCH,
-        MINIMUM_SLOTS_PER_EPOCH,
-        false,
-    ));
-
-    test_validator_genesis.add_upgradeable_programs_with_path(&[
-        UpgradeableProgramInfo {
-            program_id: Pubkey::from_str("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s").unwrap(),
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../program/tests/fixtures/mpl_token_metadata.so"),
-            upgrade_authority: Pubkey::default(),
-        },
-        UpgradeableProgramInfo {
-            program_id: spl_single_pool::id(),
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../../target/deploy/spl_single_pool.so"),
-            upgrade_authority: Pubkey::default(),
-        },
-    ]);
-    test_validator_genesis.start_async().await
-}
-
-async fn wait_for_next_epoch(rpc_client: &RpcClient) -> Epoch {
-    let current_epoch = rpc_client.get_epoch_info().await.unwrap().epoch;
-    println!("current epoch {}, advancing to next...", current_epoch);
-    loop {
-        let epoch_info = rpc_client.get_epoch_info().await.unwrap();
-        if epoch_info.epoch > current_epoch {
-            return epoch_info.epoch;
-        }
-
-        sleep(Duration::from_millis(200)).await;
-    }
-}
-
-async fn create_vote_account(
-    program_client: &PClient,
-    payer: &Keypair,
-    withdrawer: &Pubkey,
-) -> Pubkey {
-    let validator = Keypair::new();
-    let vote_account = Keypair::new();
-    let voter = Keypair::new();
-
-    let zero_rent = program_client
-        .get_minimum_balance_for_rent_exemption(0)
-        .await
-        .unwrap();
-
-    let vote_rent = program_client
-        .get_minimum_balance_for_rent_exemption(VoteState::size_of() * 2)
-        .await
-        .unwrap();
-
-    let blockhash = program_client.get_latest_blockhash().await.unwrap();
-
-    let mut instructions = vec![system_instruction::create_account(
-        &payer.pubkey(),
-        &validator.pubkey(),
-        zero_rent,
-        0,
-        &system_program::id(),
-    )];
-    instructions.append(&mut vote_instruction::create_account_with_config(
-        &payer.pubkey(),
-        &vote_account.pubkey(),
-        &VoteInit {
-            node_pubkey: validator.pubkey(),
-            authorized_voter: voter.pubkey(),
-            authorized_withdrawer: *withdrawer,
-            ..VoteInit::default()
-        },
-        vote_rent,
-        CreateVoteAccountConfig {
-            space: VoteState::size_of() as u64,
-            ..Default::default()
-        },
-    ));
-
-    let mut transaction = Transaction::new_with_payer(&instructions, Some(&payer.pubkey()));
-
-    transaction
-        .try_partial_sign(&vec![payer], blockhash)
-        .unwrap();
-    transaction
-        .try_partial_sign(&vec![&validator, &vote_account], blockhash)
-        .unwrap();
-
-    program_client.send_transaction(&transaction).await.unwrap();
-
-    vote_account.pubkey()
-}
-
-async fn create_and_delegate_stake_account(
-    program_client: &PClient,
-    payer: &Keypair,
-    vote_account: &Pubkey,
-) -> Pubkey {
-    let stake_account = Keypair::new();
-
-    let stake_rent = program_client
-        .get_minimum_balance_for_rent_exemption(StakeStateV2::size_of())
-        .await
-        .unwrap();
-    let blockhash = program_client.get_latest_blockhash().await.unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &stake::instruction::create_account(
-            &payer.pubkey(),
-            &stake_account.pubkey(),
-            &Authorized::auto(&payer.pubkey()),
-            &Lockup::default(),
-            stake_rent + LAMPORTS_PER_SOL,
-        ),
-        Some(&payer.pubkey()),
-    );
-
-    transaction
-        .try_partial_sign(&vec![payer], blockhash)
-        .unwrap();
-    transaction
-        .try_partial_sign(&vec![&stake_account], blockhash)
-        .unwrap();
-
-    program_client.send_transaction(&transaction).await.unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[stake::instruction::delegate_stake(
-            &stake_account.pubkey(),
-            &payer.pubkey(),
-            vote_account,
-        )],
-        Some(&payer.pubkey()),
-    );
-
-    transaction.sign(&vec![payer], blockhash);
-
-    program_client.send_transaction(&transaction).await.unwrap();
-
-    stake_account.pubkey()
-}
-
-#[tokio::test]
-#[serial]
-async fn reactivate_pool_stake() {
-    let env = setup(true).await;
-
-    // setting up a test validator for this to succeed is hell, and success is
-    // tested in program tests so we just make sure the cli can send a
-    // well-formed instruction
-    let output = Command::new(SVSP_CLI)
-        .args([
-            "manage",
-            "reactivate-pool-stake",
-            "-C",
-            &env.config_file_path,
-            "--vote-account",
-            &env.vote_account.to_string(),
-            "--skip-deactivation-check",
-        ])
-        .output()
-        .unwrap();
-    assert!(String::from_utf8(output.stderr)
-        .unwrap()
-        .contains("custom program error: 0xc"));
-}
-
-#[test_case(true; "default_stake")]
-#[test_case(false; "normal_stake")]
-#[tokio::test]
-#[serial]
-async fn deposit(use_default: bool) {
-    let env = setup(true).await;
-
-    let stake_account = if use_default {
-        let status = Command::new(SVSP_CLI)
-            .args([
-                "create-default-stake",
-                "-C",
-                &env.config_file_path,
-                "--vote-account",
-                &env.vote_account.to_string(),
-                &LAMPORTS_PER_SOL.to_string(),
-            ])
-            .status()
-            .unwrap();
-        assert!(status.success());
-
-        Pubkey::default()
-    } else {
-        create_and_delegate_stake_account(&env.program_client, &env.payer, &env.vote_account).await
-    };
-
-    wait_for_next_epoch(&env.rpc_client).await;
-
-    let mut args = vec![
-        "deposit".to_string(),
-        "-C".to_string(),
-        env.config_file_path,
-    ];
-
-    if use_default {
-        args.extend([
-            "--vote-account".to_string(),
-            env.vote_account.to_string(),
-            "--default-stake-account".to_string(),
-        ]);
-    } else {
-        args.push(stake_account.to_string());
-    };
-
-    let status = Command::new(SVSP_CLI).args(&args).status().unwrap();
-    assert!(status.success());
-}
-
-#[tokio::test]
-#[serial]
-async fn withdraw() {
-    let env = setup(true).await;
-    let stake_account =
-        create_and_delegate_stake_account(&env.program_client, &env.payer, &env.vote_account).await;
-
-    wait_for_next_epoch(&env.rpc_client).await;
-
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "deposit",
-            "-C",
-            &env.config_file_path,
-            &stake_account.to_string(),
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "withdraw",
-            "-C",
-            &env.config_file_path,
-            "--vote-account",
-            &env.vote_account.to_string(),
-            "ALL",
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-}
-
-#[tokio::test]
-#[serial]
-async fn create_metadata() {
-    let env = setup(false).await;
-
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "manage",
-            "initialize",
-            "-C",
-            &env.config_file_path,
-            "--skip-metadata",
-            &env.vote_account.to_string(),
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "manage",
-            "create-token-metadata",
-            "-C",
-            &env.config_file_path,
-            "--vote-account",
-            &env.vote_account.to_string(),
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-}
-
-#[tokio::test]
-#[serial]
-async fn update_metadata() {
-    let env = setup(true).await;
-
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "manage",
-            "update-token-metadata",
-            "-C",
-            &env.config_file_path,
-            "--vote-account",
-            &env.vote_account.to_string(),
-            "whatever",
-            "idk",
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-
-    // testing this flag because the match is rather torturous
-    let status = Command::new(SVSP_CLI)
-        .args([
-            "manage",
-            "update-token-metadata",
-            "-C",
-            &env.config_file_path,
-            "--vote-account",
-            &env.vote_account.to_string(),
-            "--authorized-withdrawer",
-            &env.keypair_file_path,
-            "something",
-            "new",
-        ])
-        .status()
-        .unwrap();
-    assert!(status.success());
-}
diff --git a/single-pool/js/LICENSE b/single-pool/js/LICENSE
deleted file mode 100644
index d6456956733..00000000000
--- a/single-pool/js/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/single-pool/js/packages/classic/.eslintignore b/single-pool/js/packages/classic/.eslintignore
deleted file mode 100644
index 58542507948..00000000000
--- a/single-pool/js/packages/classic/.eslintignore
+++ /dev/null
@@ -1,4 +0,0 @@
-dist
-node_modules
-.vscode
-.idea
diff --git a/single-pool/js/packages/classic/.eslintrc.cjs b/single-pool/js/packages/classic/.eslintrc.cjs
deleted file mode 100644
index 63db7b8405f..00000000000
--- a/single-pool/js/packages/classic/.eslintrc.cjs
+++ /dev/null
@@ -1,21 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    es6: true,
-    node: true,
-    jest: true,
-  },
-  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-  },
-};
diff --git a/single-pool/js/packages/classic/.gitignore b/single-pool/js/packages/classic/.gitignore
deleted file mode 100644
index 77738287f0e..00000000000
--- a/single-pool/js/packages/classic/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-dist/
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/.prettierrc.cjs b/single-pool/js/packages/classic/.prettierrc.cjs
deleted file mode 100644
index 8446d684477..00000000000
--- a/single-pool/js/packages/classic/.prettierrc.cjs
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-  singleQuote: true,
-  trailingComma: 'all',
-  printWidth: 100,
-  endOfLine: 'lf',
-  semi: true,
-};
diff --git a/single-pool/js/packages/classic/README.md b/single-pool/js/packages/classic/README.md
deleted file mode 100644
index f5416d3e10c..00000000000
--- a/single-pool/js/packages/classic/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# `@solana/spl-single-pool-classic`
-
-A TypeScript library for interacting with the SPL Single-Validator Stake Pool program, targeting `@solana/web3.js` 1.x.
-**If you are working on the new, bleeding-edge web3.js, you want `@solana/spl-single-pool`.**
-
-For information on installation and usage, see [SPL docs](https://spl.solana.com/single-pool).
-
-For support, please ask questions on the [Solana Stack Exchange](https://solana.stackexchange.com).
-
-If you've found a bug or you'd like to request a feature, please
-[open an issue](https://github.com/solana-labs/solana-program-library/issues/new).
diff --git a/single-pool/js/packages/classic/package.json b/single-pool/js/packages/classic/package.json
deleted file mode 100644
index d43437fc81e..00000000000
--- a/single-pool/js/packages/classic/package.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-  "name": "@solana/spl-single-pool-classic",
-  "version": "1.0.2",
-  "main": "dist/cjs/index.js",
-  "module": "dist/mjs/index.js",
-  "exports": {
-    ".": {
-      "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js"
-    }
-  },
-  "scripts": {
-    "clean": "rm -rf dist/*",
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./ts-fixup.sh",
-    "build:program": "cargo build-sbf --manifest-path=../../../program/Cargo.toml",
-    "lint": "eslint --max-warnings 0 .",
-    "lint:fix": "eslint . --fix",
-    "test": "sed -i '1s/.*/{ \"type\": \"module\",/' package.json && NODE_OPTIONS='--loader=tsx' ava ; ret=$?; sed -i '1s/.*/{/' package.json && exit $ret"
-  },
-  "devDependencies": {
-    "@types/node": "^20.14.5",
-    "@ava/typescript": "^5.0.0",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "ava": "^6.1.3",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "solana-bankrun": "^0.2.0",
-    "tsx": "^4.15.6",
-    "typescript": "^5.4.5"
-  },
-  "dependencies": {
-    "@solana/web3.js": "^1.93.0",
-    "@solana/spl-single-pool": "1.0.0"
-  },
-  "ava": {
-    "extensions": {
-      "ts": "module"
-    },
-    "nodeArguments": [
-      "--import=tsx"
-    ]
-  }
-}
diff --git a/single-pool/js/packages/classic/src/addresses.ts b/single-pool/js/packages/classic/src/addresses.ts
deleted file mode 100644
index b6e121fd626..00000000000
--- a/single-pool/js/packages/classic/src/addresses.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import {
-  findPoolAddress as findPoolModern,
-  findPoolStakeAddress as findStakeModern,
-  findPoolMintAddress as findMintModern,
-  findPoolStakeAuthorityAddress as findStakeAuthorityModern,
-  findPoolMintAuthorityAddress as findMintAuthorityModern,
-  findPoolMplAuthorityAddress as findMplAuthorityModern,
-  findDefaultDepositAccountAddress as findDefaultDepositModern,
-} from '@solana/spl-single-pool';
-
-export async function findPoolAddress(programId: PublicKey, voteAccountAddress: PublicKey) {
-  return new PublicKey(await findPoolModern(programId.toBase58(), voteAccountAddress.toBase58()));
-}
-
-export async function findPoolStakeAddress(programId: PublicKey, poolAddress: PublicKey) {
-  return new PublicKey(await findStakeModern(programId.toBase58(), poolAddress.toBase58()));
-}
-
-export async function findPoolMintAddress(programId: PublicKey, poolAddress: PublicKey) {
-  return new PublicKey(await findMintModern(programId.toBase58(), poolAddress.toBase58()));
-}
-
-export async function findPoolStakeAuthorityAddress(programId: PublicKey, poolAddress: PublicKey) {
-  return new PublicKey(
-    await findStakeAuthorityModern(programId.toBase58(), poolAddress.toBase58()),
-  );
-}
-
-export async function findPoolMintAuthorityAddress(programId: PublicKey, poolAddress: PublicKey) {
-  return new PublicKey(await findMintAuthorityModern(programId.toBase58(), poolAddress.toBase58()));
-}
-
-export async function findPoolMplAuthorityAddress(programId: PublicKey, poolAddress: PublicKey) {
-  return new PublicKey(await findMplAuthorityModern(programId.toBase58(), poolAddress.toBase58()));
-}
-
-export async function findDefaultDepositAccountAddress(
-  poolAddress: PublicKey,
-  userWallet: PublicKey,
-) {
-  return new PublicKey(
-    await findDefaultDepositModern(poolAddress.toBase58(), userWallet.toBase58()),
-  );
-}
diff --git a/single-pool/js/packages/classic/src/index.ts b/single-pool/js/packages/classic/src/index.ts
deleted file mode 100644
index 9f98e44a218..00000000000
--- a/single-pool/js/packages/classic/src/index.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { getVoteAccountAddressForPool as getVoteModern } from '@solana/spl-single-pool';
-
-import { rpc } from './internal.js';
-
-export * from './mpl_metadata.js';
-export * from './addresses.js';
-export * from './instructions.js';
-export * from './transactions.js';
-
-export async function getVoteAccountAddressForPool(connection: Connection, poolAddress: PublicKey) {
-  const voteAccountModern = await getVoteModern(rpc(connection), poolAddress.toBase58());
-
-  return new PublicKey(voteAccountModern);
-}
diff --git a/single-pool/js/packages/classic/src/instructions.ts b/single-pool/js/packages/classic/src/instructions.ts
deleted file mode 100644
index 17010559017..00000000000
--- a/single-pool/js/packages/classic/src/instructions.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { SinglePoolInstruction as PoolInstructionModern } from '@solana/spl-single-pool';
-
-import { modernInstructionToLegacy } from './internal.js';
-
-export class SinglePoolInstruction {
-  static async initializePool(voteAccount: PublicKey): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.initializePool(voteAccount.toBase58());
-    return modernInstructionToLegacy(instruction);
-  }
-
-  static async reactivatePoolStake(voteAccount: PublicKey): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.reactivatePoolStake(voteAccount.toBase58());
-    return modernInstructionToLegacy(instruction);
-  }
-
-  static async depositStake(
-    pool: PublicKey,
-    userStakeAccount: PublicKey,
-    userTokenAccount: PublicKey,
-    userLamportAccount: PublicKey,
-  ): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.depositStake(
-      pool.toBase58(),
-      userStakeAccount.toBase58(),
-      userTokenAccount.toBase58(),
-      userLamportAccount.toBase58(),
-    );
-    return modernInstructionToLegacy(instruction);
-  }
-
-  static async withdrawStake(
-    pool: PublicKey,
-    userStakeAccount: PublicKey,
-    userStakeAuthority: PublicKey,
-    userTokenAccount: PublicKey,
-    tokenAmount: number | bigint,
-  ): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.withdrawStake(
-      pool.toBase58(),
-      userStakeAccount.toBase58(),
-      userStakeAuthority.toBase58(),
-      userTokenAccount.toBase58(),
-      BigInt(tokenAmount),
-    );
-    return modernInstructionToLegacy(instruction);
-  }
-
-  static async createTokenMetadata(
-    pool: PublicKey,
-    payer: PublicKey,
-  ): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.createTokenMetadata(
-      pool.toBase58(),
-      payer.toBase58(),
-    );
-    return modernInstructionToLegacy(instruction);
-  }
-
-  static async updateTokenMetadata(
-    voteAccount: PublicKey,
-    authorizedWithdrawer: PublicKey,
-    tokenName: string,
-    tokenSymbol: string,
-    tokenUri?: string,
-  ): Promise<TransactionInstruction> {
-    const instruction = await PoolInstructionModern.updateTokenMetadata(
-      voteAccount.toBase58(),
-      authorizedWithdrawer.toBase58(),
-      tokenName,
-      tokenSymbol,
-      tokenUri,
-    );
-    return modernInstructionToLegacy(instruction);
-  }
-}
diff --git a/single-pool/js/packages/classic/src/internal.ts b/single-pool/js/packages/classic/src/internal.ts
deleted file mode 100644
index e1628ee76a8..00000000000
--- a/single-pool/js/packages/classic/src/internal.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { Connection, Transaction, TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { Buffer } from 'buffer';
-
-export function rpc(connection: Connection) {
-  return {
-    getAccountInfo(address: string) {
-      return {
-        async send() {
-          const pubkey = new PublicKey(address);
-          return await connection.getAccountInfo(pubkey);
-        },
-      };
-    },
-    getMinimumBalanceForRentExemption(size: bigint) {
-      return {
-        async send() {
-          return BigInt(await connection.getMinimumBalanceForRentExemption(Number(size)));
-        },
-      };
-    },
-    getStakeMinimumDelegation() {
-      return {
-        async send() {
-          const minimumDelegation = await connection.getStakeMinimumDelegation();
-          return { value: BigInt(minimumDelegation.value) };
-        },
-      };
-    },
-  };
-}
-
-export function modernInstructionToLegacy(modernInstruction: any): TransactionInstruction {
-  const keys = [];
-  for (const account of modernInstruction.accounts) {
-    keys.push({
-      pubkey: new PublicKey(account.address),
-      isSigner: !!(account.role & 2),
-      isWritable: !!(account.role & 1),
-    });
-  }
-
-  return new TransactionInstruction({
-    programId: new PublicKey(modernInstruction.programAddress),
-    keys,
-    data: Buffer.from(modernInstruction.data),
-  });
-}
-
-export function modernTransactionToLegacy(modernTransaction: any): Transaction {
-  const legacyTransaction = new Transaction();
-  legacyTransaction.add(...modernTransaction.instructions.map(modernInstructionToLegacy));
-
-  return legacyTransaction;
-}
-
-export function paramsToModern(params: any) {
-  const modernParams = {} as any;
-  for (const k of Object.keys(params)) {
-    if (k == 'connection') {
-      modernParams.rpc = rpc(params[k]);
-    } else if (params[k] instanceof PublicKey || params[k].constructor.name == 'PublicKey') {
-      modernParams[k] = params[k].toBase58();
-    } else if (typeof params[k] == 'number') {
-      modernParams[k] = BigInt(params[k]);
-    } else {
-      modernParams[k] = params[k];
-    }
-  }
-
-  return modernParams;
-}
diff --git a/single-pool/js/packages/classic/src/mpl_metadata.ts b/single-pool/js/packages/classic/src/mpl_metadata.ts
deleted file mode 100644
index 31c52ae2a50..00000000000
--- a/single-pool/js/packages/classic/src/mpl_metadata.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { Buffer } from 'buffer';
-
-export const MPL_METADATA_PROGRAM_ID = new PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
-
-export function findMplMetadataAddress(poolMintAddress: PublicKey) {
-  const [publicKey] = PublicKey.findProgramAddressSync(
-    [Buffer.from('metadata'), MPL_METADATA_PROGRAM_ID.toBuffer(), poolMintAddress.toBuffer()],
-    MPL_METADATA_PROGRAM_ID,
-  );
-  return publicKey;
-}
diff --git a/single-pool/js/packages/classic/src/transactions.ts b/single-pool/js/packages/classic/src/transactions.ts
deleted file mode 100644
index bcdafba5ff4..00000000000
--- a/single-pool/js/packages/classic/src/transactions.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import { PublicKey, Connection } from '@solana/web3.js';
-import { SinglePoolProgram as PoolProgramModern } from '@solana/spl-single-pool';
-
-import { paramsToModern, modernTransactionToLegacy, rpc } from './internal.js';
-
-interface DepositParams {
-  connection: Connection;
-  pool: PublicKey;
-  userWallet: PublicKey;
-  userStakeAccount?: PublicKey;
-  depositFromDefaultAccount?: boolean;
-  userTokenAccount?: PublicKey;
-  userLamportAccount?: PublicKey;
-  userWithdrawAuthority?: PublicKey;
-}
-
-interface WithdrawParams {
-  connection: Connection;
-  pool: PublicKey;
-  userWallet: PublicKey;
-  userStakeAccount: PublicKey;
-  tokenAmount: number | bigint;
-  createStakeAccount?: boolean;
-  userStakeAuthority?: PublicKey;
-  userTokenAccount?: PublicKey;
-  userTokenAuthority?: PublicKey;
-}
-
-export class SinglePoolProgram {
-  static programId: PublicKey = new PublicKey(PoolProgramModern.programAddress);
-  static space: number = Number(PoolProgramModern.space);
-
-  static async initialize(
-    connection: Connection,
-    voteAccount: PublicKey,
-    payer: PublicKey,
-    skipMetadata = false,
-  ) {
-    const modernTransaction = await PoolProgramModern.initialize(
-      rpc(connection),
-      voteAccount.toBase58(),
-      payer.toBase58(),
-      skipMetadata,
-    );
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async reactivatePoolStake(connection: Connection, voteAccount: PublicKey) {
-    const modernTransaction = await PoolProgramModern.reactivatePoolStake(voteAccount.toBase58());
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async deposit(params: DepositParams) {
-    const modernParams = paramsToModern(params);
-    const modernTransaction = await PoolProgramModern.deposit(modernParams);
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async withdraw(params: WithdrawParams) {
-    const modernParams = paramsToModern(params);
-    const modernTransaction = await PoolProgramModern.withdraw(modernParams);
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async createTokenMetadata(pool: PublicKey, payer: PublicKey) {
-    const modernTransaction = await PoolProgramModern.createTokenMetadata(
-      pool.toBase58(),
-      payer.toBase58(),
-    );
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async updateTokenMetadata(
-    voteAccount: PublicKey,
-    authorizedWithdrawer: PublicKey,
-    name: string,
-    symbol: string,
-    uri?: string,
-  ) {
-    const modernTransaction = await PoolProgramModern.updateTokenMetadata(
-      voteAccount.toBase58(),
-      authorizedWithdrawer.toBase58(),
-      name,
-      symbol,
-      uri,
-    );
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-
-  static async createAndDelegateUserStake(
-    connection: Connection,
-    voteAccount: PublicKey,
-    userWallet: PublicKey,
-    stakeAmount: number | bigint,
-  ) {
-    const modernTransaction = await PoolProgramModern.createAndDelegateUserStake(
-      rpc(connection),
-      voteAccount.toBase58(),
-      userWallet.toBase58(),
-      BigInt(stakeAmount),
-    );
-
-    return modernTransactionToLegacy(modernTransaction);
-  }
-}
diff --git a/single-pool/js/packages/classic/tests/fixtures/mpl_token_metadata.so b/single-pool/js/packages/classic/tests/fixtures/mpl_token_metadata.so
deleted file mode 120000
index df4d35160ee..00000000000
--- a/single-pool/js/packages/classic/tests/fixtures/mpl_token_metadata.so
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../stake-pool/program/tests/fixtures/mpl_token_metadata.so
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/tests/fixtures/spl_single_pool.so b/single-pool/js/packages/classic/tests/fixtures/spl_single_pool.so
deleted file mode 120000
index 5fe6f8bd60e..00000000000
--- a/single-pool/js/packages/classic/tests/fixtures/spl_single_pool.so
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../../target/deploy/spl_single_pool.so
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/tests/transactions.test.ts b/single-pool/js/packages/classic/tests/transactions.test.ts
deleted file mode 100644
index c6e1cb9cc5d..00000000000
--- a/single-pool/js/packages/classic/tests/transactions.test.ts
+++ /dev/null
@@ -1,433 +0,0 @@
-import test from 'ava';
-import { start, BanksClient, ProgramTestContext } from 'solana-bankrun';
-import {
-  Keypair,
-  PublicKey,
-  Transaction,
-  Authorized,
-  TransactionInstruction,
-  StakeProgram,
-  VoteProgram,
-} from '@solana/web3.js';
-import { Buffer } from 'buffer';
-import {
-  getVoteAccountAddressForPool,
-  findDefaultDepositAccountAddress,
-  MPL_METADATA_PROGRAM_ID,
-  SinglePoolProgram,
-  findPoolAddress,
-  findPoolStakeAddress,
-  findPoolMintAddress,
-  SinglePoolProgram,
-  findMplMetadataAddress,
-} from '../src/index.ts';
-import * as voteAccount from './vote_account.json';
-
-const SLOTS_PER_EPOCH: bigint = 432000n;
-
-class BanksConnection {
-  constructor(client: BanksClient, payer: Keypair) {
-    this.client = client;
-    this.payer = payer;
-  }
-
-  async getMinimumBalanceForRentExemption(dataLen: number): Promise<number> {
-    const rent = await this.client.getRent();
-    return Number(rent.minimumBalance(BigInt(dataLen)));
-  }
-
-  async getStakeMinimumDelegation() {
-    const transaction = new Transaction();
-    transaction.add(
-      new TransactionInstruction({
-        programId: StakeProgram.programId,
-        keys: [],
-        data: Buffer.from([13, 0, 0, 0]),
-      }),
-    );
-    transaction.recentBlockhash = (await this.client.getLatestBlockhash())[0];
-    transaction.feePayer = this.payer.publicKey;
-    transaction.sign(this.payer);
-
-    const res = await this.client.simulateTransaction(transaction);
-    const data = Array.from(res.inner.meta.returnData.data);
-    const minimumDelegation = data[0] + (data[1] << 8) + (data[2] << 16) + (data[3] << 24);
-
-    return { value: minimumDelegation };
-  }
-
-  async getAccountInfo(address: PublicKey, commitment?: string): Promise<AccountInfo<Buffer>> {
-    const account = await this.client.getAccount(address, commitment);
-    if (account) {
-      account.data = Buffer.from(account.data);
-    }
-    return account;
-  }
-}
-
-async function startWithContext(authorizedWithdrawer?: PublicKey) {
-  const voteAccountData = Uint8Array.from(atob(voteAccount.account.data[0]), (c) =>
-    c.charCodeAt(0),
-  );
-
-  if (authorizedWithdrawer != null) {
-    voteAccountData.set(authorizedWithdrawer.toBytes(), 36);
-  }
-
-  return await start(
-    [
-      { name: 'spl_single_pool', programId: SinglePoolProgram.programId },
-      { name: 'mpl_token_metadata', programId: MPL_METADATA_PROGRAM_ID },
-    ],
-    [
-      {
-        address: new PublicKey(voteAccount.pubkey),
-        info: {
-          lamports: voteAccount.account.lamports,
-          data: voteAccountData,
-          owner: VoteProgram.programId,
-          executable: false,
-        },
-      },
-    ],
-  );
-}
-
-async function processTransaction(
-  context: ProgramTestContext,
-  transaction: Transaction,
-  signers = [],
-) {
-  transaction.recentBlockhash = context.lastBlockhash;
-  transaction.feePayer = context.payer.publicKey;
-  transaction.sign(...[context.payer].concat(signers));
-  return context.banksClient.processTransaction(transaction);
-}
-
-async function createAndDelegateStakeAccount(
-  context: ProgramTestContext,
-  voteAccountAddress: PublicKey,
-): Promise<PublicKey> {
-  const connection = new BanksConnection(context.banksClient, context.payer);
-  let userStakeAccount = new Keypair();
-
-  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
-  const minimumDelegation = (await connection.getStakeMinimumDelegation()).value;
-  let transaction = StakeProgram.createAccount({
-    authorized: new Authorized(context.payer.publicKey, context.payer.publicKey),
-    fromPubkey: context.payer.publicKey,
-    lamports: stakeRent + minimumDelegation,
-    stakePubkey: userStakeAccount.publicKey,
-  });
-  await processTransaction(context, transaction, [userStakeAccount]);
-  userStakeAccount = userStakeAccount.publicKey;
-
-  transaction = StakeProgram.delegate({
-    authorizedPubkey: context.payer.publicKey,
-    stakePubkey: userStakeAccount,
-    votePubkey: voteAccountAddress,
-  });
-  await processTransaction(context, transaction);
-
-  return userStakeAccount;
-}
-
-test('initialize', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-
-  // initialize pool
-  const transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  t.truthy(await client.getAccount(poolAddress), 'pool has been created');
-  t.truthy(
-    await client.getAccount(
-      findMplMetadataAddress(await findPoolMintAddress(SinglePoolProgram.programId, poolAddress)),
-    ),
-    'metadata has been created',
-  );
-});
-
-test('reactivate pool stake', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-
-  // initialize pool
-  let transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
-
-  // reactivate pool stake
-  transaction = await SinglePoolProgram.reactivatePoolStake(connection, voteAccountAddress);
-
-  // setting up the validator state for this to succeed is very annoying
-  // we test success in program tests; here we just confirm we submit a well-formed transaction
-  let message = '';
-  try {
-    await processTransaction(context, transaction);
-  } catch (e) {
-    message = e.message;
-  } finally {
-    t.true(message.includes('custom program error: 0xc'), 'got expected stake mismatch error');
-  }
-});
-
-test('deposit', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-  const poolStakeAddress = await findPoolStakeAddress(SinglePoolProgram.programId, poolAddress);
-  const userStakeAccount = await createAndDelegateStakeAccount(context, voteAccountAddress);
-
-  // initialize pool
-  let transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
-
-  // deposit
-  transaction = await SinglePoolProgram.deposit({
-    connection,
-    pool: poolAddress,
-    userWallet: payer.publicKey,
-    userStakeAccount,
-  });
-  await processTransaction(context, transaction);
-
-  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
-  const minimumDelegation = (await connection.getStakeMinimumDelegation()).value;
-  const poolStakeAccount = await client.getAccount(poolStakeAddress);
-  t.is(poolStakeAccount.lamports, minimumDelegation * 2 + stakeRent, 'stake has been deposited');
-});
-
-test('deposit from default', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-  const poolStakeAddress = await findPoolStakeAddress(SinglePoolProgram.programId, poolAddress);
-
-  // create default account
-  const minimumDelegation = (await connection.getStakeMinimumDelegation()).value;
-  let transaction = await SinglePoolProgram.createAndDelegateUserStake(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-    minimumDelegation,
-  );
-  await processTransaction(context, transaction);
-
-  // initialize pool
-  transaction = await SinglePoolProgram.initialize(connection, voteAccountAddress, payer.publicKey);
-  await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
-
-  // deposit
-  transaction = await SinglePoolProgram.deposit({
-    connection,
-    pool: poolAddress,
-    userWallet: payer.publicKey,
-    depositFromDefaultAccount: true,
-  });
-  await processTransaction(context, transaction);
-
-  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
-  const poolStakeAccount = await client.getAccount(poolStakeAddress);
-  t.is(poolStakeAccount.lamports, minimumDelegation * 2 + stakeRent, 'stake has been deposited');
-});
-
-test('withdraw', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-  const poolStakeAddress = await findPoolStakeAddress(SinglePoolProgram.programId, poolAddress);
-  const depositAccount = await createAndDelegateStakeAccount(context, voteAccountAddress);
-
-  // initialize pool
-  let transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
-
-  // deposit
-  transaction = await SinglePoolProgram.deposit({
-    connection,
-    pool: poolAddress,
-    userWallet: payer.publicKey,
-    userStakeAccount: depositAccount,
-  });
-  await processTransaction(context, transaction);
-
-  const minimumDelegation = (await connection.getStakeMinimumDelegation()).value;
-  const poolStakeAccount = await client.getAccount(poolStakeAddress);
-  t.true(poolStakeAccount.lamports > minimumDelegation * 2, 'stake has been deposited');
-
-  // withdraw
-  const withdrawAccount = new Keypair();
-  transaction = await SinglePoolProgram.withdraw({
-    connection,
-    pool: poolAddress,
-    userWallet: payer.publicKey,
-    userStakeAccount: withdrawAccount.publicKey,
-    tokenAmount: minimumDelegation,
-    createStakeAccount: true,
-  });
-  await processTransaction(context, transaction, [withdrawAccount]);
-
-  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
-  const userStakeAccount = await client.getAccount(withdrawAccount.publicKey);
-  t.is(userStakeAccount.lamports, minimumDelegation + stakeRent, 'stake has been withdrawn');
-});
-
-test('create metadata', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-
-  // initialize pool without metadata
-  let transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-    true,
-  );
-  await processTransaction(context, transaction);
-
-  t.truthy(await client.getAccount(poolAddress), 'pool has been created');
-  t.falsy(
-    await client.getAccount(
-      findMplMetadataAddress(await findPoolMintAddress(SinglePoolProgram.programId, poolAddress)),
-    ),
-    'metadata has not been created',
-  );
-
-  // create metadata
-  transaction = await SinglePoolProgram.createTokenMetadata(poolAddress, payer.publicKey);
-  await processTransaction(context, transaction);
-
-  t.truthy(
-    await client.getAccount(
-      findMplMetadataAddress(await findPoolMintAddress(SinglePoolProgram.programId, poolAddress)),
-    ),
-    'metadata has been created',
-  );
-});
-
-test('update metadata', async (t) => {
-  const authorizedWithdrawer = new Keypair();
-
-  const context = await startWithContext(authorizedWithdrawer.publicKey);
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-  const poolMintAddress = await findPoolMintAddress(SinglePoolProgram.programId, poolAddress);
-  const poolMetadataAddress = findMplMetadataAddress(poolMintAddress);
-
-  // initialize pool
-  let transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  // update metadata
-  const newName = 'hana wuz here';
-  transaction = await SinglePoolProgram.updateTokenMetadata(
-    voteAccountAddress,
-    authorizedWithdrawer.publicKey,
-    newName,
-    '',
-  );
-  await processTransaction(context, transaction, [authorizedWithdrawer]);
-
-  const metadataAccount = await client.getAccount(poolMetadataAddress);
-  t.true(
-    new TextDecoder('ascii').decode(metadataAccount.data).indexOf(newName) > -1,
-    'metadata name has been updated',
-  );
-});
-
-test('get vote account address', async (t) => {
-  const context = await startWithContext();
-  const client = context.banksClient;
-  const payer = context.payer;
-  const connection = new BanksConnection(client, payer);
-
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
-
-  // initialize pool
-  const transaction = await SinglePoolProgram.initialize(
-    connection,
-    voteAccountAddress,
-    payer.publicKey,
-  );
-  await processTransaction(context, transaction);
-
-  const chainVoteAccount = await getVoteAccountAddressForPool(connection, poolAddress);
-  t.true(chainVoteAccount.equals(voteAccountAddress), 'got correct vote account');
-});
-
-test('default account address', async (t) => {
-  const voteAccountAddress = new PublicKey(voteAccount.pubkey);
-  const owner = new PublicKey('GtaYCtXWCrciizttN5mx9P38niTQPGWpfu6DnSgAr3Cj');
-  const expectedDefault = new PublicKey('BbfrNeJrd82cSFsULXT9zG8SvLLB8WsTc1gQsDFy3Sed');
-
-  const actualDefault = await findDefaultDepositAccountAddress(
-    await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress),
-    owner,
-  );
-
-  t.true(actualDefault.equals(expectedDefault), 'got correct default account address');
-});
diff --git a/single-pool/js/packages/classic/tests/vote_account.json b/single-pool/js/packages/classic/tests/vote_account.json
deleted file mode 100644
index 44a5efd12d8..00000000000
--- a/single-pool/js/packages/classic/tests/vote_account.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "pubkey": "KRAKEnMdmT4EfM8ykTFH6yLoCd5vNLcQvJwF66Y2dag",
-  "account": {
-    "lamports": 1300578700922,
-    "data": [
-      "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",
-      "base64"
-    ],
-    "owner": "Vote111111111111111111111111111111111111111",
-    "executable": false,
-    "rentEpoch": 361,
-    "space": 3731
-  }
-}
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/ts-fixup.sh b/single-pool/js/packages/classic/ts-fixup.sh
deleted file mode 120000
index 2b79c262866..00000000000
--- a/single-pool/js/packages/classic/ts-fixup.sh
+++ /dev/null
@@ -1 +0,0 @@
-../../ts-fixup.sh
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/tsconfig-base.json b/single-pool/js/packages/classic/tsconfig-base.json
deleted file mode 120000
index 8cdeff689fc..00000000000
--- a/single-pool/js/packages/classic/tsconfig-base.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig-base.json
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/tsconfig-cjs.json b/single-pool/js/packages/classic/tsconfig-cjs.json
deleted file mode 120000
index eb5b6778868..00000000000
--- a/single-pool/js/packages/classic/tsconfig-cjs.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig-cjs.json
\ No newline at end of file
diff --git a/single-pool/js/packages/classic/tsconfig.json b/single-pool/js/packages/classic/tsconfig.json
deleted file mode 120000
index fd0e4743dda..00000000000
--- a/single-pool/js/packages/classic/tsconfig.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig.json
\ No newline at end of file
diff --git a/single-pool/js/packages/modern/.eslintignore b/single-pool/js/packages/modern/.eslintignore
deleted file mode 100644
index 58542507948..00000000000
--- a/single-pool/js/packages/modern/.eslintignore
+++ /dev/null
@@ -1,4 +0,0 @@
-dist
-node_modules
-.vscode
-.idea
diff --git a/single-pool/js/packages/modern/.eslintrc.cjs b/single-pool/js/packages/modern/.eslintrc.cjs
deleted file mode 100644
index 63db7b8405f..00000000000
--- a/single-pool/js/packages/modern/.eslintrc.cjs
+++ /dev/null
@@ -1,21 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    es6: true,
-    node: true,
-    jest: true,
-  },
-  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-  },
-};
diff --git a/single-pool/js/packages/modern/.gitignore b/single-pool/js/packages/modern/.gitignore
deleted file mode 100644
index 77738287f0e..00000000000
--- a/single-pool/js/packages/modern/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-dist/
\ No newline at end of file
diff --git a/single-pool/js/packages/modern/.prettierrc.cjs b/single-pool/js/packages/modern/.prettierrc.cjs
deleted file mode 100644
index 8446d684477..00000000000
--- a/single-pool/js/packages/modern/.prettierrc.cjs
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-  singleQuote: true,
-  trailingComma: 'all',
-  printWidth: 100,
-  endOfLine: 'lf',
-  semi: true,
-};
diff --git a/single-pool/js/packages/modern/README.md b/single-pool/js/packages/modern/README.md
deleted file mode 100644
index 2cd1ff2c225..00000000000
--- a/single-pool/js/packages/modern/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# `@solana/spl-single-pool`
-
-A TypeScript library for interacting with the SPL Single-Validator Stake Pool program, targeting `@solana/web3.js` 2.0.
-**If you are working on the legacy web3.js (if you're not sure, you probably are!), you want `@solana/spl-single-pool-classic`.**
-
-For information on installation and usage, see [SPL docs](https://spl.solana.com/single-pool).
-
-For support, please ask questions on the [Solana Stack Exchange](https://solana.stackexchange.com).
-
-If you've found a bug or you'd like to request a feature, please
-[open an issue](https://github.com/solana-labs/solana-program-library/issues/new).
diff --git a/single-pool/js/packages/modern/package.json b/single-pool/js/packages/modern/package.json
deleted file mode 100644
index 22cd70ccf40..00000000000
--- a/single-pool/js/packages/modern/package.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-  "name": "@solana/spl-single-pool",
-  "version": "1.0.0",
-  "main": "dist/cjs/index.js",
-  "module": "dist/mjs/index.js",
-  "exports": {
-    ".": {
-      "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js"
-    }
-  },
-  "scripts": {
-    "clean": "rm -fr dist/*",
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && ./ts-fixup.sh",
-    "lint": "eslint --max-warnings 0 .",
-    "lint:fix": "eslint . --fix"
-  },
-  "devDependencies": {
-    "@types/node": "^20.14.5",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "typescript": "^5.4.5"
-  },
-  "dependencies": {
-    "@solana/web3.js": "=2.0.0-experimental.21e994f"
-  }
-}
diff --git a/single-pool/js/packages/modern/src/addresses.ts b/single-pool/js/packages/modern/src/addresses.ts
deleted file mode 100644
index 7e8464e487f..00000000000
--- a/single-pool/js/packages/modern/src/addresses.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import {
-  address,
-  getAddressCodec,
-  Base58EncodedAddress,
-  getProgramDerivedAddress,
-  createAddressWithSeed,
-} from '@solana/web3.js';
-
-import { MPL_METADATA_PROGRAM_ID } from './internal.js';
-import { STAKE_PROGRAM_ID } from './quarantine.js';
-
-export const SINGLE_POOL_PROGRAM_ID = address('SVSPxpvHdN29nkVg9rPapPNDddN5DipNLRUFhyjFThE');
-
-export type VoteAccountAddress<TAddress extends string = string> =
-  Base58EncodedAddress<TAddress> & {
-    readonly __voteAccountAddress: unique symbol;
-  };
-
-export type PoolAddress<TAddress extends string = string> = Base58EncodedAddress<TAddress> & {
-  readonly __poolAddress: unique symbol;
-};
-
-export type PoolStakeAddress<TAddress extends string = string> = Base58EncodedAddress<TAddress> & {
-  readonly __poolStakeAddress: unique symbol;
-};
-
-export type PoolMintAddress<TAddress extends string = string> = Base58EncodedAddress<TAddress> & {
-  readonly __poolMintAddress: unique symbol;
-};
-
-export type PoolStakeAuthorityAddress<TAddress extends string = string> =
-  Base58EncodedAddress<TAddress> & {
-    readonly __poolStakeAuthorityAddress: unique symbol;
-  };
-
-export type PoolMintAuthorityAddress<TAddress extends string = string> =
-  Base58EncodedAddress<TAddress> & {
-    readonly __poolMintAuthorityAddress: unique symbol;
-  };
-
-export type PoolMplAuthorityAddress<TAddress extends string = string> =
-  Base58EncodedAddress<TAddress> & {
-    readonly __poolMplAuthorityAddress: unique symbol;
-  };
-
-export async function findPoolAddress(
-  programId: Base58EncodedAddress,
-  voteAccountAddress: VoteAccountAddress,
-): Promise<PoolAddress> {
-  return (await findPda(programId, voteAccountAddress, 'pool')) as PoolAddress;
-}
-
-export async function findPoolStakeAddress(
-  programId: Base58EncodedAddress,
-  poolAddress: PoolAddress,
-): Promise<PoolStakeAddress> {
-  return (await findPda(programId, poolAddress, 'stake')) as PoolStakeAddress;
-}
-
-export async function findPoolMintAddress(
-  programId: Base58EncodedAddress,
-  poolAddress: PoolAddress,
-): Promise<PoolMintAddress> {
-  return (await findPda(programId, poolAddress, 'mint')) as PoolMintAddress;
-}
-
-export async function findPoolStakeAuthorityAddress(
-  programId: Base58EncodedAddress,
-  poolAddress: PoolAddress,
-): Promise<PoolStakeAuthorityAddress> {
-  return (await findPda(programId, poolAddress, 'stake_authority')) as PoolStakeAuthorityAddress;
-}
-
-export async function findPoolMintAuthorityAddress(
-  programId: Base58EncodedAddress,
-  poolAddress: PoolAddress,
-): Promise<PoolMintAuthorityAddress> {
-  return (await findPda(programId, poolAddress, 'mint_authority')) as PoolMintAuthorityAddress;
-}
-
-export async function findPoolMplAuthorityAddress(
-  programId: Base58EncodedAddress,
-  poolAddress: PoolAddress,
-): Promise<PoolMplAuthorityAddress> {
-  return (await findPda(programId, poolAddress, 'mpl_authority')) as PoolMplAuthorityAddress;
-}
-
-async function findPda(
-  programId: Base58EncodedAddress,
-  baseAddress: Base58EncodedAddress,
-  prefix: string,
-) {
-  const { serialize } = getAddressCodec();
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: [prefix, serialize(baseAddress)],
-  });
-
-  return pda;
-}
-
-export async function findDefaultDepositAccountAddress(
-  poolAddress: PoolAddress,
-  userWallet: Base58EncodedAddress,
-) {
-  return createAddressWithSeed({
-    baseAddress: userWallet,
-    seed: defaultDepositAccountSeed(poolAddress),
-    programAddress: STAKE_PROGRAM_ID,
-  });
-}
-
-export function defaultDepositAccountSeed(poolAddress: PoolAddress): string {
-  return 'svsp' + poolAddress.slice(0, 28);
-}
-
-export async function findMplMetadataAddress(poolMintAddress: PoolMintAddress) {
-  const { serialize } = getAddressCodec();
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: MPL_METADATA_PROGRAM_ID,
-    seeds: ['metadata', serialize(MPL_METADATA_PROGRAM_ID), serialize(poolMintAddress)],
-  });
-
-  return pda;
-}
diff --git a/single-pool/js/packages/modern/src/index.ts b/single-pool/js/packages/modern/src/index.ts
deleted file mode 100644
index b26524a4f1b..00000000000
--- a/single-pool/js/packages/modern/src/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { getAddressCodec } from '@solana/web3.js';
-
-import { PoolAddress, VoteAccountAddress } from './addresses.js';
-
-export * from './addresses.js';
-export * from './instructions.js';
-export * from './transactions.js';
-
-export async function getVoteAccountAddressForPool(
-  rpc: any, // XXX not exported: Rpc<GetAccountInfoApi>,
-  poolAddress: PoolAddress,
-  abortSignal?: AbortSignal,
-): Promise<VoteAccountAddress> {
-  const poolAccount = await rpc.getAccountInfo(poolAddress).send(abortSignal);
-  if (!(poolAccount && poolAccount.data[0] === 1)) {
-    throw 'invalid pool address';
-  }
-  return getAddressCodec().deserialize(poolAccount.data.slice(1))[0] as VoteAccountAddress;
-}
diff --git a/single-pool/js/packages/modern/src/instructions.ts b/single-pool/js/packages/modern/src/instructions.ts
deleted file mode 100644
index a170f47764e..00000000000
--- a/single-pool/js/packages/modern/src/instructions.ts
+++ /dev/null
@@ -1,382 +0,0 @@
-import {
-  getAddressCodec,
-  Base58EncodedAddress,
-  ReadonlySignerAccount,
-  ReadonlyAccount,
-  IInstructionWithAccounts,
-  IInstructionWithData,
-  WritableAccount,
-  WritableSignerAccount,
-  IInstruction,
-  AccountRole,
-} from '@solana/web3.js';
-
-import {
-  PoolMintAuthorityAddress,
-  PoolMintAddress,
-  PoolMplAuthorityAddress,
-  PoolStakeAuthorityAddress,
-  PoolStakeAddress,
-  findMplMetadataAddress,
-  findPoolMplAuthorityAddress,
-  findPoolAddress,
-  VoteAccountAddress,
-  PoolAddress,
-  findPoolStakeAddress,
-  findPoolMintAddress,
-  findPoolMintAuthorityAddress,
-  findPoolStakeAuthorityAddress,
-  SINGLE_POOL_PROGRAM_ID,
-} from './addresses.js';
-import { MPL_METADATA_PROGRAM_ID } from './internal.js';
-import {
-  SYSTEM_PROGRAM_ID,
-  SYSVAR_RENT_ID,
-  SYSVAR_CLOCK_ID,
-  STAKE_PROGRAM_ID,
-  SYSVAR_STAKE_HISTORY_ID,
-  STAKE_CONFIG_ID,
-  TOKEN_PROGRAM_ID,
-  u32,
-  u64,
-} from './quarantine.js';
-
-type InitializePoolInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<VoteAccountAddress>,
-      WritableAccount<PoolAddress>,
-      WritableAccount<PoolStakeAddress>,
-      WritableAccount<PoolMintAddress>,
-      ReadonlyAccount<PoolStakeAuthorityAddress>,
-      ReadonlyAccount<PoolMintAuthorityAddress>,
-      ReadonlyAccount<typeof SYSVAR_RENT_ID>,
-      ReadonlyAccount<typeof SYSVAR_CLOCK_ID>,
-      ReadonlyAccount<typeof SYSVAR_STAKE_HISTORY_ID>,
-      ReadonlyAccount<typeof STAKE_CONFIG_ID>,
-      ReadonlyAccount<typeof SYSTEM_PROGRAM_ID>,
-      ReadonlyAccount<typeof TOKEN_PROGRAM_ID>,
-      ReadonlyAccount<typeof STAKE_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-type ReactivatePoolStakeInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<VoteAccountAddress>,
-      ReadonlyAccount<PoolAddress>,
-      WritableAccount<PoolStakeAddress>,
-      ReadonlyAccount<PoolStakeAuthorityAddress>,
-      ReadonlyAccount<typeof SYSVAR_CLOCK_ID>,
-      ReadonlyAccount<typeof SYSVAR_STAKE_HISTORY_ID>,
-      ReadonlyAccount<typeof STAKE_CONFIG_ID>,
-      ReadonlyAccount<typeof STAKE_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-type DepositStakeInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<PoolAddress>,
-      WritableAccount<PoolStakeAddress>,
-      WritableAccount<PoolMintAddress>,
-      ReadonlyAccount<PoolStakeAuthorityAddress>,
-      ReadonlyAccount<PoolMintAuthorityAddress>,
-      WritableAccount<Base58EncodedAddress>, // user stake
-      WritableAccount<Base58EncodedAddress>, // user token
-      WritableAccount<Base58EncodedAddress>, // user lamport
-      ReadonlyAccount<typeof SYSVAR_CLOCK_ID>,
-      ReadonlyAccount<typeof SYSVAR_STAKE_HISTORY_ID>,
-      ReadonlyAccount<typeof TOKEN_PROGRAM_ID>,
-      ReadonlyAccount<typeof STAKE_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-type WithdrawStakeInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<PoolAddress>,
-      WritableAccount<PoolStakeAddress>,
-      WritableAccount<PoolMintAddress>,
-      ReadonlyAccount<PoolStakeAuthorityAddress>,
-      ReadonlyAccount<PoolMintAuthorityAddress>,
-      WritableAccount<Base58EncodedAddress>, // user stake
-      WritableAccount<Base58EncodedAddress>, // user token
-      ReadonlyAccount<typeof SYSVAR_CLOCK_ID>,
-      ReadonlyAccount<typeof TOKEN_PROGRAM_ID>,
-      ReadonlyAccount<typeof STAKE_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-type CreateTokenMetadataInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<PoolAddress>,
-      ReadonlyAccount<PoolMintAddress>,
-      ReadonlyAccount<PoolMintAuthorityAddress>,
-      ReadonlyAccount<PoolMplAuthorityAddress>,
-      WritableSignerAccount<Base58EncodedAddress>, // mpl payer
-      WritableAccount<Base58EncodedAddress>, // mpl account
-      ReadonlyAccount<typeof MPL_METADATA_PROGRAM_ID>,
-      ReadonlyAccount<typeof SYSTEM_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-type UpdateTokenMetadataInstruction = IInstruction<typeof SINGLE_POOL_PROGRAM_ID> &
-  IInstructionWithAccounts<
-    [
-      ReadonlyAccount<VoteAccountAddress>,
-      ReadonlyAccount<PoolAddress>,
-      ReadonlyAccount<PoolMplAuthorityAddress>,
-      ReadonlySignerAccount<Base58EncodedAddress>, // authorized withdrawer
-      WritableAccount<Base58EncodedAddress>, // mpl account
-      ReadonlyAccount<typeof MPL_METADATA_PROGRAM_ID>,
-    ]
-  > &
-  IInstructionWithData<Uint8Array>;
-
-const enum SinglePoolInstructionType {
-  InitializePool = 0,
-  ReactivatePoolStake,
-  DepositStake,
-  WithdrawStake,
-  CreateTokenMetadata,
-  UpdateTokenMetadata,
-}
-
-export const SinglePoolInstruction = {
-  initializePool: initializePoolInstruction,
-  reactivatePoolStake: reactivatePoolStakeInstruction,
-  depositStake: depositStakeInstruction,
-  withdrawStake: withdrawStakeInstruction,
-  createTokenMetadata: createTokenMetadataInstruction,
-  updateTokenMetadata: updateTokenMetadataInstruction,
-};
-
-export async function initializePoolInstruction(
-  voteAccount: VoteAccountAddress,
-): Promise<InitializePoolInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  const pool = await findPoolAddress(programAddress, voteAccount);
-  const [stake, mint, stakeAuthority, mintAuthority] = await Promise.all([
-    findPoolStakeAddress(programAddress, pool),
-    findPoolMintAddress(programAddress, pool),
-    findPoolStakeAuthorityAddress(programAddress, pool),
-    findPoolMintAuthorityAddress(programAddress, pool),
-  ]);
-
-  const data = new Uint8Array([SinglePoolInstructionType.InitializePool]);
-
-  return {
-    data,
-    accounts: [
-      { address: voteAccount, role: AccountRole.READONLY },
-      { address: pool, role: AccountRole.WRITABLE },
-      { address: stake, role: AccountRole.WRITABLE },
-      { address: mint, role: AccountRole.WRITABLE },
-      { address: stakeAuthority, role: AccountRole.READONLY },
-      { address: mintAuthority, role: AccountRole.READONLY },
-      { address: SYSVAR_RENT_ID, role: AccountRole.READONLY },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: SYSVAR_STAKE_HISTORY_ID, role: AccountRole.READONLY },
-      { address: STAKE_CONFIG_ID, role: AccountRole.READONLY },
-      { address: SYSTEM_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: TOKEN_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: STAKE_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
-
-export async function reactivatePoolStakeInstruction(
-  voteAccount: VoteAccountAddress,
-): Promise<ReactivatePoolStakeInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  const pool = await findPoolAddress(programAddress, voteAccount);
-  const [stake, stakeAuthority] = await Promise.all([
-    findPoolStakeAddress(programAddress, pool),
-    findPoolStakeAuthorityAddress(programAddress, pool),
-  ]);
-
-  const data = new Uint8Array([SinglePoolInstructionType.ReactivatePoolStake]);
-
-  return {
-    data,
-    accounts: [
-      { address: voteAccount, role: AccountRole.READONLY },
-      { address: pool, role: AccountRole.READONLY },
-      { address: stake, role: AccountRole.WRITABLE },
-      { address: stakeAuthority, role: AccountRole.READONLY },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: SYSVAR_STAKE_HISTORY_ID, role: AccountRole.READONLY },
-      { address: STAKE_CONFIG_ID, role: AccountRole.READONLY },
-      { address: STAKE_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
-
-export async function depositStakeInstruction(
-  pool: PoolAddress,
-  userStakeAccount: Base58EncodedAddress,
-  userTokenAccount: Base58EncodedAddress,
-  userLamportAccount: Base58EncodedAddress,
-): Promise<DepositStakeInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  const [stake, mint, stakeAuthority, mintAuthority] = await Promise.all([
-    findPoolStakeAddress(programAddress, pool),
-    findPoolMintAddress(programAddress, pool),
-    findPoolStakeAuthorityAddress(programAddress, pool),
-    findPoolMintAuthorityAddress(programAddress, pool),
-  ]);
-
-  const data = new Uint8Array([SinglePoolInstructionType.DepositStake]);
-
-  return {
-    data,
-    accounts: [
-      { address: pool, role: AccountRole.READONLY },
-      { address: stake, role: AccountRole.WRITABLE },
-      { address: mint, role: AccountRole.WRITABLE },
-      { address: stakeAuthority, role: AccountRole.READONLY },
-      { address: mintAuthority, role: AccountRole.READONLY },
-      { address: userStakeAccount, role: AccountRole.WRITABLE },
-      { address: userTokenAccount, role: AccountRole.WRITABLE },
-      { address: userLamportAccount, role: AccountRole.WRITABLE },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: SYSVAR_STAKE_HISTORY_ID, role: AccountRole.READONLY },
-      { address: TOKEN_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: STAKE_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
-
-export async function withdrawStakeInstruction(
-  pool: PoolAddress,
-  userStakeAccount: Base58EncodedAddress,
-  userStakeAuthority: Base58EncodedAddress,
-  userTokenAccount: Base58EncodedAddress,
-  tokenAmount: bigint,
-): Promise<WithdrawStakeInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  const [stake, mint, stakeAuthority, mintAuthority] = await Promise.all([
-    findPoolStakeAddress(programAddress, pool),
-    findPoolMintAddress(programAddress, pool),
-    findPoolStakeAuthorityAddress(programAddress, pool),
-    findPoolMintAuthorityAddress(programAddress, pool),
-  ]);
-
-  const { serialize } = getAddressCodec();
-  const data = new Uint8Array([
-    SinglePoolInstructionType.WithdrawStake,
-    ...serialize(userStakeAuthority),
-    ...u64(tokenAmount),
-  ]);
-
-  return {
-    data,
-    accounts: [
-      { address: pool, role: AccountRole.READONLY },
-      { address: stake, role: AccountRole.WRITABLE },
-      { address: mint, role: AccountRole.WRITABLE },
-      { address: stakeAuthority, role: AccountRole.READONLY },
-      { address: mintAuthority, role: AccountRole.READONLY },
-      { address: userStakeAccount, role: AccountRole.WRITABLE },
-      { address: userTokenAccount, role: AccountRole.WRITABLE },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: TOKEN_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: STAKE_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
-
-export async function createTokenMetadataInstruction(
-  pool: PoolAddress,
-  payer: Base58EncodedAddress,
-): Promise<CreateTokenMetadataInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  const mint = await findPoolMintAddress(programAddress, pool);
-  const [mintAuthority, mplAuthority, mplMetadata] = await Promise.all([
-    findPoolMintAuthorityAddress(programAddress, pool),
-    findPoolMplAuthorityAddress(programAddress, pool),
-    findMplMetadataAddress(mint),
-  ]);
-
-  const data = new Uint8Array([SinglePoolInstructionType.CreateTokenMetadata]);
-
-  return {
-    data,
-    accounts: [
-      { address: pool, role: AccountRole.READONLY },
-      { address: mint, role: AccountRole.READONLY },
-      { address: mintAuthority, role: AccountRole.READONLY },
-      { address: mplAuthority, role: AccountRole.READONLY },
-      { address: payer, role: AccountRole.WRITABLE_SIGNER },
-      { address: mplMetadata, role: AccountRole.WRITABLE },
-      { address: MPL_METADATA_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: SYSTEM_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
-
-export async function updateTokenMetadataInstruction(
-  voteAccount: VoteAccountAddress,
-  authorizedWithdrawer: Base58EncodedAddress,
-  tokenName: string,
-  tokenSymbol: string,
-  tokenUri?: string,
-): Promise<UpdateTokenMetadataInstruction> {
-  const programAddress = SINGLE_POOL_PROGRAM_ID;
-  tokenUri = tokenUri || '';
-
-  if (tokenName.length > 32) {
-    throw 'maximum token name length is 32 characters';
-  }
-
-  if (tokenSymbol.length > 10) {
-    throw 'maximum token symbol length is 10 characters';
-  }
-
-  if (tokenUri.length > 200) {
-    throw 'maximum token uri length is 200 characters';
-  }
-
-  const pool = await findPoolAddress(programAddress, voteAccount);
-  const [mint, mplAuthority] = await Promise.all([
-    findPoolMintAddress(programAddress, pool),
-    findPoolMplAuthorityAddress(programAddress, pool),
-  ]);
-  const mplMetadata = await findMplMetadataAddress(mint);
-
-  const text = new TextEncoder();
-  const data = new Uint8Array([
-    SinglePoolInstructionType.UpdateTokenMetadata,
-    ...u32(tokenName.length),
-    ...text.encode(tokenName),
-    ...u32(tokenSymbol.length),
-    ...text.encode(tokenSymbol),
-    ...u32(tokenUri.length),
-    ...text.encode(tokenUri),
-  ]);
-
-  return {
-    data,
-    accounts: [
-      { address: voteAccount, role: AccountRole.READONLY },
-      { address: pool, role: AccountRole.READONLY },
-      { address: mplAuthority, role: AccountRole.READONLY },
-      { address: authorizedWithdrawer, role: AccountRole.READONLY_SIGNER },
-      { address: mplMetadata, role: AccountRole.WRITABLE },
-      { address: MPL_METADATA_PROGRAM_ID, role: AccountRole.READONLY },
-    ],
-    programAddress,
-  };
-}
diff --git a/single-pool/js/packages/modern/src/internal.ts b/single-pool/js/packages/modern/src/internal.ts
deleted file mode 100644
index cdea7d11bae..00000000000
--- a/single-pool/js/packages/modern/src/internal.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { address } from '@solana/web3.js';
-
-export const MPL_METADATA_PROGRAM_ID = address('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
diff --git a/single-pool/js/packages/modern/src/quarantine.ts b/single-pool/js/packages/modern/src/quarantine.ts
deleted file mode 100644
index be688b48156..00000000000
--- a/single-pool/js/packages/modern/src/quarantine.ts
+++ /dev/null
@@ -1,261 +0,0 @@
-import {
-  address,
-  getAddressCodec,
-  Base58EncodedAddress,
-  AccountRole,
-  getProgramDerivedAddress,
-} from '@solana/web3.js';
-
-// HERE BE DRAGONS
-// this is all the stuff that shouldnt be in our library once we can import from elsewhere
-
-export const SYSTEM_PROGRAM_ID = address('11111111111111111111111111111111');
-export const STAKE_PROGRAM_ID = address('Stake11111111111111111111111111111111111111');
-export const SYSVAR_RENT_ID = address('SysvarRent111111111111111111111111111111111');
-export const SYSVAR_CLOCK_ID = address('SysvarC1ock11111111111111111111111111111111');
-export const SYSVAR_STAKE_HISTORY_ID = address('SysvarStakeHistory1111111111111111111111111');
-export const STAKE_CONFIG_ID = address('StakeConfig11111111111111111111111111111111');
-export const STAKE_ACCOUNT_SIZE = 200n;
-
-export const TOKEN_PROGRAM_ID = address('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-export const ATOKEN_PROGRAM_ID = address('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-export const MINT_SIZE = 82n;
-
-export function u32(n: number): Uint8Array {
-  const bns = Uint32Array.from([n]);
-  return new Uint8Array(bns.buffer);
-}
-
-export function u64(n: bigint): Uint8Array {
-  const bns = BigUint64Array.from([n]);
-  return new Uint8Array(bns.buffer);
-}
-
-export class SystemInstruction {
-  static createAccount(params: {
-    from: Base58EncodedAddress;
-    newAccount: Base58EncodedAddress;
-    lamports: bigint;
-    space: bigint;
-    programAddress: Base58EncodedAddress;
-  }) {
-    const { serialize } = getAddressCodec();
-    const data = new Uint8Array([
-      ...u32(0),
-      ...u64(params.lamports),
-      ...u64(params.space),
-      ...serialize(params.programAddress),
-    ]);
-
-    const accounts = [
-      { address: params.from, role: AccountRole.WRITABLE_SIGNER },
-      { address: params.newAccount, role: AccountRole.WRITABLE_SIGNER },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: SYSTEM_PROGRAM_ID,
-    };
-  }
-
-  static transfer(params: {
-    from: Base58EncodedAddress;
-    to: Base58EncodedAddress;
-    lamports: bigint;
-  }) {
-    const data = new Uint8Array([...u32(2), ...u64(params.lamports)]);
-
-    const accounts = [
-      { address: params.from, role: AccountRole.WRITABLE_SIGNER },
-      { address: params.to, role: AccountRole.WRITABLE },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: SYSTEM_PROGRAM_ID,
-    };
-  }
-
-  static createAccountWithSeed(params: {
-    from: Base58EncodedAddress;
-    newAccount: Base58EncodedAddress;
-    base: Base58EncodedAddress;
-    seed: string;
-    lamports: bigint;
-    space: bigint;
-    programAddress: Base58EncodedAddress;
-  }) {
-    const { serialize } = getAddressCodec();
-    const data = new Uint8Array([
-      ...u32(3),
-      ...serialize(params.base),
-      ...u64(BigInt(params.seed.length)),
-      ...new TextEncoder().encode(params.seed),
-      ...u64(params.lamports),
-      ...u64(params.space),
-      ...serialize(params.programAddress),
-    ]);
-
-    const accounts = [
-      { address: params.from, role: AccountRole.WRITABLE_SIGNER },
-      { address: params.newAccount, role: AccountRole.WRITABLE },
-    ];
-    if (params.base != params.from) {
-      accounts.push({ address: params.base, role: AccountRole.READONLY_SIGNER });
-    }
-
-    return {
-      data,
-      accounts,
-      programAddress: SYSTEM_PROGRAM_ID,
-    };
-  }
-}
-
-export class TokenInstruction {
-  static approve(params: {
-    account: Base58EncodedAddress;
-    delegate: Base58EncodedAddress;
-    owner: Base58EncodedAddress;
-    amount: bigint;
-  }) {
-    const data = new Uint8Array([...u32(4), ...u64(params.amount)]);
-
-    const accounts = [
-      { address: params.account, role: AccountRole.WRITABLE },
-      { address: params.delegate, role: AccountRole.READONLY },
-      { address: params.owner, role: AccountRole.READONLY_SIGNER },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: TOKEN_PROGRAM_ID,
-    };
-  }
-
-  static createAssociatedTokenAccount(params: {
-    payer: Base58EncodedAddress;
-    associatedAccount: Base58EncodedAddress;
-    owner: Base58EncodedAddress;
-    mint: Base58EncodedAddress;
-  }) {
-    const data = new Uint8Array([0]);
-
-    const accounts = [
-      { address: params.payer, role: AccountRole.WRITABLE_SIGNER },
-      { address: params.associatedAccount, role: AccountRole.WRITABLE },
-      { address: params.owner, role: AccountRole.READONLY },
-      { address: params.mint, role: AccountRole.READONLY },
-      { address: SYSTEM_PROGRAM_ID, role: AccountRole.READONLY },
-      { address: TOKEN_PROGRAM_ID, role: AccountRole.READONLY },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: ATOKEN_PROGRAM_ID,
-    };
-  }
-}
-
-export enum StakeAuthorizationType {
-  Staker,
-  Withdrawer,
-}
-
-export class StakeInstruction {
-  // idc about doing it right unless this goes in a lib
-  static initialize(params: {
-    stakeAccount: Base58EncodedAddress;
-    staker: Base58EncodedAddress;
-    withdrawer: Base58EncodedAddress;
-  }) {
-    const { serialize } = getAddressCodec();
-    const data = new Uint8Array([
-      ...u32(0),
-      ...serialize(params.staker),
-      ...serialize(params.withdrawer),
-      ...Array(48).fill(0),
-    ]);
-
-    const accounts = [
-      { address: params.stakeAccount, role: AccountRole.WRITABLE },
-      { address: SYSVAR_RENT_ID, role: AccountRole.READONLY },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: STAKE_PROGRAM_ID,
-    };
-  }
-
-  static authorize(params: {
-    stakeAccount: Base58EncodedAddress;
-    authorized: Base58EncodedAddress;
-    newAuthorized: Base58EncodedAddress;
-    authorizationType: StakeAuthorizationType;
-    custodian?: Base58EncodedAddress;
-  }) {
-    const { serialize } = getAddressCodec();
-    const data = new Uint8Array([
-      ...u32(1),
-      ...serialize(params.newAuthorized),
-      ...u32(params.authorizationType),
-    ]);
-
-    const accounts = [
-      { address: params.stakeAccount, role: AccountRole.WRITABLE },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: params.authorized, role: AccountRole.READONLY_SIGNER },
-    ];
-    if (params.custodian) {
-      accounts.push({ address: params.custodian, role: AccountRole.READONLY });
-    }
-
-    return {
-      data,
-      accounts,
-      programAddress: STAKE_PROGRAM_ID,
-    };
-  }
-
-  static delegate(params: {
-    stakeAccount: Base58EncodedAddress;
-    authorized: Base58EncodedAddress;
-    voteAccount: Base58EncodedAddress;
-  }) {
-    const data = new Uint8Array(u32(2));
-
-    const accounts = [
-      { address: params.stakeAccount, role: AccountRole.WRITABLE },
-      { address: params.voteAccount, role: AccountRole.READONLY },
-      { address: SYSVAR_CLOCK_ID, role: AccountRole.READONLY },
-      { address: SYSVAR_STAKE_HISTORY_ID, role: AccountRole.READONLY },
-      { address: STAKE_CONFIG_ID, role: AccountRole.READONLY },
-      { address: params.authorized, role: AccountRole.READONLY_SIGNER },
-    ];
-
-    return {
-      data,
-      accounts,
-      programAddress: STAKE_PROGRAM_ID,
-    };
-  }
-}
-
-export async function getAssociatedTokenAddress(
-  mint: Base58EncodedAddress,
-  owner: Base58EncodedAddress,
-) {
-  const { serialize } = getAddressCodec();
-  const [pda] = await getProgramDerivedAddress({
-    programAddress: ATOKEN_PROGRAM_ID,
-    seeds: [serialize(owner), serialize(TOKEN_PROGRAM_ID), serialize(mint)],
-  });
-
-  return pda;
-}
diff --git a/single-pool/js/packages/modern/src/transactions.ts b/single-pool/js/packages/modern/src/transactions.ts
deleted file mode 100644
index 03b2842b7c8..00000000000
--- a/single-pool/js/packages/modern/src/transactions.ts
+++ /dev/null
@@ -1,346 +0,0 @@
-import {
-  appendTransactionInstruction,
-  Transaction,
-  TransactionVersion,
-  Base58EncodedAddress,
-} from '@solana/web3.js';
-
-import {
-  findPoolAddress,
-  VoteAccountAddress,
-  PoolAddress,
-  findPoolStakeAddress,
-  findPoolMintAddress,
-  defaultDepositAccountSeed,
-  findDefaultDepositAccountAddress,
-  findPoolMintAuthorityAddress,
-  findPoolStakeAuthorityAddress,
-  SINGLE_POOL_PROGRAM_ID,
-} from './addresses.js';
-import {
-  initializePoolInstruction,
-  reactivatePoolStakeInstruction,
-  depositStakeInstruction,
-  withdrawStakeInstruction,
-  createTokenMetadataInstruction,
-  updateTokenMetadataInstruction,
-} from './instructions.js';
-import {
-  STAKE_PROGRAM_ID,
-  STAKE_ACCOUNT_SIZE,
-  MINT_SIZE,
-  StakeInstruction,
-  SystemInstruction,
-  TokenInstruction,
-  StakeAuthorizationType,
-  getAssociatedTokenAddress,
-} from './quarantine.js';
-
-interface DepositParams {
-  rpc: any; // XXX Rpc<???>
-  pool: PoolAddress;
-  userWallet: Base58EncodedAddress;
-  userStakeAccount?: Base58EncodedAddress;
-  depositFromDefaultAccount?: boolean;
-  userTokenAccount?: Base58EncodedAddress;
-  userLamportAccount?: Base58EncodedAddress;
-  userWithdrawAuthority?: Base58EncodedAddress;
-}
-
-interface WithdrawParams {
-  rpc: any; // XXX Rpc<???>
-  pool: PoolAddress;
-  userWallet: Base58EncodedAddress;
-  userStakeAccount: Base58EncodedAddress;
-  tokenAmount: bigint;
-  createStakeAccount?: boolean;
-  userStakeAuthority?: Base58EncodedAddress;
-  userTokenAccount?: Base58EncodedAddress;
-  userTokenAuthority?: Base58EncodedAddress;
-}
-
-export const SINGLE_POOL_ACCOUNT_SIZE = 33n;
-
-export const SinglePoolProgram = {
-  programAddress: SINGLE_POOL_PROGRAM_ID,
-  space: SINGLE_POOL_ACCOUNT_SIZE,
-  initialize: initializeTransaction,
-  reactivatePoolStake: reactivatePoolStakeTransaction,
-  deposit: depositTransaction,
-  withdraw: withdrawTransaction,
-  createTokenMetadata: createTokenMetadataTransaction,
-  updateTokenMetadata: updateTokenMetadataTransaction,
-  createAndDelegateUserStake: createAndDelegateUserStakeTransaction,
-};
-
-export async function initializeTransaction(
-  rpc: any, // XXX not exported: Rpc<???>,
-  voteAccount: VoteAccountAddress,
-  payer: Base58EncodedAddress,
-  skipMetadata = false,
-): Promise<Transaction> {
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-
-  const pool = await findPoolAddress(SINGLE_POOL_PROGRAM_ID, voteAccount);
-  const [stake, mint, poolRent, stakeRent, mintRent, minimumDelegationObj] = await Promise.all([
-    findPoolStakeAddress(SINGLE_POOL_PROGRAM_ID, pool),
-    findPoolMintAddress(SINGLE_POOL_PROGRAM_ID, pool),
-    rpc.getMinimumBalanceForRentExemption(SINGLE_POOL_ACCOUNT_SIZE).send(),
-    rpc.getMinimumBalanceForRentExemption(STAKE_ACCOUNT_SIZE).send(),
-    rpc.getMinimumBalanceForRentExemption(MINT_SIZE).send(),
-    rpc.getStakeMinimumDelegation().send(),
-  ]);
-  const minimumDelegation = minimumDelegationObj.value;
-
-  transaction = appendTransactionInstruction(
-    SystemInstruction.transfer({
-      from: payer,
-      to: pool,
-      lamports: poolRent,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    SystemInstruction.transfer({
-      from: payer,
-      to: stake,
-      lamports: stakeRent + minimumDelegation,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    SystemInstruction.transfer({
-      from: payer,
-      to: mint,
-      lamports: mintRent,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    await initializePoolInstruction(voteAccount),
-    transaction,
-  );
-
-  if (!skipMetadata) {
-    transaction = appendTransactionInstruction(
-      await createTokenMetadataInstruction(pool, payer),
-      transaction,
-    );
-  }
-
-  return transaction;
-}
-
-export async function reactivatePoolStakeTransaction(
-  voteAccount: VoteAccountAddress,
-): Promise<Transaction> {
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-  transaction = appendTransactionInstruction(
-    await reactivatePoolStakeInstruction(voteAccount),
-    transaction,
-  );
-
-  return transaction;
-}
-
-export async function depositTransaction(params: DepositParams) {
-  const { rpc, pool, userWallet } = params;
-
-  // note this is just xnor
-  if (!params.userStakeAccount == !params.depositFromDefaultAccount) {
-    throw 'must either provide userStakeAccount or true depositFromDefaultAccount';
-  }
-
-  const userStakeAccount = (
-    params.depositFromDefaultAccount
-      ? await findDefaultDepositAccountAddress(pool, userWallet)
-      : params.userStakeAccount
-  ) as Base58EncodedAddress;
-
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-
-  const [mint, poolStakeAuthority] = await Promise.all([
-    findPoolMintAddress(SINGLE_POOL_PROGRAM_ID, pool),
-    findPoolStakeAuthorityAddress(SINGLE_POOL_PROGRAM_ID, pool),
-  ]);
-
-  const userAssociatedTokenAccount = await getAssociatedTokenAddress(mint, userWallet);
-  const userTokenAccount = params.userTokenAccount || userAssociatedTokenAccount;
-  const userLamportAccount = params.userLamportAccount || userWallet;
-  const userWithdrawAuthority = params.userWithdrawAuthority || userWallet;
-
-  if (
-    userTokenAccount == userAssociatedTokenAccount &&
-    (await rpc.getAccountInfo(userAssociatedTokenAccount).send()) == null
-  ) {
-    transaction = appendTransactionInstruction(
-      TokenInstruction.createAssociatedTokenAccount({
-        payer: userWallet,
-        associatedAccount: userAssociatedTokenAccount,
-        owner: userWallet,
-        mint,
-      }),
-      transaction,
-    );
-  }
-
-  transaction = appendTransactionInstruction(
-    StakeInstruction.authorize({
-      stakeAccount: userStakeAccount,
-      authorized: userWithdrawAuthority,
-      newAuthorized: poolStakeAuthority,
-      authorizationType: StakeAuthorizationType.Staker,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    StakeInstruction.authorize({
-      stakeAccount: userStakeAccount,
-      authorized: userWithdrawAuthority,
-      newAuthorized: poolStakeAuthority,
-      authorizationType: StakeAuthorizationType.Withdrawer,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    await depositStakeInstruction(pool, userStakeAccount, userTokenAccount, userLamportAccount),
-    transaction,
-  );
-
-  return transaction;
-}
-
-export async function withdrawTransaction(params: WithdrawParams) {
-  const { rpc, pool, userWallet, userStakeAccount, tokenAmount, createStakeAccount } = params;
-
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-
-  const poolMintAuthority = await findPoolMintAuthorityAddress(SINGLE_POOL_PROGRAM_ID, pool);
-
-  const userStakeAuthority = params.userStakeAuthority || userWallet;
-  const userTokenAccount =
-    params.userTokenAccount ||
-    (await getAssociatedTokenAddress(
-      await findPoolMintAddress(SINGLE_POOL_PROGRAM_ID, pool),
-      userWallet,
-    ));
-  const userTokenAuthority = params.userTokenAuthority || userWallet;
-
-  if (createStakeAccount) {
-    transaction = appendTransactionInstruction(
-      SystemInstruction.createAccount({
-        from: userWallet,
-        lamports: await rpc.getMinimumBalanceForRentExemption(STAKE_ACCOUNT_SIZE).send(),
-        newAccount: userStakeAccount,
-        programAddress: STAKE_PROGRAM_ID,
-        space: STAKE_ACCOUNT_SIZE,
-      }),
-      transaction,
-    );
-  }
-
-  transaction = appendTransactionInstruction(
-    TokenInstruction.approve({
-      account: userTokenAccount,
-      delegate: poolMintAuthority,
-      owner: userTokenAuthority,
-      amount: tokenAmount,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    await withdrawStakeInstruction(
-      pool,
-      userStakeAccount,
-      userStakeAuthority,
-      userTokenAccount,
-      tokenAmount,
-    ),
-    transaction,
-  );
-
-  return transaction;
-}
-
-export async function createTokenMetadataTransaction(
-  pool: PoolAddress,
-  payer: Base58EncodedAddress,
-): Promise<Transaction> {
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-  transaction = appendTransactionInstruction(
-    await createTokenMetadataInstruction(pool, payer),
-    transaction,
-  );
-
-  return transaction;
-}
-
-export async function updateTokenMetadataTransaction(
-  voteAccount: VoteAccountAddress,
-  authorizedWithdrawer: Base58EncodedAddress,
-  name: string,
-  symbol: string,
-  uri?: string,
-): Promise<Transaction> {
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-  transaction = appendTransactionInstruction(
-    await updateTokenMetadataInstruction(voteAccount, authorizedWithdrawer, name, symbol, uri),
-    transaction,
-  );
-
-  return transaction;
-}
-
-export async function createAndDelegateUserStakeTransaction(
-  rpc: any, // XXX not exported: Rpc<???>,
-  voteAccount: VoteAccountAddress,
-  userWallet: Base58EncodedAddress,
-  stakeAmount: bigint,
-): Promise<Transaction> {
-  let transaction = { instructions: [] as any, version: 'legacy' as TransactionVersion };
-
-  const pool = await findPoolAddress(SINGLE_POOL_PROGRAM_ID, voteAccount);
-  const [stakeAccount, stakeRent] = await Promise.all([
-    findDefaultDepositAccountAddress(pool, userWallet),
-    await rpc.getMinimumBalanceForRentExemption(STAKE_ACCOUNT_SIZE).send(),
-  ]);
-
-  transaction = appendTransactionInstruction(
-    SystemInstruction.createAccountWithSeed({
-      base: userWallet,
-      from: userWallet,
-      lamports: stakeAmount + stakeRent,
-      newAccount: stakeAccount,
-      programAddress: STAKE_PROGRAM_ID,
-      seed: defaultDepositAccountSeed(pool),
-      space: STAKE_ACCOUNT_SIZE,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    StakeInstruction.initialize({
-      stakeAccount,
-      staker: userWallet,
-      withdrawer: userWallet,
-    }),
-    transaction,
-  );
-
-  transaction = appendTransactionInstruction(
-    StakeInstruction.delegate({
-      stakeAccount,
-      authorized: userWallet,
-      voteAccount,
-    }),
-    transaction,
-  );
-
-  return transaction;
-}
diff --git a/single-pool/js/packages/modern/ts-fixup.sh b/single-pool/js/packages/modern/ts-fixup.sh
deleted file mode 120000
index 2b79c262866..00000000000
--- a/single-pool/js/packages/modern/ts-fixup.sh
+++ /dev/null
@@ -1 +0,0 @@
-../../ts-fixup.sh
\ No newline at end of file
diff --git a/single-pool/js/packages/modern/tsconfig-base.json b/single-pool/js/packages/modern/tsconfig-base.json
deleted file mode 120000
index 8cdeff689fc..00000000000
--- a/single-pool/js/packages/modern/tsconfig-base.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig-base.json
\ No newline at end of file
diff --git a/single-pool/js/packages/modern/tsconfig-cjs.json b/single-pool/js/packages/modern/tsconfig-cjs.json
deleted file mode 120000
index eb5b6778868..00000000000
--- a/single-pool/js/packages/modern/tsconfig-cjs.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig-cjs.json
\ No newline at end of file
diff --git a/single-pool/js/packages/modern/tsconfig.json b/single-pool/js/packages/modern/tsconfig.json
deleted file mode 120000
index fd0e4743dda..00000000000
--- a/single-pool/js/packages/modern/tsconfig.json
+++ /dev/null
@@ -1 +0,0 @@
-../../tsconfig.json
\ No newline at end of file
diff --git a/single-pool/js/ts-fixup.sh b/single-pool/js/ts-fixup.sh
deleted file mode 100755
index 39177d08657..00000000000
--- a/single-pool/js/ts-fixup.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-cat >dist/cjs/package.json <<!EOF
-{
-    "type": "commonjs"
-}
-!EOF
-
-cat >dist/mjs/package.json <<!EOF
-{
-    "type": "module"
-}
-!EOF
diff --git a/single-pool/js/tsconfig-base.json b/single-pool/js/tsconfig-base.json
deleted file mode 100644
index 76d1a139543..00000000000
--- a/single-pool/js/tsconfig-base.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-    "compilerOptions": {
-        "allowJs": true,
-        "allowSyntheticDefaultImports": true,
-        "baseUrl": "src",
-        "declaration": true,
-        "esModuleInterop": true,
-        "inlineSourceMap": false,
-        "lib": ["esnext"],
-        "listEmittedFiles": false,
-        "listFiles": false,
-        "moduleResolution": "node",
-        "noFallthroughCasesInSwitch": true,
-        "pretty": true,
-        "resolveJsonModule": true,
-        "rootDir": "src",
-        "skipLibCheck": true,
-        "strict": true,
-        "traceResolution": false,
-        "types": ["node"]
-    },
-    "compileOnSave": false,
-    "exclude": ["node_modules", "dist"],
-    "include": ["src"]
-}
diff --git a/single-pool/js/tsconfig-cjs.json b/single-pool/js/tsconfig-cjs.json
deleted file mode 100644
index 7ce83288486..00000000000
--- a/single-pool/js/tsconfig-cjs.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig-base.json",
-    "compilerOptions": {
-        "module": "commonjs",
-        "outDir": "dist/cjs",
-        "target": "es2020"
-    }
-}
diff --git a/single-pool/js/tsconfig.json b/single-pool/js/tsconfig.json
deleted file mode 100644
index ee6e15af6b9..00000000000
--- a/single-pool/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig-base.json",
-    "compilerOptions": {
-        "module": "esnext",
-        "outDir": "dist/mjs",
-        "target": "esnext"
-    }
-}
diff --git a/single-pool/program/Cargo.toml b/single-pool/program/Cargo.toml
deleted file mode 100644
index 4439fe303cd..00000000000
--- a/single-pool/program/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-[package]
-name = "spl-single-pool"
-version = "1.0.1"
-description = "Solana Program Library Single-Validator Stake Pool"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-arrayref = "0.3.7"
-borsh = "1.5.1"
-num-derive = "0.4"
-num-traits = "0.2"
-num_enum = "0.7.2"
-solana-program = ">=1.18.11,<=2"
-solana-security-txt = "1.1.1"
-spl-token = { version = "4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-thiserror = "1.0"
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-solana-vote-program = ">=1.18.11,<=2"
-test-case = "3.3"
-bincode = "1.3.1"
-rand = "0.8.5"
-approx = "0.5.1"
-
-[lib]
-crate-type = ["cdylib", "lib"]
diff --git a/single-pool/program/program-id.md b/single-pool/program/program-id.md
deleted file mode 100644
index e873b000f15..00000000000
--- a/single-pool/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-SVSPxpvHdN29nkVg9rPapPNDddN5DipNLRUFhyjFThE
diff --git a/single-pool/program/src/entrypoint.rs b/single-pool/program/src/entrypoint.rs
deleted file mode 100644
index 07d7ae60f23..00000000000
--- a/single-pool/program/src/entrypoint.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Program entrypoint
-
-#![cfg(all(target_os = "solana", not(feature = "no-entrypoint")))]
-
-use {
-    crate::{error::SinglePoolError, processor::Processor},
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    solana_security_txt::security_txt,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<SinglePoolError>();
-        Err(error)
-    } else {
-        Ok(())
-    }
-}
-
-security_txt! {
-    // Required fields
-    name: "SPL Single-Validator Stake Pool",
-    project_url: "https://spl.solana.com/single-pool",
-    contacts: "link:https://github.com/solana-labs/solana-program-library/security/advisories/new,mailto:security@solana.com,discord:https://discord.gg/solana",
-    policy: "https://github.com/solana-labs/solana-program-library/blob/master/SECURITY.md",
-
-    // Optional Fields
-    preferred_languages: "en",
-    source_code: "https://github.com/solana-labs/solana-program-library/tree/master/single-pool/program",
-    source_revision: "ef44df985e76a697ee9a8aabb3a223610e4cf1dc",
-    source_release: "single-pool-v1.0.0",
-    auditors: "https://github.com/solana-labs/security-audits#single-stake-pool"
-}
diff --git a/single-pool/program/src/error.rs b/single-pool/program/src/error.rs
deleted file mode 100644
index 087768492da..00000000000
--- a/single-pool/program/src/error.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-//! Error types
-
-use {
-    solana_program::{
-        decode_error::DecodeError,
-        msg,
-        program_error::{PrintProgramError, ProgramError},
-    },
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the SinglePool program.
-#[derive(Clone, Debug, Eq, Error, num_derive::FromPrimitive, PartialEq)]
-pub enum SinglePoolError {
-    // 0.
-    /// Provided pool account has the wrong address for its vote account, is
-    /// uninitialized, or otherwise invalid.
-    #[error("InvalidPoolAccount")]
-    InvalidPoolAccount,
-    /// Provided pool stake account does not match address derived from the pool
-    /// account.
-    #[error("InvalidPoolStakeAccount")]
-    InvalidPoolStakeAccount,
-    /// Provided pool mint does not match address derived from the pool account.
-    #[error("InvalidPoolMint")]
-    InvalidPoolMint,
-    /// Provided pool stake authority does not match address derived from the
-    /// pool account.
-    #[error("InvalidPoolStakeAuthority")]
-    InvalidPoolStakeAuthority,
-    /// Provided pool mint authority does not match address derived from the
-    /// pool account.
-    #[error("InvalidPoolMintAuthority")]
-    InvalidPoolMintAuthority,
-
-    // 5.
-    /// Provided pool MPL authority does not match address derived from the pool
-    /// account.
-    #[error("InvalidPoolMplAuthority")]
-    InvalidPoolMplAuthority,
-    /// Provided metadata account does not match metadata account derived for
-    /// pool mint.
-    #[error("InvalidMetadataAccount")]
-    InvalidMetadataAccount,
-    /// Authorized withdrawer provided for metadata update does not match the
-    /// vote account.
-    #[error("InvalidMetadataSigner")]
-    InvalidMetadataSigner,
-    /// Not enough lamports provided for deposit to result in one pool token.
-    #[error("DepositTooSmall")]
-    DepositTooSmall,
-    /// Not enough pool tokens provided to withdraw stake worth one lamport.
-    #[error("WithdrawalTooSmall")]
-    WithdrawalTooSmall,
-
-    // 10
-    /// Not enough stake to cover the provided quantity of pool tokens.
-    /// (Generally this should not happen absent user error, but may if the
-    /// minimum delegation increases.)
-    #[error("WithdrawalTooLarge")]
-    WithdrawalTooLarge,
-    /// Required signature is missing.
-    #[error("SignatureMissing")]
-    SignatureMissing,
-    /// Stake account is not in the state expected by the program.
-    #[error("WrongStakeStake")]
-    WrongStakeStake,
-    /// Unsigned subtraction crossed the zero.
-    #[error("ArithmeticOverflow")]
-    ArithmeticOverflow,
-    /// A calculation failed unexpectedly.
-    /// (This error should never be surfaced; it stands in for failure
-    /// conditions that should never be reached.)
-    #[error("UnexpectedMathError")]
-    UnexpectedMathError,
-
-    // 15
-    /// The V0_23_5 vote account type is unsupported and should be upgraded via
-    /// `convert_to_current()`.
-    #[error("LegacyVoteAccount")]
-    LegacyVoteAccount,
-    /// Failed to parse vote account.
-    #[error("UnparseableVoteAccount")]
-    UnparseableVoteAccount,
-    /// Incorrect number of lamports provided for rent-exemption when
-    /// initializing.
-    #[error("WrongRentAmount")]
-    WrongRentAmount,
-    /// Attempted to deposit from or withdraw to pool stake account.
-    #[error("InvalidPoolStakeAccountUsage")]
-    InvalidPoolStakeAccountUsage,
-    /// Attempted to initialize a pool that is already initialized.
-    #[error("PoolAlreadyInitialized")]
-    PoolAlreadyInitialized,
-}
-impl From<SinglePoolError> for ProgramError {
-    fn from(e: SinglePoolError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for SinglePoolError {
-    fn type_of() -> &'static str {
-        "Single-Validator Stake Pool Error"
-    }
-}
-impl PrintProgramError for SinglePoolError {
-    fn print<E>(&self)
-    where
-        E: 'static
-            + std::error::Error
-            + DecodeError<E>
-            + PrintProgramError
-            + num_traits::FromPrimitive,
-    {
-        match self {
-            SinglePoolError::InvalidPoolAccount =>
-                msg!("Error: Provided pool account has the wrong address for its vote account, is uninitialized, \
-                     or is otherwise invalid."),
-            SinglePoolError::InvalidPoolStakeAccount =>
-                msg!("Error: Provided pool stake account does not match address derived from the pool account."),
-            SinglePoolError::InvalidPoolMint =>
-                msg!("Error: Provided pool mint does not match address derived from the pool account."),
-            SinglePoolError::InvalidPoolStakeAuthority =>
-                msg!("Error: Provided pool stake authority does not match address derived from the pool account."),
-            SinglePoolError::InvalidPoolMintAuthority =>
-                msg!("Error: Provided pool mint authority does not match address derived from the pool account."),
-            SinglePoolError::InvalidPoolMplAuthority =>
-                msg!("Error: Provided pool MPL authority does not match address derived from the pool account."),
-            SinglePoolError::InvalidMetadataAccount =>
-                msg!("Error: Provided metadata account does not match metadata account derived for pool mint."),
-            SinglePoolError::InvalidMetadataSigner =>
-                msg!("Error: Authorized withdrawer provided for metadata update does not match the vote account."),
-            SinglePoolError::DepositTooSmall =>
-                msg!("Error: Not enough lamports provided for deposit to result in one pool token."),
-            SinglePoolError::WithdrawalTooSmall =>
-                msg!("Error: Not enough pool tokens provided to withdraw stake worth one lamport."),
-            SinglePoolError::WithdrawalTooLarge =>
-                msg!("Error: Not enough stake to cover the provided quantity of pool tokens. \
-                     (Generally this should not happen absent user error, but may if the minimum delegation increases.)"),
-            SinglePoolError::SignatureMissing => msg!("Error: Required signature is missing."),
-            SinglePoolError::WrongStakeStake => msg!("Error: Stake account is not in the state expected by the program."),
-            SinglePoolError::ArithmeticOverflow => msg!("Error: Unsigned subtraction crossed the zero."),
-            SinglePoolError::UnexpectedMathError =>
-                msg!("Error: A calculation failed unexpectedly. \
-                     (This error should never be surfaced; it stands in for failure conditions that should never be reached.)"),
-            SinglePoolError::UnparseableVoteAccount => msg!("Error: Failed to parse vote account."),
-            SinglePoolError::LegacyVoteAccount =>
-                msg!("Error: The V0_23_5 vote account type is unsupported and should be upgraded via `convert_to_current()`."),
-            SinglePoolError::WrongRentAmount =>
-                msg!("Error: Incorrect number of lamports provided for rent-exemption when initializing."),
-            SinglePoolError::InvalidPoolStakeAccountUsage =>
-                msg!("Error: Attempted to deposit from or withdraw to pool stake account."),
-            SinglePoolError::PoolAlreadyInitialized =>
-                msg!("Error: Attempted to initialize a pool that is already initialized."),
-        }
-    }
-}
diff --git a/single-pool/program/src/inline_mpl_token_metadata.rs b/single-pool/program/src/inline_mpl_token_metadata.rs
deleted file mode 120000
index 144225f4bfc..00000000000
--- a/single-pool/program/src/inline_mpl_token_metadata.rs
+++ /dev/null
@@ -1 +0,0 @@
-../../../stake-pool/program/src/inline_mpl_token_metadata.rs
\ No newline at end of file
diff --git a/single-pool/program/src/instruction.rs b/single-pool/program/src/instruction.rs
deleted file mode 100644
index fda54691a3c..00000000000
--- a/single-pool/program/src/instruction.rs
+++ /dev/null
@@ -1,473 +0,0 @@
-//! Instruction types
-
-#![allow(clippy::too_many_arguments)]
-
-use {
-    crate::{
-        find_default_deposit_account_address_and_seed, find_pool_address, find_pool_mint_address,
-        find_pool_mint_authority_address, find_pool_mpl_authority_address, find_pool_stake_address,
-        find_pool_stake_authority_address,
-        inline_mpl_token_metadata::{self, pda::find_metadata_account},
-        state::SinglePool,
-    },
-    borsh::{BorshDeserialize, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_pack::Pack,
-        pubkey::Pubkey,
-        rent::Rent,
-        stake, system_instruction, system_program, sysvar,
-    },
-};
-
-/// Instructions supported by the SinglePool program.
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub enum SinglePoolInstruction {
-    ///   Initialize the mint and stake account for a new single-validator
-    ///   stake pool. The pool stake account must contain the rent-exempt
-    ///   minimum plus the minimum delegation. No tokens will be minted: to
-    ///   deposit more, use `Deposit` after `InitializeStake`.
-    ///
-    ///   0. `[]` Validator vote account
-    ///   1. `[w]` Pool account
-    ///   2. `[w]` Pool stake account
-    ///   3. `[w]` Pool token mint
-    ///   4. `[]` Pool stake authority
-    ///   5. `[]` Pool mint authority
-    ///   6. `[]` Rent sysvar
-    ///   7. `[]` Clock sysvar
-    ///   8. `[]` Stake history sysvar
-    ///   9. `[]` Stake config sysvar
-    ///  10. `[]` System program
-    ///  11. `[]` Token program
-    ///  12. `[]` Stake program
-    InitializePool,
-
-    ///   Restake the pool stake account if it was deactivated. This can
-    ///   happen through the stake program's `DeactivateDelinquent`
-    ///   instruction, or during a cluster restart.
-    ///
-    ///   0. `[]` Validator vote account
-    ///   1. `[]` Pool account
-    ///   2. `[w]` Pool stake account
-    ///   3. `[]` Pool stake authority
-    ///   4. `[]` Clock sysvar
-    ///   5. `[]` Stake history sysvar
-    ///   6. `[]` Stake config sysvar
-    ///   7. `[]` Stake program
-    ReactivatePoolStake,
-
-    ///   Deposit stake into the pool. The output is a "pool" token
-    ///   representing fractional ownership of the pool stake. Inputs are
-    ///   converted to the current ratio.
-    ///
-    ///   0. `[]` Pool account
-    ///   1. `[w]` Pool stake account
-    ///   2. `[w]` Pool token mint
-    ///   3. `[]` Pool stake authority
-    ///   4. `[]` Pool mint authority
-    ///   5. `[w]` User stake account to join to the pool
-    ///   6. `[w]` User account to receive pool tokens
-    ///   7. `[w]` User account to receive lamports
-    ///   8. `[]` Clock sysvar
-    ///   9. `[]` Stake history sysvar
-    ///  10. `[]` Token program
-    ///  11. `[]` Stake program
-    DepositStake,
-
-    ///   Redeem tokens issued by this pool for stake at the current ratio.
-    ///
-    ///   0. `[]` Pool account
-    ///   1. `[w]` Pool stake account
-    ///   2. `[w]` Pool token mint
-    ///   3. `[]` Pool stake authority
-    ///   4. `[]` Pool mint authority
-    ///   5. `[w]` User stake account to receive stake at
-    ///   6. `[w]` User account to take pool tokens from
-    ///   7. `[]` Clock sysvar
-    ///   8. `[]` Token program
-    ///   9. `[]` Stake program
-    WithdrawStake {
-        /// User authority for the new stake account
-        user_stake_authority: Pubkey,
-        /// Amount of tokens to redeem for stake
-        token_amount: u64,
-    },
-
-    ///   Create token metadata for the stake-pool token in the metaplex-token
-    ///   program. Step three of the permissionless three-stage initialization
-    ///   flow.
-    ///   Note this instruction is not necessary for the pool to operate, to
-    ///   ensure we cannot be broken by upstream.
-    ///
-    ///   0. `[]` Pool account
-    ///   1. `[]` Pool token mint
-    ///   2. `[]` Pool mint authority
-    ///   3. `[]` Pool MPL authority
-    ///   4. `[s, w]` Payer for creation of token metadata account
-    ///   5. `[w]` Token metadata account
-    ///   6. `[]` Metadata program id
-    ///   7. `[]` System program id
-    CreateTokenMetadata,
-
-    ///   Update token metadata for the stake-pool token in the metaplex-token
-    ///   program.
-    ///
-    ///   0. `[]` Validator vote account
-    ///   1. `[]` Pool account
-    ///   2. `[]` Pool MPL authority
-    ///   3. `[s]` Vote account authorized withdrawer
-    ///   4. `[w]` Token metadata account
-    ///   5. `[]` Metadata program id
-    UpdateTokenMetadata {
-        /// Token name
-        name: String,
-        /// Token symbol e.g. stkSOL
-        symbol: String,
-        /// URI of the uploaded metadata of the spl-token
-        uri: String,
-    },
-}
-
-/// Creates all necessary instructions to initialize the stake pool.
-pub fn initialize(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    payer: &Pubkey,
-    rent: &Rent,
-    minimum_delegation: u64,
-) -> Vec<Instruction> {
-    let pool_address = find_pool_address(program_id, vote_account_address);
-    let pool_rent = rent.minimum_balance(std::mem::size_of::<SinglePool>());
-
-    let stake_address = find_pool_stake_address(program_id, &pool_address);
-    let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-    let stake_rent_plus_minimum = rent
-        .minimum_balance(stake_space)
-        .saturating_add(minimum_delegation);
-
-    let mint_address = find_pool_mint_address(program_id, &pool_address);
-    let mint_rent = rent.minimum_balance(spl_token::state::Mint::LEN);
-
-    vec![
-        system_instruction::transfer(payer, &pool_address, pool_rent),
-        system_instruction::transfer(payer, &stake_address, stake_rent_plus_minimum),
-        system_instruction::transfer(payer, &mint_address, mint_rent),
-        initialize_pool(program_id, vote_account_address),
-        create_token_metadata(program_id, &pool_address, payer),
-    ]
-}
-
-/// Creates an `InitializePool` instruction.
-pub fn initialize_pool(program_id: &Pubkey, vote_account_address: &Pubkey) -> Instruction {
-    let pool_address = find_pool_address(program_id, vote_account_address);
-    let mint_address = find_pool_mint_address(program_id, &pool_address);
-
-    let data = borsh::to_vec(&SinglePoolInstruction::InitializePool).unwrap();
-    let accounts = vec![
-        AccountMeta::new_readonly(*vote_account_address, false),
-        AccountMeta::new(pool_address, false),
-        AccountMeta::new(find_pool_stake_address(program_id, &pool_address), false),
-        AccountMeta::new(mint_address, false),
-        AccountMeta::new_readonly(
-            find_pool_stake_authority_address(program_id, &pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(
-            find_pool_mint_authority_address(program_id, &pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates a `ReactivatePoolStake` instruction.
-pub fn reactivate_pool_stake(program_id: &Pubkey, vote_account_address: &Pubkey) -> Instruction {
-    let pool_address = find_pool_address(program_id, vote_account_address);
-
-    let data = borsh::to_vec(&SinglePoolInstruction::ReactivatePoolStake).unwrap();
-    let accounts = vec![
-        AccountMeta::new_readonly(*vote_account_address, false),
-        AccountMeta::new_readonly(pool_address, false),
-        AccountMeta::new(find_pool_stake_address(program_id, &pool_address), false),
-        AccountMeta::new_readonly(
-            find_pool_stake_authority_address(program_id, &pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates all necessary instructions to deposit stake.
-pub fn deposit(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    user_stake_account: &Pubkey,
-    user_token_account: &Pubkey,
-    user_lamport_account: &Pubkey,
-    user_withdraw_authority: &Pubkey,
-) -> Vec<Instruction> {
-    let pool_stake_authority = find_pool_stake_authority_address(program_id, pool_address);
-
-    vec![
-        stake::instruction::authorize(
-            user_stake_account,
-            user_withdraw_authority,
-            &pool_stake_authority,
-            stake::state::StakeAuthorize::Staker,
-            None,
-        ),
-        stake::instruction::authorize(
-            user_stake_account,
-            user_withdraw_authority,
-            &pool_stake_authority,
-            stake::state::StakeAuthorize::Withdrawer,
-            None,
-        ),
-        deposit_stake(
-            program_id,
-            pool_address,
-            user_stake_account,
-            user_token_account,
-            user_lamport_account,
-        ),
-    ]
-}
-
-/// Creates a `DepositStake` instruction.
-pub fn deposit_stake(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    user_stake_account: &Pubkey,
-    user_token_account: &Pubkey,
-    user_lamport_account: &Pubkey,
-) -> Instruction {
-    let data = borsh::to_vec(&SinglePoolInstruction::DepositStake).unwrap();
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*pool_address, false),
-        AccountMeta::new(find_pool_stake_address(program_id, pool_address), false),
-        AccountMeta::new(find_pool_mint_address(program_id, pool_address), false),
-        AccountMeta::new_readonly(
-            find_pool_stake_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(
-            find_pool_mint_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new(*user_stake_account, false),
-        AccountMeta::new(*user_token_account, false),
-        AccountMeta::new(*user_lamport_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates all necessary instructions to withdraw stake into a given stake
-/// account. If a new stake account is required, the user should first include
-/// `system_instruction::create_account` with account size
-/// `std::mem::size_of::<stake::state::StakeStateV2>()` and owner
-/// `stake::program::id()`.
-pub fn withdraw(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    user_stake_account: &Pubkey,
-    user_stake_authority: &Pubkey,
-    user_token_account: &Pubkey,
-    user_token_authority: &Pubkey,
-    token_amount: u64,
-) -> Vec<Instruction> {
-    vec![
-        spl_token::instruction::approve(
-            &spl_token::id(),
-            user_token_account,
-            &find_pool_mint_authority_address(program_id, pool_address),
-            user_token_authority,
-            &[],
-            token_amount,
-        )
-        .unwrap(),
-        withdraw_stake(
-            program_id,
-            pool_address,
-            user_stake_account,
-            user_stake_authority,
-            user_token_account,
-            token_amount,
-        ),
-    ]
-}
-
-/// Creates a `WithdrawStake` instruction.
-pub fn withdraw_stake(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    user_stake_account: &Pubkey,
-    user_stake_authority: &Pubkey,
-    user_token_account: &Pubkey,
-    token_amount: u64,
-) -> Instruction {
-    let data = borsh::to_vec(&SinglePoolInstruction::WithdrawStake {
-        user_stake_authority: *user_stake_authority,
-        token_amount,
-    })
-    .unwrap();
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*pool_address, false),
-        AccountMeta::new(find_pool_stake_address(program_id, pool_address), false),
-        AccountMeta::new(find_pool_mint_address(program_id, pool_address), false),
-        AccountMeta::new_readonly(
-            find_pool_stake_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(
-            find_pool_mint_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new(*user_stake_account, false),
-        AccountMeta::new(*user_token_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates necessary instructions to create and delegate a new stake account to
-/// a given validator. Uses a fixed address for each wallet and vote account
-/// combination to make it easier to find for deposits. This is an optional
-/// helper function; deposits can come from any owned stake account without
-/// lockup.
-pub fn create_and_delegate_user_stake(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    user_wallet: &Pubkey,
-    rent: &Rent,
-    stake_amount: u64,
-) -> Vec<Instruction> {
-    let pool_address = find_pool_address(program_id, vote_account_address);
-    let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-    let lamports = rent
-        .minimum_balance(stake_space)
-        .saturating_add(stake_amount);
-    let (deposit_address, deposit_seed) =
-        find_default_deposit_account_address_and_seed(&pool_address, user_wallet);
-
-    stake::instruction::create_account_with_seed_and_delegate_stake(
-        user_wallet,
-        &deposit_address,
-        user_wallet,
-        &deposit_seed,
-        vote_account_address,
-        &stake::state::Authorized::auto(user_wallet),
-        &stake::state::Lockup::default(),
-        lamports,
-    )
-}
-
-/// Creates a `CreateTokenMetadata` instruction.
-pub fn create_token_metadata(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    payer: &Pubkey,
-) -> Instruction {
-    let pool_mint = find_pool_mint_address(program_id, pool_address);
-    let (token_metadata, _) = find_metadata_account(&pool_mint);
-    let data = borsh::to_vec(&SinglePoolInstruction::CreateTokenMetadata).unwrap();
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*pool_address, false),
-        AccountMeta::new_readonly(pool_mint, false),
-        AccountMeta::new_readonly(
-            find_pool_mint_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(
-            find_pool_mpl_authority_address(program_id, pool_address),
-            false,
-        ),
-        AccountMeta::new(*payer, true),
-        AccountMeta::new(token_metadata, false),
-        AccountMeta::new_readonly(inline_mpl_token_metadata::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates an `UpdateTokenMetadata` instruction.
-pub fn update_token_metadata(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    authorized_withdrawer: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> Instruction {
-    let pool_address = find_pool_address(program_id, vote_account_address);
-    let pool_mint = find_pool_mint_address(program_id, &pool_address);
-    let (token_metadata, _) = find_metadata_account(&pool_mint);
-    let data =
-        borsh::to_vec(&SinglePoolInstruction::UpdateTokenMetadata { name, symbol, uri }).unwrap();
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*vote_account_address, false),
-        AccountMeta::new_readonly(pool_address, false),
-        AccountMeta::new_readonly(
-            find_pool_mpl_authority_address(program_id, &pool_address),
-            false,
-        ),
-        AccountMeta::new_readonly(*authorized_withdrawer, true),
-        AccountMeta::new(token_metadata, false),
-        AccountMeta::new_readonly(inline_mpl_token_metadata::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
diff --git a/single-pool/program/src/lib.rs b/single-pool/program/src/lib.rs
deleted file mode 100644
index 62ed4376647..00000000000
--- a/single-pool/program/src/lib.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-#![deny(missing_docs)]
-
-//! A program for liquid staking with a single validator
-
-pub mod error;
-pub mod inline_mpl_token_metadata;
-pub mod instruction;
-pub mod processor;
-pub mod state;
-
-#[cfg(not(feature = "no-entrypoint"))]
-pub mod entrypoint;
-
-// export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-use solana_program::{pubkey::Pubkey, stake};
-
-solana_program::declare_id!("SVSPxpvHdN29nkVg9rPapPNDddN5DipNLRUFhyjFThE");
-
-const POOL_PREFIX: &[u8] = b"pool";
-const POOL_STAKE_PREFIX: &[u8] = b"stake";
-const POOL_MINT_PREFIX: &[u8] = b"mint";
-const POOL_MINT_AUTHORITY_PREFIX: &[u8] = b"mint_authority";
-const POOL_STAKE_AUTHORITY_PREFIX: &[u8] = b"stake_authority";
-const POOL_MPL_AUTHORITY_PREFIX: &[u8] = b"mpl_authority";
-
-const MINT_DECIMALS: u8 = 9;
-
-const VOTE_STATE_DISCRIMINATOR_END: usize = 4;
-const VOTE_STATE_AUTHORIZED_WITHDRAWER_START: usize = 36;
-const VOTE_STATE_AUTHORIZED_WITHDRAWER_END: usize = 68;
-
-fn find_pool_address_and_bump(program_id: &Pubkey, vote_account_address: &Pubkey) -> (Pubkey, u8) {
-    Pubkey::find_program_address(&[POOL_PREFIX, vote_account_address.as_ref()], program_id)
-}
-
-fn find_pool_stake_address_and_bump(program_id: &Pubkey, pool_address: &Pubkey) -> (Pubkey, u8) {
-    Pubkey::find_program_address(&[POOL_STAKE_PREFIX, pool_address.as_ref()], program_id)
-}
-
-fn find_pool_mint_address_and_bump(program_id: &Pubkey, pool_address: &Pubkey) -> (Pubkey, u8) {
-    Pubkey::find_program_address(&[POOL_MINT_PREFIX, pool_address.as_ref()], program_id)
-}
-
-fn find_pool_stake_authority_address_and_bump(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[POOL_STAKE_AUTHORITY_PREFIX, pool_address.as_ref()],
-        program_id,
-    )
-}
-
-fn find_pool_mint_authority_address_and_bump(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[POOL_MINT_AUTHORITY_PREFIX, pool_address.as_ref()],
-        program_id,
-    )
-}
-
-fn find_pool_mpl_authority_address_and_bump(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[POOL_MPL_AUTHORITY_PREFIX, pool_address.as_ref()],
-        program_id,
-    )
-}
-
-fn find_default_deposit_account_address_and_seed(
-    pool_address: &Pubkey,
-    user_wallet_address: &Pubkey,
-) -> (Pubkey, String) {
-    let pool_address_str = pool_address.to_string();
-    let seed = format!("svsp{}", &pool_address_str[0..28]);
-    let address =
-        Pubkey::create_with_seed(user_wallet_address, &seed, &stake::program::id()).unwrap();
-
-    (address, seed)
-}
-
-/// Find the canonical pool address for a given vote account.
-pub fn find_pool_address(program_id: &Pubkey, vote_account_address: &Pubkey) -> Pubkey {
-    find_pool_address_and_bump(program_id, vote_account_address).0
-}
-
-/// Find the canonical stake account address for a given pool account.
-pub fn find_pool_stake_address(program_id: &Pubkey, pool_address: &Pubkey) -> Pubkey {
-    find_pool_stake_address_and_bump(program_id, pool_address).0
-}
-
-/// Find the canonical token mint address for a given pool account.
-pub fn find_pool_mint_address(program_id: &Pubkey, pool_address: &Pubkey) -> Pubkey {
-    find_pool_mint_address_and_bump(program_id, pool_address).0
-}
-
-/// Find the canonical stake authority address for a given pool account.
-pub fn find_pool_stake_authority_address(program_id: &Pubkey, pool_address: &Pubkey) -> Pubkey {
-    find_pool_stake_authority_address_and_bump(program_id, pool_address).0
-}
-
-/// Find the canonical mint authority address for a given pool account.
-pub fn find_pool_mint_authority_address(program_id: &Pubkey, pool_address: &Pubkey) -> Pubkey {
-    find_pool_mint_authority_address_and_bump(program_id, pool_address).0
-}
-
-/// Find the canonical MPL authority address for a given pool account.
-pub fn find_pool_mpl_authority_address(program_id: &Pubkey, pool_address: &Pubkey) -> Pubkey {
-    find_pool_mpl_authority_address_and_bump(program_id, pool_address).0
-}
-
-/// Find the address of the default intermediate account that holds activating
-/// user stake before deposit.
-pub fn find_default_deposit_account_address(
-    pool_address: &Pubkey,
-    user_wallet_address: &Pubkey,
-) -> Pubkey {
-    find_default_deposit_account_address_and_seed(pool_address, user_wallet_address).0
-}
diff --git a/single-pool/program/src/processor.rs b/single-pool/program/src/processor.rs
deleted file mode 100644
index 55379d637d4..00000000000
--- a/single-pool/program/src/processor.rs
+++ /dev/null
@@ -1,1539 +0,0 @@
-//! program state processor
-
-use {
-    crate::{
-        error::SinglePoolError,
-        inline_mpl_token_metadata::{
-            self,
-            instruction::{create_metadata_accounts_v3, update_metadata_accounts_v2},
-            pda::find_metadata_account,
-            state::DataV2,
-        },
-        instruction::SinglePoolInstruction,
-        state::{SinglePool, SinglePoolAccountType},
-        MINT_DECIMALS, POOL_MINT_AUTHORITY_PREFIX, POOL_MINT_PREFIX, POOL_MPL_AUTHORITY_PREFIX,
-        POOL_PREFIX, POOL_STAKE_AUTHORITY_PREFIX, POOL_STAKE_PREFIX,
-        VOTE_STATE_AUTHORIZED_WITHDRAWER_END, VOTE_STATE_AUTHORIZED_WITHDRAWER_START,
-        VOTE_STATE_DISCRIMINATOR_END,
-    },
-    borsh::BorshDeserialize,
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        borsh1::{get_packed_len, try_from_slice_unchecked},
-        entrypoint::ProgramResult,
-        msg,
-        native_token::LAMPORTS_PER_SOL,
-        program::invoke_signed,
-        program_error::ProgramError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        rent::Rent,
-        stake::{
-            self,
-            state::{Meta, Stake, StakeStateV2},
-        },
-        stake_history::Epoch,
-        system_instruction, system_program,
-        sysvar::{clock::Clock, Sysvar},
-        vote::program as vote_program,
-    },
-    spl_token::state::Mint,
-};
-
-/// Calculate pool tokens to mint, given outstanding token supply, pool active
-/// stake, and deposit active stake
-fn calculate_deposit_amount(
-    pre_token_supply: u64,
-    pre_pool_stake: u64,
-    user_stake_to_deposit: u64,
-) -> Option<u64> {
-    if pre_pool_stake == 0 || pre_token_supply == 0 {
-        Some(user_stake_to_deposit)
-    } else {
-        u64::try_from(
-            (user_stake_to_deposit as u128)
-                .checked_mul(pre_token_supply as u128)?
-                .checked_div(pre_pool_stake as u128)?,
-        )
-        .ok()
-    }
-}
-
-/// Calculate pool stake to return, given outstanding token supply, pool active
-/// stake, and tokens to redeem
-fn calculate_withdraw_amount(
-    pre_token_supply: u64,
-    pre_pool_stake: u64,
-    user_tokens_to_burn: u64,
-) -> Option<u64> {
-    let numerator = (user_tokens_to_burn as u128).checked_mul(pre_pool_stake as u128)?;
-    let denominator = pre_token_supply as u128;
-    if numerator < denominator || denominator == 0 {
-        Some(0)
-    } else {
-        u64::try_from(numerator.checked_div(denominator)?).ok()
-    }
-}
-
-/// Deserialize the stake state from AccountInfo
-fn get_stake_state(stake_account_info: &AccountInfo) -> Result<(Meta, Stake), ProgramError> {
-    let stake_state = try_from_slice_unchecked::<StakeStateV2>(&stake_account_info.data.borrow())?;
-
-    match stake_state {
-        StakeStateV2::Stake(meta, stake, _) => Ok((meta, stake)),
-        _ => Err(SinglePoolError::WrongStakeStake.into()),
-    }
-}
-
-/// Deserialize the stake amount from AccountInfo
-fn get_stake_amount(stake_account_info: &AccountInfo) -> Result<u64, ProgramError> {
-    Ok(get_stake_state(stake_account_info)?.1.delegation.stake)
-}
-
-/// Determine if stake is active
-fn is_stake_active_without_history(stake: &Stake, current_epoch: Epoch) -> bool {
-    stake.delegation.activation_epoch < current_epoch
-        && stake.delegation.deactivation_epoch == Epoch::MAX
-}
-
-/// Check pool account address for the validator vote account
-fn check_pool_address(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        vote_account_address,
-        check_address,
-        &crate::find_pool_address_and_bump,
-        "pool",
-        SinglePoolError::InvalidPoolAccount,
-    )
-}
-
-/// Check pool stake account address for the pool account
-fn check_pool_stake_address(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        pool_address,
-        check_address,
-        &crate::find_pool_stake_address_and_bump,
-        "stake account",
-        SinglePoolError::InvalidPoolStakeAccount,
-    )
-}
-
-/// Check pool mint address for the pool account
-fn check_pool_mint_address(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        pool_address,
-        check_address,
-        &crate::find_pool_mint_address_and_bump,
-        "mint",
-        SinglePoolError::InvalidPoolMint,
-    )
-}
-
-/// Check pool stake authority address for the pool account
-fn check_pool_stake_authority_address(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        pool_address,
-        check_address,
-        &crate::find_pool_stake_authority_address_and_bump,
-        "stake authority",
-        SinglePoolError::InvalidPoolStakeAuthority,
-    )
-}
-
-/// Check pool mint authority address for the pool account
-fn check_pool_mint_authority_address(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        pool_address,
-        check_address,
-        &crate::find_pool_mint_authority_address_and_bump,
-        "mint authority",
-        SinglePoolError::InvalidPoolMintAuthority,
-    )
-}
-
-/// Check pool MPL authority address for the pool account
-fn check_pool_mpl_authority_address(
-    program_id: &Pubkey,
-    pool_address: &Pubkey,
-    check_address: &Pubkey,
-) -> Result<u8, ProgramError> {
-    check_pool_pda(
-        program_id,
-        pool_address,
-        check_address,
-        &crate::find_pool_mpl_authority_address_and_bump,
-        "MPL authority",
-        SinglePoolError::InvalidPoolMplAuthority,
-    )
-}
-
-fn check_pool_pda(
-    program_id: &Pubkey,
-    base_address: &Pubkey,
-    check_address: &Pubkey,
-    pda_lookup_fn: &dyn Fn(&Pubkey, &Pubkey) -> (Pubkey, u8),
-    pda_name: &str,
-    pool_error: SinglePoolError,
-) -> Result<u8, ProgramError> {
-    let (derived_address, bump_seed) = pda_lookup_fn(program_id, base_address);
-    if *check_address != derived_address {
-        msg!(
-            "Incorrect {} address for base {}: expected {}, received {}",
-            pda_name,
-            base_address,
-            derived_address,
-            check_address,
-        );
-        Err(pool_error.into())
-    } else {
-        Ok(bump_seed)
-    }
-}
-
-/// Check vote account is owned by the vote program and not a legacy variant
-fn check_vote_account(vote_account_info: &AccountInfo) -> Result<(), ProgramError> {
-    check_account_owner(vote_account_info, &vote_program::id())?;
-
-    let vote_account_data = &vote_account_info.try_borrow_data()?;
-    let state_variant = vote_account_data
-        .get(..VOTE_STATE_DISCRIMINATOR_END)
-        .and_then(|s| s.try_into().ok())
-        .ok_or(SinglePoolError::UnparseableVoteAccount)?;
-
-    match u32::from_le_bytes(state_variant) {
-        1 | 2 => Ok(()),
-        0 => Err(SinglePoolError::LegacyVoteAccount.into()),
-        _ => Err(SinglePoolError::UnparseableVoteAccount.into()),
-    }
-}
-
-/// Check MPL metadata account address for the pool mint
-fn check_mpl_metadata_account_address(
-    metadata_address: &Pubkey,
-    pool_mint: &Pubkey,
-) -> Result<(), ProgramError> {
-    let (metadata_account_pubkey, _) = find_metadata_account(pool_mint);
-    if metadata_account_pubkey != *metadata_address {
-        Err(SinglePoolError::InvalidMetadataAccount.into())
-    } else {
-        Ok(())
-    }
-}
-
-/// Check system program address
-fn check_system_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != system_program::id() {
-        msg!(
-            "Expected system program {}, received {}",
-            system_program::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check token program address
-fn check_token_program(address: &Pubkey) -> Result<(), ProgramError> {
-    if *address != spl_token::id() {
-        msg!(
-            "Incorrect token program, expected {}, received {}",
-            spl_token::id(),
-            address
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check stake program address
-fn check_stake_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != stake::program::id() {
-        msg!(
-            "Expected stake program {}, received {}",
-            stake::program::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check MPL metadata program
-fn check_mpl_metadata_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != inline_mpl_token_metadata::id() {
-        msg!(
-            "Expected MPL metadata program {}, received {}",
-            inline_mpl_token_metadata::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check account owner is the given program
-fn check_account_owner(
-    account_info: &AccountInfo,
-    program_id: &Pubkey,
-) -> Result<(), ProgramError> {
-    if *program_id != *account_info.owner {
-        msg!(
-            "Expected account to be owned by program {}, received {}",
-            program_id,
-            account_info.owner
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Minimum delegation to create a pool
-/// We floor at 1sol to avoid over-minting tokens before the relevant feature is
-/// active
-fn minimum_delegation() -> Result<u64, ProgramError> {
-    Ok(std::cmp::max(
-        stake::tools::get_minimum_delegation()?,
-        LAMPORTS_PER_SOL,
-    ))
-}
-
-/// Program state handler.
-pub struct Processor {}
-impl Processor {
-    #[allow(clippy::too_many_arguments)]
-    fn stake_merge<'a>(
-        pool_account_key: &Pubkey,
-        source_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        bump_seed: u8,
-        destination_account: AccountInfo<'a>,
-        clock: AccountInfo<'a>,
-        stake_history: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        invoke_signed(
-            &stake::instruction::merge(destination_account.key, source_account.key, authority.key)
-                [0],
-            &[
-                destination_account,
-                source_account,
-                clock,
-                stake_history,
-                authority,
-            ],
-            signers,
-        )
-    }
-
-    fn stake_split<'a>(
-        pool_account_key: &Pubkey,
-        stake_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        bump_seed: u8,
-        amount: u64,
-        split_stake: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        let split_instruction =
-            stake::instruction::split(stake_account.key, authority.key, amount, split_stake.key);
-
-        invoke_signed(
-            split_instruction.last().unwrap(),
-            &[stake_account, split_stake, authority],
-            signers,
-        )
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn stake_authorize<'a>(
-        pool_account_key: &Pubkey,
-        stake_account: AccountInfo<'a>,
-        stake_authority: AccountInfo<'a>,
-        bump_seed: u8,
-        new_stake_authority: &Pubkey,
-        clock: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Staker,
-            None,
-        );
-
-        invoke_signed(
-            &authorize_instruction,
-            &[
-                stake_account.clone(),
-                clock.clone(),
-                stake_authority.clone(),
-            ],
-            signers,
-        )?;
-
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Withdrawer,
-            None,
-        );
-        invoke_signed(
-            &authorize_instruction,
-            &[stake_account, clock, stake_authority],
-            signers,
-        )
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn stake_withdraw<'a>(
-        pool_account_key: &Pubkey,
-        stake_account: AccountInfo<'a>,
-        stake_authority: AccountInfo<'a>,
-        bump_seed: u8,
-        destination_account: AccountInfo<'a>,
-        clock: AccountInfo<'a>,
-        stake_history: AccountInfo<'a>,
-        lamports: u64,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        let withdraw_instruction = stake::instruction::withdraw(
-            stake_account.key,
-            stake_authority.key,
-            destination_account.key,
-            lamports,
-            None,
-        );
-
-        invoke_signed(
-            &withdraw_instruction,
-            &[
-                stake_account,
-                destination_account,
-                clock,
-                stake_history,
-                stake_authority,
-            ],
-            signers,
-        )
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn token_mint_to<'a>(
-        pool_account_key: &Pubkey,
-        token_program: AccountInfo<'a>,
-        mint: AccountInfo<'a>,
-        destination: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        bump_seed: u8,
-        amount: u64,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_MINT_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        let ix = spl_token::instruction::mint_to(
-            token_program.key,
-            mint.key,
-            destination.key,
-            authority.key,
-            &[],
-            amount,
-        )?;
-
-        invoke_signed(&ix, &[mint, destination, authority], signers)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn token_burn<'a>(
-        pool_account_key: &Pubkey,
-        token_program: AccountInfo<'a>,
-        burn_account: AccountInfo<'a>,
-        mint: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        bump_seed: u8,
-        amount: u64,
-    ) -> Result<(), ProgramError> {
-        let authority_seeds = &[
-            POOL_MINT_AUTHORITY_PREFIX,
-            pool_account_key.as_ref(),
-            &[bump_seed],
-        ];
-        let signers = &[&authority_seeds[..]];
-
-        let ix = spl_token::instruction::burn(
-            token_program.key,
-            burn_account.key,
-            mint.key,
-            authority.key,
-            &[],
-            amount,
-        )?;
-
-        invoke_signed(&ix, &[burn_account, mint, authority], signers)
-    }
-
-    fn process_initialize_pool(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let vote_account_info = next_account_info(account_info_iter)?;
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_stake_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let pool_stake_authority_info = next_account_info(account_info_iter)?;
-        let pool_mint_authority_info = next_account_info(account_info_iter)?;
-        let rent_info = next_account_info(account_info_iter)?;
-        let rent = &Rent::from_account_info(rent_info)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_vote_account(vote_account_info)?;
-        let pool_bump_seed = check_pool_address(program_id, vote_account_info.key, pool_info.key)?;
-        let stake_bump_seed =
-            check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
-        let mint_bump_seed =
-            check_pool_mint_address(program_id, pool_info.key, pool_mint_info.key)?;
-        let stake_authority_bump_seed = check_pool_stake_authority_address(
-            program_id,
-            pool_info.key,
-            pool_stake_authority_info.key,
-        )?;
-        let mint_authority_bump_seed = check_pool_mint_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mint_authority_info.key,
-        )?;
-        check_system_program(system_program_info.key)?;
-        check_token_program(token_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-
-        let pool_seeds = &[
-            POOL_PREFIX,
-            vote_account_info.key.as_ref(),
-            &[pool_bump_seed],
-        ];
-        let pool_signers = &[&pool_seeds[..]];
-
-        let stake_seeds = &[
-            POOL_STAKE_PREFIX,
-            pool_info.key.as_ref(),
-            &[stake_bump_seed],
-        ];
-        let stake_signers = &[&stake_seeds[..]];
-
-        let mint_seeds = &[POOL_MINT_PREFIX, pool_info.key.as_ref(), &[mint_bump_seed]];
-        let mint_signers = &[&mint_seeds[..]];
-
-        let stake_authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[stake_authority_bump_seed],
-        ];
-        let stake_authority_signers = &[&stake_authority_seeds[..]];
-
-        let mint_authority_seeds = &[
-            POOL_MINT_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[mint_authority_bump_seed],
-        ];
-        let mint_authority_signers = &[&mint_authority_seeds[..]];
-
-        // create the pool. user has already transferred in rent
-        let pool_space = get_packed_len::<SinglePool>();
-        if !rent.is_exempt(pool_info.lamports(), pool_space) {
-            return Err(SinglePoolError::WrongRentAmount.into());
-        }
-        if pool_info.data_len() != 0 {
-            return Err(SinglePoolError::PoolAlreadyInitialized.into());
-        }
-
-        invoke_signed(
-            &system_instruction::allocate(pool_info.key, pool_space as u64),
-            &[pool_info.clone()],
-            pool_signers,
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(pool_info.key, program_id),
-            &[pool_info.clone()],
-            pool_signers,
-        )?;
-
-        let mut pool = try_from_slice_unchecked::<SinglePool>(&pool_info.data.borrow())?;
-        pool.account_type = SinglePoolAccountType::Pool;
-        pool.vote_account_address = *vote_account_info.key;
-        borsh::to_writer(&mut pool_info.data.borrow_mut()[..], &pool)?;
-
-        // create the pool mint. user has already transferred in rent
-        let mint_space = spl_token::state::Mint::LEN;
-
-        invoke_signed(
-            &system_instruction::allocate(pool_mint_info.key, mint_space as u64),
-            &[pool_mint_info.clone()],
-            mint_signers,
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(pool_mint_info.key, token_program_info.key),
-            &[pool_mint_info.clone()],
-            mint_signers,
-        )?;
-
-        invoke_signed(
-            &spl_token::instruction::initialize_mint2(
-                token_program_info.key,
-                pool_mint_info.key,
-                pool_mint_authority_info.key,
-                None,
-                MINT_DECIMALS,
-            )?,
-            &[pool_mint_info.clone()],
-            mint_authority_signers,
-        )?;
-
-        // create the pool stake account. user has already transferred in rent plus at
-        // least the minimum
-        let minimum_delegation = minimum_delegation()?;
-        let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-        let stake_rent_plus_initial = rent
-            .minimum_balance(stake_space)
-            .saturating_add(minimum_delegation);
-
-        if pool_stake_info.lamports() < stake_rent_plus_initial {
-            return Err(SinglePoolError::WrongRentAmount.into());
-        }
-
-        let authorized = stake::state::Authorized::auto(pool_stake_authority_info.key);
-
-        invoke_signed(
-            &system_instruction::allocate(pool_stake_info.key, stake_space as u64),
-            &[pool_stake_info.clone()],
-            stake_signers,
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(pool_stake_info.key, stake_program_info.key),
-            &[pool_stake_info.clone()],
-            stake_signers,
-        )?;
-
-        invoke_signed(
-            &stake::instruction::initialize_checked(pool_stake_info.key, &authorized),
-            &[
-                pool_stake_info.clone(),
-                rent_info.clone(),
-                pool_stake_authority_info.clone(),
-                pool_stake_authority_info.clone(),
-            ],
-            stake_authority_signers,
-        )?;
-
-        // delegate stake so it activates
-        invoke_signed(
-            &stake::instruction::delegate_stake(
-                pool_stake_info.key,
-                pool_stake_authority_info.key,
-                vote_account_info.key,
-            ),
-            &[
-                pool_stake_info.clone(),
-                vote_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-                stake_config_info.clone(),
-                pool_stake_authority_info.clone(),
-            ],
-            stake_authority_signers,
-        )?;
-
-        Ok(())
-    }
-
-    fn process_reactivate_pool_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let vote_account_info = next_account_info(account_info_iter)?;
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_stake_info = next_account_info(account_info_iter)?;
-        let pool_stake_authority_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_vote_account(vote_account_info)?;
-        check_pool_address(program_id, vote_account_info.key, pool_info.key)?;
-
-        SinglePool::from_account_info(pool_info, program_id)?;
-
-        check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
-        let stake_authority_bump_seed = check_pool_stake_authority_address(
-            program_id,
-            pool_info.key,
-            pool_stake_authority_info.key,
-        )?;
-        check_stake_program(stake_program_info.key)?;
-
-        let (_, pool_stake_state) = get_stake_state(pool_stake_info)?;
-        if pool_stake_state.delegation.deactivation_epoch > clock.epoch {
-            return Err(SinglePoolError::WrongStakeStake.into());
-        }
-
-        let stake_authority_seeds = &[
-            POOL_STAKE_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[stake_authority_bump_seed],
-        ];
-        let stake_authority_signers = &[&stake_authority_seeds[..]];
-
-        // delegate stake so it activates
-        invoke_signed(
-            &stake::instruction::delegate_stake(
-                pool_stake_info.key,
-                pool_stake_authority_info.key,
-                vote_account_info.key,
-            ),
-            &[
-                pool_stake_info.clone(),
-                vote_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-                stake_config_info.clone(),
-                pool_stake_authority_info.clone(),
-            ],
-            stake_authority_signers,
-        )?;
-
-        Ok(())
-    }
-
-    fn process_deposit_stake(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_stake_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let pool_stake_authority_info = next_account_info(account_info_iter)?;
-        let pool_mint_authority_info = next_account_info(account_info_iter)?;
-        let user_stake_info = next_account_info(account_info_iter)?;
-        let user_token_account_info = next_account_info(account_info_iter)?;
-        let user_lamport_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        SinglePool::from_account_info(pool_info, program_id)?;
-
-        check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
-        let stake_authority_bump_seed = check_pool_stake_authority_address(
-            program_id,
-            pool_info.key,
-            pool_stake_authority_info.key,
-        )?;
-        let mint_authority_bump_seed = check_pool_mint_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mint_authority_info.key,
-        )?;
-        check_pool_mint_address(program_id, pool_info.key, pool_mint_info.key)?;
-        check_token_program(token_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-
-        if pool_stake_info.key == user_stake_info.key {
-            return Err(SinglePoolError::InvalidPoolStakeAccountUsage.into());
-        }
-
-        let minimum_delegation = minimum_delegation()?;
-
-        let (_, pool_stake_state) = get_stake_state(pool_stake_info)?;
-        let pre_pool_stake = pool_stake_state
-            .delegation
-            .stake
-            .saturating_sub(minimum_delegation);
-        msg!("Available stake pre merge {}", pre_pool_stake);
-
-        // user can deposit active stake into an active pool or inactive stake into an
-        // activating pool
-        let (user_stake_meta, user_stake_state) = get_stake_state(user_stake_info)?;
-        if user_stake_meta.authorized
-            != stake::state::Authorized::auto(pool_stake_authority_info.key)
-            || is_stake_active_without_history(&pool_stake_state, clock.epoch)
-                != is_stake_active_without_history(&user_stake_state, clock.epoch)
-        {
-            return Err(SinglePoolError::WrongStakeStake.into());
-        }
-
-        // merge the user stake account, which is preauthed to us, into the pool stake
-        // account this merge succeeding implicitly validates authority/lockup
-        // of the user stake account
-        Self::stake_merge(
-            pool_info.key,
-            user_stake_info.clone(),
-            pool_stake_authority_info.clone(),
-            stake_authority_bump_seed,
-            pool_stake_info.clone(),
-            clock_info.clone(),
-            stake_history_info.clone(),
-        )?;
-
-        let (pool_stake_meta, pool_stake_state) = get_stake_state(pool_stake_info)?;
-        let post_pool_stake = pool_stake_state
-            .delegation
-            .stake
-            .saturating_sub(minimum_delegation);
-        let post_pool_lamports = pool_stake_info.lamports();
-        msg!("Available stake post merge {}", post_pool_stake);
-
-        // stake lamports added, as a stake difference
-        let stake_added = post_pool_stake
-            .checked_sub(pre_pool_stake)
-            .ok_or(SinglePoolError::ArithmeticOverflow)?;
-
-        // we calculate absolute rather than relative to deposit amount to allow
-        // claiming lamports mistakenly transferred in
-        let excess_lamports = post_pool_lamports
-            .checked_sub(pool_stake_state.delegation.stake)
-            .and_then(|amount| amount.checked_sub(pool_stake_meta.rent_exempt_reserve))
-            .ok_or(SinglePoolError::ArithmeticOverflow)?;
-
-        // sanity check: the user stake account is empty
-        if user_stake_info.lamports() != 0 {
-            return Err(SinglePoolError::UnexpectedMathError.into());
-        }
-
-        let token_supply = {
-            let pool_mint_data = pool_mint_info.try_borrow_data()?;
-            let pool_mint = Mint::unpack_from_slice(&pool_mint_data)?;
-            pool_mint.supply
-        };
-
-        // deposit amount is determined off stake because we return excess rent
-        let new_pool_tokens = calculate_deposit_amount(token_supply, pre_pool_stake, stake_added)
-            .ok_or(SinglePoolError::UnexpectedMathError)?;
-
-        if new_pool_tokens == 0 {
-            return Err(SinglePoolError::DepositTooSmall.into());
-        }
-
-        // mint tokens to the user corresponding to their stake deposit
-        Self::token_mint_to(
-            pool_info.key,
-            token_program_info.clone(),
-            pool_mint_info.clone(),
-            user_token_account_info.clone(),
-            pool_mint_authority_info.clone(),
-            mint_authority_bump_seed,
-            new_pool_tokens,
-        )?;
-
-        // return the lamports their stake account previously held for rent-exemption
-        if excess_lamports > 0 {
-            Self::stake_withdraw(
-                pool_info.key,
-                pool_stake_info.clone(),
-                pool_stake_authority_info.clone(),
-                stake_authority_bump_seed,
-                user_lamport_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-                excess_lamports,
-            )?;
-        }
-
-        Ok(())
-    }
-
-    fn process_withdraw_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        user_stake_authority: &Pubkey,
-        token_amount: u64,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_stake_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let pool_stake_authority_info = next_account_info(account_info_iter)?;
-        let pool_mint_authority_info = next_account_info(account_info_iter)?;
-        let user_stake_info = next_account_info(account_info_iter)?;
-        let user_token_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        SinglePool::from_account_info(pool_info, program_id)?;
-
-        check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
-        let stake_authority_bump_seed = check_pool_stake_authority_address(
-            program_id,
-            pool_info.key,
-            pool_stake_authority_info.key,
-        )?;
-        let mint_authority_bump_seed = check_pool_mint_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mint_authority_info.key,
-        )?;
-        check_pool_mint_address(program_id, pool_info.key, pool_mint_info.key)?;
-        check_token_program(token_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-
-        if pool_stake_info.key == user_stake_info.key {
-            return Err(SinglePoolError::InvalidPoolStakeAccountUsage.into());
-        }
-
-        let minimum_delegation = minimum_delegation()?;
-
-        let pre_pool_stake = get_stake_amount(pool_stake_info)?.saturating_sub(minimum_delegation);
-        msg!("Available stake pre split {}", pre_pool_stake);
-
-        let token_supply = {
-            let pool_mint_data = pool_mint_info.try_borrow_data()?;
-            let pool_mint = Mint::unpack_from_slice(&pool_mint_data)?;
-            pool_mint.supply
-        };
-
-        // withdraw amount is determined off stake just like deposit amount
-        let withdraw_stake = calculate_withdraw_amount(token_supply, pre_pool_stake, token_amount)
-            .ok_or(SinglePoolError::UnexpectedMathError)?;
-
-        if withdraw_stake == 0 {
-            return Err(SinglePoolError::WithdrawalTooSmall.into());
-        }
-
-        // the second case should never be true, but its best to be sure
-        if withdraw_stake > pre_pool_stake || withdraw_stake == pool_stake_info.lamports() {
-            return Err(SinglePoolError::WithdrawalTooLarge.into());
-        }
-
-        // burn user tokens corresponding to the amount of stake they wish to withdraw
-        Self::token_burn(
-            pool_info.key,
-            token_program_info.clone(),
-            user_token_account_info.clone(),
-            pool_mint_info.clone(),
-            pool_mint_authority_info.clone(),
-            mint_authority_bump_seed,
-            token_amount,
-        )?;
-
-        // split stake into a blank stake account the user has created for this purpose
-        Self::stake_split(
-            pool_info.key,
-            pool_stake_info.clone(),
-            pool_stake_authority_info.clone(),
-            stake_authority_bump_seed,
-            withdraw_stake,
-            user_stake_info.clone(),
-        )?;
-
-        // assign both authorities on the new stake account to the user
-        Self::stake_authorize(
-            pool_info.key,
-            user_stake_info.clone(),
-            pool_stake_authority_info.clone(),
-            stake_authority_bump_seed,
-            user_stake_authority,
-            clock_info.clone(),
-        )?;
-
-        let post_pool_stake = get_stake_amount(pool_stake_info)?.saturating_sub(minimum_delegation);
-        msg!("Available stake post split {}", post_pool_stake);
-
-        Ok(())
-    }
-
-    fn process_create_pool_token_metadata(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let pool_mint_authority_info = next_account_info(account_info_iter)?;
-        let pool_mpl_authority_info = next_account_info(account_info_iter)?;
-        let payer_info = next_account_info(account_info_iter)?;
-        let metadata_info = next_account_info(account_info_iter)?;
-        let mpl_token_metadata_program_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-
-        let pool = SinglePool::from_account_info(pool_info, program_id)?;
-
-        let mint_authority_bump_seed = check_pool_mint_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mint_authority_info.key,
-        )?;
-        let mpl_authority_bump_seed = check_pool_mpl_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mpl_authority_info.key,
-        )?;
-        check_pool_mint_address(program_id, pool_info.key, pool_mint_info.key)?;
-        check_system_program(system_program_info.key)?;
-        check_account_owner(payer_info, &system_program::id())?;
-        check_mpl_metadata_program(mpl_token_metadata_program_info.key)?;
-        check_mpl_metadata_account_address(metadata_info.key, pool_mint_info.key)?;
-
-        if !payer_info.is_signer {
-            msg!("Payer did not sign metadata creation");
-            return Err(SinglePoolError::SignatureMissing.into());
-        }
-
-        let vote_address_str = pool.vote_account_address.to_string();
-        let token_name = format!("SPL Single Pool {}", &vote_address_str[0..15]);
-        let token_symbol = format!("st{}", &vote_address_str[0..7]);
-
-        let new_metadata_instruction = create_metadata_accounts_v3(
-            *mpl_token_metadata_program_info.key,
-            *metadata_info.key,
-            *pool_mint_info.key,
-            *pool_mint_authority_info.key,
-            *payer_info.key,
-            *pool_mpl_authority_info.key,
-            token_name,
-            token_symbol,
-            "".to_string(),
-        );
-
-        let mint_authority_seeds = &[
-            POOL_MINT_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[mint_authority_bump_seed],
-        ];
-        let mpl_authority_seeds = &[
-            POOL_MPL_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[mpl_authority_bump_seed],
-        ];
-        let signers = &[&mint_authority_seeds[..], &mpl_authority_seeds[..]];
-
-        invoke_signed(
-            &new_metadata_instruction,
-            &[
-                metadata_info.clone(),
-                pool_mint_info.clone(),
-                pool_mint_authority_info.clone(),
-                payer_info.clone(),
-                pool_mpl_authority_info.clone(),
-                system_program_info.clone(),
-            ],
-            signers,
-        )?;
-
-        Ok(())
-    }
-
-    fn process_update_pool_token_metadata(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        name: String,
-        symbol: String,
-        uri: String,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let vote_account_info = next_account_info(account_info_iter)?;
-        let pool_info = next_account_info(account_info_iter)?;
-        let pool_mpl_authority_info = next_account_info(account_info_iter)?;
-        let authorized_withdrawer_info = next_account_info(account_info_iter)?;
-        let metadata_info = next_account_info(account_info_iter)?;
-        let mpl_token_metadata_program_info = next_account_info(account_info_iter)?;
-
-        check_vote_account(vote_account_info)?;
-        check_pool_address(program_id, vote_account_info.key, pool_info.key)?;
-
-        let pool = SinglePool::from_account_info(pool_info, program_id)?;
-        if pool.vote_account_address != *vote_account_info.key {
-            return Err(SinglePoolError::InvalidPoolAccount.into());
-        }
-
-        let mpl_authority_bump_seed = check_pool_mpl_authority_address(
-            program_id,
-            pool_info.key,
-            pool_mpl_authority_info.key,
-        )?;
-        let pool_mint_address = crate::find_pool_mint_address(program_id, pool_info.key);
-        check_mpl_metadata_program(mpl_token_metadata_program_info.key)?;
-        check_mpl_metadata_account_address(metadata_info.key, &pool_mint_address)?;
-
-        // we use authorized_withdrawer to authenticate the caller controls the vote
-        // account this is safer than using an authorized_voter since those keys
-        // live hot and validator-operators we spoke with indicated this would
-        // be their preference as well
-        let vote_account_data = &vote_account_info.try_borrow_data()?;
-        let vote_account_withdrawer = vote_account_data
-            .get(VOTE_STATE_AUTHORIZED_WITHDRAWER_START..VOTE_STATE_AUTHORIZED_WITHDRAWER_END)
-            .and_then(|x| Pubkey::try_from(x).ok())
-            .ok_or(SinglePoolError::UnparseableVoteAccount)?;
-
-        if *authorized_withdrawer_info.key != vote_account_withdrawer {
-            msg!("Vote account authorized withdrawer does not match the account provided.");
-            return Err(SinglePoolError::InvalidMetadataSigner.into());
-        }
-
-        if !authorized_withdrawer_info.is_signer {
-            msg!("Vote account authorized withdrawer did not sign metadata update.");
-            return Err(SinglePoolError::SignatureMissing.into());
-        }
-
-        let update_metadata_accounts_instruction = update_metadata_accounts_v2(
-            *mpl_token_metadata_program_info.key,
-            *metadata_info.key,
-            *pool_mpl_authority_info.key,
-            None,
-            Some(DataV2 {
-                name,
-                symbol,
-                uri,
-                seller_fee_basis_points: 0,
-                creators: None,
-                collection: None,
-                uses: None,
-            }),
-            None,
-            Some(true),
-        );
-
-        let mpl_authority_seeds = &[
-            POOL_MPL_AUTHORITY_PREFIX,
-            pool_info.key.as_ref(),
-            &[mpl_authority_bump_seed],
-        ];
-        let signers = &[&mpl_authority_seeds[..]];
-
-        invoke_signed(
-            &update_metadata_accounts_instruction,
-            &[metadata_info.clone(), pool_mpl_authority_info.clone()],
-            signers,
-        )?;
-
-        Ok(())
-    }
-
-    /// Processes [Instruction](enum.Instruction.html).
-    pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-        let instruction = SinglePoolInstruction::try_from_slice(input)?;
-        match instruction {
-            SinglePoolInstruction::InitializePool => {
-                msg!("Instruction: InitializePool");
-                Self::process_initialize_pool(program_id, accounts)
-            }
-            SinglePoolInstruction::ReactivatePoolStake => {
-                msg!("Instruction: ReactivatePoolStake");
-                Self::process_reactivate_pool_stake(program_id, accounts)
-            }
-            SinglePoolInstruction::DepositStake => {
-                msg!("Instruction: DepositStake");
-                Self::process_deposit_stake(program_id, accounts)
-            }
-            SinglePoolInstruction::WithdrawStake {
-                user_stake_authority,
-                token_amount,
-            } => {
-                msg!("Instruction: WithdrawStake");
-                Self::process_withdraw_stake(
-                    program_id,
-                    accounts,
-                    &user_stake_authority,
-                    token_amount,
-                )
-            }
-            SinglePoolInstruction::CreateTokenMetadata => {
-                msg!("Instruction: CreateTokenMetadata");
-                Self::process_create_pool_token_metadata(program_id, accounts)
-            }
-            SinglePoolInstruction::UpdateTokenMetadata { name, symbol, uri } => {
-                msg!("Instruction: UpdateTokenMetadata");
-                Self::process_update_pool_token_metadata(program_id, accounts, name, symbol, uri)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-#[allow(clippy::arithmetic_side_effects)]
-mod tests {
-    use {
-        super::*,
-        approx::assert_relative_eq,
-        rand::{
-            distributions::{Distribution, Uniform},
-            rngs::StdRng,
-            seq::{IteratorRandom, SliceRandom},
-            Rng, SeedableRng,
-        },
-        std::collections::BTreeMap,
-        test_case::test_case,
-    };
-
-    // approximately 6%/yr assuking 146 epochs
-    const INFLATION_BASE_RATE: f64 = 0.0004;
-
-    #[derive(Clone, Debug, Default)]
-    struct PoolState {
-        pub token_supply: u64,
-        pub total_stake: u64,
-        pub user_token_balances: BTreeMap<Pubkey, u64>,
-    }
-    impl PoolState {
-        // deposits a given amount of stake and returns the equivalent tokens on success
-        // note this is written as unsugared do-notation, so *any* failure returns None
-        // otherwise returns the value produced by its respective calculate function
-        #[rustfmt::skip]
-        pub fn deposit(&mut self, user_pubkey: &Pubkey, stake_to_deposit: u64) -> Option<u64> {
-            calculate_deposit_amount(self.token_supply, self.total_stake, stake_to_deposit)
-                .and_then(|tokens_to_mint| self.token_supply.checked_add(tokens_to_mint)
-                .and_then(|new_token_supply| self.total_stake.checked_add(stake_to_deposit)
-                .and_then(|new_total_stake| self.user_token_balances.remove(user_pubkey).or(Some(0))
-                .and_then(|old_user_token_balance| old_user_token_balance.checked_add(tokens_to_mint)
-                .map(|new_user_token_balance| {
-                    self.token_supply = new_token_supply;
-                    self.total_stake = new_total_stake;
-                    let _ = self.user_token_balances.insert(*user_pubkey, new_user_token_balance);
-                    tokens_to_mint
-            })))))
-        }
-
-        // burns a given amount of tokens and returns the equivalent stake on success
-        // note this is written as unsugared do-notation, so *any* failure returns None
-        // otherwise returns the value produced by its respective calculate function
-        #[rustfmt::skip]
-        pub fn withdraw(&mut self, user_pubkey: &Pubkey, tokens_to_burn: u64) -> Option<u64> {
-            calculate_withdraw_amount(self.token_supply, self.total_stake, tokens_to_burn)
-                .and_then(|stake_to_withdraw| self.token_supply.checked_sub(tokens_to_burn)
-                .and_then(|new_token_supply| self.total_stake.checked_sub(stake_to_withdraw)
-                .and_then(|new_total_stake| self.user_token_balances.remove(user_pubkey)
-                .and_then(|old_user_token_balance| old_user_token_balance.checked_sub(tokens_to_burn)
-                .map(|new_user_token_balance| {
-                    self.token_supply = new_token_supply;
-                    self.total_stake = new_total_stake;
-                    let _ = self.user_token_balances.insert(*user_pubkey, new_user_token_balance);
-                    stake_to_withdraw
-            })))))
-        }
-
-        // adds an arbitrary amount of stake, as if inflation rewards were granted
-        pub fn reward(&mut self, reward_amount: u64) {
-            self.total_stake = self.total_stake.checked_add(reward_amount).unwrap();
-        }
-
-        // get the token balance for a user
-        pub fn tokens(&self, user_pubkey: &Pubkey) -> u64 {
-            *self.user_token_balances.get(user_pubkey).unwrap_or(&0)
-        }
-
-        // get the amount of stake that belongs to a user
-        pub fn stake(&self, user_pubkey: &Pubkey) -> u64 {
-            let tokens = self.tokens(user_pubkey);
-            if tokens > 0 {
-                u64::try_from(tokens as u128 * self.total_stake as u128 / self.token_supply as u128)
-                    .unwrap()
-            } else {
-                0
-            }
-        }
-
-        // get the share of the pool that belongs to a user, as a float between 0 and 1
-        pub fn share(&self, user_pubkey: &Pubkey) -> f64 {
-            let tokens = self.tokens(user_pubkey);
-            if tokens > 0 {
-                tokens as f64 / self.token_supply as f64
-            } else {
-                0.0
-            }
-        }
-    }
-
-    // this deterministically tests basic behavior of calculate_deposit_amount and
-    // calculate_withdraw_amount
-    #[test]
-    fn simple_deposit_withdraw() {
-        let mut pool = PoolState::default();
-        let alice = Pubkey::new_unique();
-        let bob = Pubkey::new_unique();
-        let chad = Pubkey::new_unique();
-
-        // first deposit. alice now has 250
-        pool.deposit(&alice, 250).unwrap();
-        assert_eq!(pool.tokens(&alice), 250);
-        assert_eq!(pool.token_supply, 250);
-        assert_eq!(pool.total_stake, 250);
-
-        // second deposit. bob now has 750
-        pool.deposit(&bob, 750).unwrap();
-        assert_eq!(pool.tokens(&bob), 750);
-        assert_eq!(pool.token_supply, 1000);
-        assert_eq!(pool.total_stake, 1000);
-
-        // alice controls 25% of the pool and bob controls 75%. rewards should accrue
-        // likewise use nice even numbers, we can test fiddly stuff in the
-        // stochastic cases
-        assert_relative_eq!(pool.share(&alice), 0.25);
-        assert_relative_eq!(pool.share(&bob), 0.75);
-        pool.reward(1000);
-        assert_eq!(pool.stake(&alice), pool.tokens(&alice) * 2);
-        assert_eq!(pool.stake(&bob), pool.tokens(&bob) * 2);
-        assert_relative_eq!(pool.share(&alice), 0.25);
-        assert_relative_eq!(pool.share(&bob), 0.75);
-
-        // alice harvests rewards, reducing her share of the *previous* pool size to
-        // 12.5% but because the pool itself has shrunk to 87.5%, its actually
-        // more like 14.3% luckily chad deposits immediately after to make our
-        // math easier
-        let stake_removed = pool.withdraw(&alice, 125).unwrap();
-        pool.deposit(&chad, 250).unwrap();
-        assert_eq!(stake_removed, 250);
-        assert_relative_eq!(pool.share(&alice), 0.125);
-        assert_relative_eq!(pool.share(&bob), 0.75);
-
-        // bob and chad exit the pool
-        let stake_removed = pool.withdraw(&bob, 750).unwrap();
-        assert_eq!(stake_removed, 1500);
-        assert_relative_eq!(pool.share(&bob), 0.0);
-        pool.withdraw(&chad, 125).unwrap();
-        assert_relative_eq!(pool.share(&alice), 1.0);
-    }
-
-    // this stochastically tests calculate_deposit_amount and
-    // calculate_withdraw_amount the objective is specifically to ensure that
-    // the math does not fail on any combination of state changes the no_minimum
-    // case is to account for a future where small deposits are possible through
-    // multistake
-    #[test_case(rand::random(), false, false; "no_rewards")]
-    #[test_case(rand::random(), true, false; "with_rewards")]
-    #[test_case(rand::random(), true, true; "no_minimum")]
-    fn random_deposit_withdraw(seed: u64, with_rewards: bool, no_minimum: bool) {
-        println!(
-            "TEST SEED: {}. edit the test case to pass this value if needed to debug failures",
-            seed
-        );
-        let mut prng = rand::rngs::StdRng::seed_from_u64(seed);
-
-        // deposit_range is the range of typical deposits within minimum_delegation
-        // minnow_range is under the minimum for cases where we test that
-        // op_range is how we roll whether to deposit, withdraw, or reward
-        // std_range is a standard probability
-        let deposit_range = Uniform::from(LAMPORTS_PER_SOL..LAMPORTS_PER_SOL * 1000);
-        let minnow_range = Uniform::from(1..LAMPORTS_PER_SOL);
-        let op_range = Uniform::from(if with_rewards { 0.0..1.0 } else { 0.0..0.65 });
-        let std_range = Uniform::from(0.0..1.0);
-
-        let deposit_amount = |prng: &mut StdRng| {
-            if no_minimum && prng.gen_bool(0.2) {
-                minnow_range.sample(prng)
-            } else {
-                deposit_range.sample(prng)
-            }
-        };
-
-        // run everything a number of times to get a good sample
-        for _ in 0..100 {
-            // PoolState tracks all outstanding tokens and the total combined stake
-            // there is no reasonable way to track "deposited stake" because reward accrual
-            // makes this concept incoherent a token corresponds to a
-            // percentage, not a stake value
-            let mut pool = PoolState::default();
-
-            // generate between 1 and 100 users and have ~half of them deposit
-            // note for most of these tests we adhere to the minimum delegation
-            // one of the thing we want to see is deposit size being many ooms larger than
-            // reward size
-            let mut users = vec![];
-            let user_count: usize = prng.gen_range(1..=100);
-            for _ in 0..user_count {
-                let user = Pubkey::new_unique();
-
-                if prng.gen_bool(0.5) {
-                    pool.deposit(&user, deposit_amount(&mut prng)).unwrap();
-                }
-
-                users.push(user);
-            }
-
-            // now we do a set of arbitrary operations and confirm invariants hold
-            // we underweight withdraw a little bit to lessen the chances we random walk to
-            // an empty pool
-            for _ in 0..1000 {
-                match op_range.sample(&mut prng) {
-                    // deposit a random amount of stake for tokens with a random user
-                    // check their stake, tokens, and share increase by the expected amount
-                    n if n <= 0.35 => {
-                        let user = users.choose(&mut prng).unwrap();
-                        let prev_share = pool.share(user);
-                        let prev_stake = pool.stake(user);
-                        let prev_token_supply = pool.token_supply;
-                        let prev_total_stake = pool.total_stake;
-
-                        let stake_deposited = deposit_amount(&mut prng);
-                        let tokens_minted = pool.deposit(user, stake_deposited).unwrap();
-
-                        // stake increased by exactly the deposit amount
-                        assert_eq!(pool.total_stake - prev_total_stake, stake_deposited);
-
-                        // calculated stake fraction is within 2 lamps of deposit amount
-                        assert!(
-                            (pool.stake(user) as i64 - prev_stake as i64 - stake_deposited as i64)
-                                .abs()
-                                <= 2
-                        );
-
-                        // tokens increased by exactly the mint amount
-                        assert_eq!(pool.token_supply - prev_token_supply, tokens_minted);
-
-                        // tokens per supply increased with stake per total
-                        if prev_total_stake > 0 {
-                            assert_relative_eq!(
-                                pool.share(user) - prev_share,
-                                pool.stake(user) as f64 / pool.total_stake as f64
-                                    - prev_stake as f64 / prev_total_stake as f64,
-                                epsilon = 1e-6
-                            );
-                        }
-                    }
-
-                    // burn a random amount of tokens from a random user with outstanding deposits
-                    // check their stake, tokens, and share decrease by the expected amount
-                    n if n > 0.35 && n <= 0.65 => {
-                        if let Some(user) = users
-                            .iter()
-                            .filter(|user| pool.tokens(user) > 0)
-                            .choose(&mut prng)
-                        {
-                            let prev_tokens = pool.tokens(user);
-                            let prev_share = pool.share(user);
-                            let prev_stake = pool.stake(user);
-                            let prev_token_supply = pool.token_supply;
-                            let prev_total_stake = pool.total_stake;
-
-                            let tokens_burned = if std_range.sample(&mut prng) <= 0.1 {
-                                prev_tokens
-                            } else {
-                                prng.gen_range(0..prev_tokens)
-                            };
-                            let stake_received = pool.withdraw(user, tokens_burned).unwrap();
-
-                            // stake decreased by exactly the withdraw amount
-                            assert_eq!(prev_total_stake - pool.total_stake, stake_received);
-
-                            // calculated stake fraction is within 2 lamps of withdraw amount
-                            assert!(
-                                (prev_stake as i64
-                                    - pool.stake(user) as i64
-                                    - stake_received as i64)
-                                    .abs()
-                                    <= 2
-                            );
-
-                            // tokens decreased by the burn amount
-                            assert_eq!(prev_token_supply - pool.token_supply, tokens_burned);
-
-                            // tokens per supply decreased with stake per total
-                            if pool.total_stake > 0 {
-                                assert_relative_eq!(
-                                    prev_share - pool.share(user),
-                                    prev_stake as f64 / prev_total_stake as f64
-                                        - pool.stake(user) as f64 / pool.total_stake as f64,
-                                    epsilon = 1e-6
-                                );
-                            }
-                        };
-                    }
-
-                    // run a single epoch worth of rewards
-                    // check all user shares stay the same and stakes increase by the expected
-                    // amount
-                    _ => {
-                        assert!(with_rewards);
-
-                        let prev_shares_stakes = users
-                            .iter()
-                            .map(|user| (user, pool.share(user), pool.stake(user)))
-                            .filter(|(_, _, stake)| stake > &0)
-                            .collect::<Vec<_>>();
-
-                        pool.reward((pool.total_stake as f64 * INFLATION_BASE_RATE) as u64);
-
-                        for (user, prev_share, prev_stake) in prev_shares_stakes {
-                            // shares are the same before and after
-                            assert_eq!(pool.share(user), prev_share);
-
-                            let curr_stake = pool.stake(user);
-                            let stake_share = prev_stake as f64 * INFLATION_BASE_RATE;
-                            let stake_diff = (curr_stake - prev_stake) as f64;
-
-                            // stake increase is within 2 lamps when calculated as a difference or a
-                            // percentage
-                            assert!((stake_share - stake_diff).abs() <= 2.0);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/single-pool/program/src/state.rs b/single-pool/program/src/state.rs
deleted file mode 100644
index 0c58b87f6d0..00000000000
--- a/single-pool/program/src/state.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-//! State transition types
-
-use {
-    crate::{error::SinglePoolError, find_pool_address},
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        account_info::AccountInfo, borsh1::try_from_slice_unchecked, program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-};
-
-/// Single-Validator Stake Pool account type
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub enum SinglePoolAccountType {
-    /// Uninitialized account
-    #[default]
-    Uninitialized,
-    /// Main pool account
-    Pool,
-}
-
-/// Single-Validator Stake Pool account, used to derive all PDAs
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub struct SinglePool {
-    /// Pool account type, reserved for future compat
-    pub account_type: SinglePoolAccountType,
-    /// The vote account this pool is mapped to
-    pub vote_account_address: Pubkey,
-}
-impl SinglePool {
-    /// Create a SinglePool struct from its account info
-    pub fn from_account_info(
-        account_info: &AccountInfo,
-        program_id: &Pubkey,
-    ) -> Result<Self, ProgramError> {
-        // pool is allocated and owned by this program
-        if account_info.data_len() == 0 || account_info.owner != program_id {
-            return Err(SinglePoolError::InvalidPoolAccount.into());
-        }
-
-        let pool = try_from_slice_unchecked::<SinglePool>(&account_info.data.borrow())?;
-
-        // pool is well-typed
-        if pool.account_type != SinglePoolAccountType::Pool {
-            return Err(SinglePoolError::InvalidPoolAccount.into());
-        }
-
-        // pool vote account address is properly configured. in practice this is
-        // irrefutable because the pool is initialized from the address that
-        // derives it, and never modified
-        if *account_info.key != find_pool_address(program_id, &pool.vote_account_address) {
-            return Err(SinglePoolError::InvalidPoolAccount.into());
-        }
-
-        Ok(pool)
-    }
-}
diff --git a/single-pool/program/tests/accounts.rs b/single-pool/program/tests/accounts.rs
deleted file mode 100644
index d6276be2639..00000000000
--- a/single-pool/program/tests/accounts.rs
+++ /dev/null
@@ -1,304 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::Instruction, program_error::ProgramError, pubkey::Pubkey, signature::Signer,
-        stake, system_program, transaction::Transaction,
-    },
-    spl_single_pool::{
-        error::SinglePoolError,
-        id,
-        instruction::{self, SinglePoolInstruction},
-    },
-    test_case::test_case,
-};
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-enum TestMode {
-    Initialize,
-    Deposit,
-    Withdraw,
-}
-
-// build a full transaction for initialize, deposit, and withdraw
-// this is used to test knocking out individual accounts, for the sake of
-// confirming the pubkeys are checked
-async fn build_instructions(
-    context: &mut ProgramTestContext,
-    accounts: &SinglePoolAccounts,
-    test_mode: TestMode,
-) -> (Vec<Instruction>, usize) {
-    let initialize_instructions = if test_mode == TestMode::Initialize {
-        let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-        context.warp_to_slot(slot).unwrap();
-
-        create_vote(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &accounts.validator,
-            &accounts.voter.pubkey(),
-            &accounts.withdrawer.pubkey(),
-            &accounts.vote_account,
-        )
-        .await;
-
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &accounts.alice.pubkey(),
-            USER_STARTING_LAMPORTS,
-        )
-        .await;
-
-        let rent = context.banks_client.get_rent().await.unwrap();
-        let minimum_delegation = get_pool_minimum_delegation(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-
-        instruction::initialize(
-            &id(),
-            &accounts.vote_account.pubkey(),
-            &accounts.alice.pubkey(),
-            &rent,
-            minimum_delegation,
-        )
-    } else {
-        accounts
-            .initialize_for_deposit(context, TEST_STAKE_AMOUNT, None)
-            .await;
-        advance_epoch(context).await;
-
-        vec![]
-    };
-
-    let deposit_instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-
-    let withdraw_instructions = if test_mode == TestMode::Withdraw {
-        let transaction = Transaction::new_signed_with_payer(
-            &deposit_instructions,
-            Some(&accounts.alice.pubkey()),
-            &[&accounts.alice],
-            context.last_blockhash,
-        );
-
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-
-        create_blank_stake_account(
-            &mut context.banks_client,
-            &context.payer,
-            &accounts.alice,
-            &context.last_blockhash,
-            &accounts.alice_stake,
-        )
-        .await;
-
-        instruction::withdraw(
-            &id(),
-            &accounts.pool,
-            &accounts.alice_stake.pubkey(),
-            &accounts.alice.pubkey(),
-            &accounts.alice_token,
-            &accounts.alice.pubkey(),
-            get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
-        )
-    } else {
-        vec![]
-    };
-
-    let (instructions, i) = match test_mode {
-        TestMode::Initialize => (initialize_instructions, 3),
-        TestMode::Deposit => (deposit_instructions, 2),
-        TestMode::Withdraw => (withdraw_instructions, 1),
-    };
-
-    // guard against instructions moving with code changes
-    assert_eq!(instructions[i].program_id, id());
-
-    (instructions, i)
-}
-
-// test that account addresses are checked properly
-#[test_case(TestMode::Initialize; "initialize")]
-#[test_case(TestMode::Deposit; "deposit")]
-#[test_case(TestMode::Withdraw; "withdraw")]
-#[tokio::test]
-async fn fail_account_checks(test_mode: TestMode) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    let (instructions, i) = build_instructions(&mut context, &accounts, test_mode).await;
-
-    for j in 0..instructions[i].accounts.len() {
-        let mut instructions = instructions.clone();
-        let instruction_account = &mut instructions[i].accounts[j];
-
-        // wallet address can be arbitrary
-        if instruction_account.pubkey == accounts.alice.pubkey() {
-            continue;
-        }
-
-        let prev_pubkey = instruction_account.pubkey;
-        instruction_account.pubkey = Pubkey::new_unique();
-
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&accounts.alice.pubkey()),
-            &[&accounts.alice],
-            context.last_blockhash,
-        );
-
-        // random addresses should error always otherwise
-        let e = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err();
-
-        // these ones we can also make sure we hit the explicit check, before we use it
-        if prev_pubkey == accounts.pool {
-            check_error(e, SinglePoolError::InvalidPoolAccount)
-        } else if prev_pubkey == accounts.stake_account {
-            check_error(e, SinglePoolError::InvalidPoolStakeAccount)
-        } else if prev_pubkey == accounts.stake_authority {
-            check_error(e, SinglePoolError::InvalidPoolStakeAuthority)
-        } else if prev_pubkey == accounts.mint_authority {
-            check_error(e, SinglePoolError::InvalidPoolMintAuthority)
-        } else if prev_pubkey == accounts.mpl_authority {
-            check_error(e, SinglePoolError::InvalidPoolMplAuthority)
-        } else if prev_pubkey == accounts.mint {
-            check_error(e, SinglePoolError::InvalidPoolMint)
-        } else if [system_program::id(), spl_token::id(), stake::program::id()]
-            .contains(&prev_pubkey)
-        {
-            check_error(e, ProgramError::IncorrectProgramId)
-        }
-    }
-}
-
-// make an individual instruction for all program instructions
-// the match is just so this will error if new instructions are added
-// if you are reading this because of that error, add the case to the
-// `consistent_account_order` test!!!
-fn make_basic_instruction(
-    accounts: &SinglePoolAccounts,
-    instruction_type: SinglePoolInstruction,
-) -> Instruction {
-    match instruction_type {
-        SinglePoolInstruction::InitializePool => {
-            instruction::initialize_pool(&id(), &accounts.vote_account.pubkey())
-        }
-        SinglePoolInstruction::ReactivatePoolStake => {
-            instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey())
-        }
-        SinglePoolInstruction::DepositStake => instruction::deposit_stake(
-            &id(),
-            &accounts.pool,
-            &Pubkey::default(),
-            &Pubkey::default(),
-            &Pubkey::default(),
-        ),
-        SinglePoolInstruction::WithdrawStake { .. } => instruction::withdraw_stake(
-            &id(),
-            &accounts.pool,
-            &Pubkey::default(),
-            &Pubkey::default(),
-            &Pubkey::default(),
-            0,
-        ),
-        SinglePoolInstruction::CreateTokenMetadata => {
-            instruction::create_token_metadata(&id(), &accounts.pool, &Pubkey::default())
-        }
-        SinglePoolInstruction::UpdateTokenMetadata { .. } => instruction::update_token_metadata(
-            &id(),
-            &accounts.vote_account.pubkey(),
-            &accounts.withdrawer.pubkey(),
-            "".to_string(),
-            "".to_string(),
-            "".to_string(),
-        ),
-    }
-}
-
-// advanced technology
-fn is_sorted<T>(data: &[T]) -> bool
-where
-    T: Ord,
-{
-    data.windows(2).all(|w| w[0] <= w[1])
-}
-
-// check that major accounts always show up in the same order, to spare
-// developer confusion
-#[test]
-fn consistent_account_order() {
-    let accounts = SinglePoolAccounts::default();
-
-    let ordering = vec![
-        accounts.vote_account.pubkey(),
-        accounts.pool,
-        accounts.stake_account,
-        accounts.mint,
-        accounts.stake_authority,
-        accounts.mint_authority,
-        accounts.mpl_authority,
-    ];
-
-    let instructions = vec![
-        make_basic_instruction(&accounts, SinglePoolInstruction::InitializePool),
-        make_basic_instruction(&accounts, SinglePoolInstruction::ReactivatePoolStake),
-        make_basic_instruction(&accounts, SinglePoolInstruction::DepositStake),
-        make_basic_instruction(
-            &accounts,
-            SinglePoolInstruction::WithdrawStake {
-                user_stake_authority: Pubkey::default(),
-                token_amount: 0,
-            },
-        ),
-        make_basic_instruction(&accounts, SinglePoolInstruction::CreateTokenMetadata),
-        make_basic_instruction(
-            &accounts,
-            SinglePoolInstruction::UpdateTokenMetadata {
-                name: "".to_string(),
-                symbol: "".to_string(),
-                uri: "".to_string(),
-            },
-        ),
-    ];
-
-    for instruction in instructions {
-        let mut indexes = vec![];
-
-        for target in &ordering {
-            if let Some(i) = instruction
-                .accounts
-                .iter()
-                .position(|meta| meta.pubkey == *target)
-            {
-                indexes.push(i);
-            }
-        }
-
-        assert!(is_sorted(&indexes));
-    }
-}
diff --git a/single-pool/program/tests/create_pool_token_metadata.rs b/single-pool/program/tests/create_pool_token_metadata.rs
deleted file mode 100644
index 930c0f4f7cc..00000000000
--- a/single-pool/program/tests/create_pool_token_metadata.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer,
-        system_instruction::SystemError, transaction::Transaction,
-    },
-    spl_single_pool::{id, instruction},
-};
-
-fn assert_metadata(vote_account: &Pubkey, metadata: &Metadata) {
-    let vote_address_str = vote_account.to_string();
-    let name = format!("SPL Single Pool {}", &vote_address_str[0..15]);
-    let symbol = format!("st{}", &vote_address_str[0..7]);
-
-    assert!(metadata.name.starts_with(&name));
-    assert!(metadata.symbol.starts_with(&symbol));
-}
-
-#[tokio::test]
-async fn success() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    let metadata = get_metadata_account(&mut context.banks_client, &accounts.mint).await;
-    assert_metadata(&accounts.vote_account.pubkey(), &metadata);
-}
-
-#[tokio::test]
-async fn fail_double_init() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-    refresh_blockhash(&mut context).await;
-
-    let instruction =
-        instruction::create_token_metadata(&id(), &accounts.pool, &context.payer.pubkey());
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error::<InstructionError>(e, SystemError::AccountAlreadyInUse.into());
-}
diff --git a/single-pool/program/tests/deposit.rs b/single-pool/program/tests/deposit.rs
deleted file mode 100644
index 6fe15a2cc48..00000000000
--- a/single-pool/program/tests/deposit.rs
+++ /dev/null
@@ -1,477 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        signature::Signer,
-        signer::keypair::Keypair,
-        stake::state::{Authorized, Lockup},
-        transaction::Transaction,
-    },
-    spl_associated_token_account as atoken,
-    spl_single_pool::{
-        error::SinglePoolError, find_default_deposit_account_address, id, instruction,
-    },
-    test_case::test_case,
-};
-
-#[test_case(true, 0, false, false, false; "activated::minimum_disabled")]
-#[test_case(true, 0, false, false, true; "activated::minimum_disabled::small")]
-#[test_case(true, 0, false, true, false; "activated::minimum_enabled")]
-#[test_case(false, 0, false, false, false; "activating::minimum_disabled")]
-#[test_case(false, 0, false, false, true; "activating::minimum_disabled::small")]
-#[test_case(false, 0, false, true, false; "activating::minimum_enabled")]
-#[test_case(true, 100_000, false, false, false; "activated::extra")]
-#[test_case(false, 100_000, false, false, false; "activating::extra")]
-#[test_case(true, 0, true, false, false; "activated::second")]
-#[test_case(false, 0, true, false, false; "activating::second")]
-#[tokio::test]
-async fn success(
-    activate: bool,
-    extra_lamports: u64,
-    prior_deposit: bool,
-    enable_minimum_delegation: bool,
-    small_deposit: bool,
-) {
-    let mut context = program_test(enable_minimum_delegation)
-        .start_with_context()
-        .await;
-    let accounts = SinglePoolAccounts::default();
-    accounts
-        .initialize_for_deposit(
-            &mut context,
-            if small_deposit { 1 } else { TEST_STAKE_AMOUNT },
-            if prior_deposit {
-                Some(TEST_STAKE_AMOUNT * 10)
-            } else {
-                None
-            },
-        )
-        .await;
-
-    if activate {
-        advance_epoch(&mut context).await;
-    }
-
-    if prior_deposit {
-        let instructions = instruction::deposit(
-            &id(),
-            &accounts.pool,
-            &accounts.bob_stake.pubkey(),
-            &accounts.bob_token,
-            &accounts.bob.pubkey(),
-            &accounts.bob.pubkey(),
-        );
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &accounts.bob],
-            context.last_blockhash,
-        );
-
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-    }
-
-    let (_, alice_stake_before_deposit, stake_lamports) =
-        get_stake_account(&mut context.banks_client, &accounts.alice_stake.pubkey()).await;
-    let alice_stake_before_deposit = alice_stake_before_deposit.unwrap().delegation.stake;
-
-    let (_, pool_stake_before, pool_lamports_before) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let pool_stake_before = pool_stake_before.unwrap().delegation.stake;
-
-    if extra_lamports > 0 {
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &accounts.stake_account,
-            extra_lamports,
-        )
-        .await;
-    }
-
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let wallet_lamports_after_deposit =
-        get_account(&mut context.banks_client, &accounts.alice.pubkey())
-            .await
-            .lamports;
-
-    let (pool_meta_after, pool_stake_after, pool_lamports_after) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let pool_stake_after = pool_stake_after.unwrap().delegation.stake;
-
-    // when active, the depositor gets their rent back
-    // but when activating, its just added to stake
-    let expected_deposit = if activate {
-        alice_stake_before_deposit
-    } else {
-        stake_lamports
-    };
-
-    // deposit stake account is closed
-    assert!(context
-        .banks_client
-        .get_account(accounts.alice_stake.pubkey())
-        .await
-        .expect("get_account")
-        .is_none());
-
-    // entire stake has moved to pool
-    assert_eq!(pool_stake_before + expected_deposit, pool_stake_after);
-
-    // pool only gained stake
-    assert_eq!(pool_lamports_after, pool_lamports_before + expected_deposit);
-    assert_eq!(
-        pool_lamports_after,
-        pool_stake_before + expected_deposit + pool_meta_after.rent_exempt_reserve,
-    );
-
-    // alice got her rent back if active, or everything otherwise
-    // and if someone sent lamports to the stake account, the next depositor gets
-    // them
-    assert_eq!(
-        wallet_lamports_after_deposit,
-        USER_STARTING_LAMPORTS - expected_deposit + extra_lamports,
-    );
-
-    // alice got tokens. no rewards have been paid so tokens correspond to stake 1:1
-    assert_eq!(
-        get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
-        expected_deposit,
-    );
-}
-
-#[test_case(true, false, false; "activated::minimum_disabled")]
-#[test_case(true, false, true; "activated::minimum_disabled::small")]
-#[test_case(true, true, false; "activated::minimum_enabled")]
-#[test_case(false, false, false; "activating::minimum_disabled")]
-#[test_case(false, false, true; "activating::minimum_disabled::small")]
-#[test_case(false, true, false; "activating::minimum_enabled")]
-#[tokio::test]
-async fn success_with_seed(activate: bool, enable_minimum_delegation: bool, small_deposit: bool) {
-    let mut context = program_test(enable_minimum_delegation)
-        .start_with_context()
-        .await;
-    let accounts = SinglePoolAccounts::default();
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let minimum_stake = accounts.initialize(&mut context).await;
-    let alice_default_stake =
-        find_default_deposit_account_address(&accounts.pool, &accounts.alice.pubkey());
-
-    let instructions = instruction::create_and_delegate_user_stake(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &accounts.alice.pubkey(),
-        &rent,
-        if small_deposit { 1 } else { minimum_stake },
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    if activate {
-        advance_epoch(&mut context).await;
-    }
-
-    let (_, alice_stake_before_deposit, stake_lamports) =
-        get_stake_account(&mut context.banks_client, &alice_default_stake).await;
-    let alice_stake_before_deposit = alice_stake_before_deposit.unwrap().delegation.stake;
-
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &alice_default_stake,
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let wallet_lamports_after_deposit =
-        get_account(&mut context.banks_client, &accounts.alice.pubkey())
-            .await
-            .lamports;
-
-    let (_, pool_stake_after, _) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let pool_stake_after = pool_stake_after.unwrap().delegation.stake;
-
-    let expected_deposit = if activate {
-        alice_stake_before_deposit
-    } else {
-        stake_lamports
-    };
-
-    // deposit stake account is closed
-    assert!(context
-        .banks_client
-        .get_account(alice_default_stake)
-        .await
-        .expect("get_account")
-        .is_none());
-
-    // stake moved to pool
-    assert_eq!(minimum_stake + expected_deposit, pool_stake_after);
-
-    // alice got her rent back if active, or everything otherwise
-    assert_eq!(
-        wallet_lamports_after_deposit,
-        USER_STARTING_LAMPORTS - expected_deposit
-    );
-
-    // alice got tokens. no rewards have been paid so tokens correspond to stake 1:1
-    assert_eq!(
-        get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
-        expected_deposit,
-    );
-}
-
-#[test_case(true; "activated")]
-#[test_case(false; "activating")]
-#[tokio::test]
-async fn fail_uninitialized(activate: bool) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    let stake_account = Keypair::new();
-
-    let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    create_vote(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &accounts.validator,
-        &accounts.voter.pubkey(),
-        &accounts.withdrawer.pubkey(),
-        &accounts.vote_account,
-    )
-    .await;
-
-    let token_account =
-        atoken::get_associated_token_address(&context.payer.pubkey(), &accounts.mint);
-
-    create_independent_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_account,
-        &Authorized::auto(&context.payer.pubkey()),
-        &Lockup::default(),
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_account.pubkey(),
-        &context.payer,
-        &accounts.vote_account.pubkey(),
-    )
-    .await;
-
-    if activate {
-        advance_epoch(&mut context).await;
-    }
-
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &stake_account.pubkey(),
-        &token_account,
-        &context.payer.pubkey(),
-        &context.payer.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::InvalidPoolAccount);
-}
-
-#[test_case(true, true; "activated::automorph")]
-#[test_case(false, true; "activating::automorph")]
-#[test_case(true, false; "activated::unauth")]
-#[test_case(false, false; "activating::unauth")]
-#[tokio::test]
-async fn fail_bad_account(activate: bool, automorph: bool) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts
-        .initialize_for_deposit(&mut context, TEST_STAKE_AMOUNT, None)
-        .await;
-
-    let instruction = instruction::deposit_stake(
-        &id(),
-        &accounts.pool,
-        &if automorph {
-            accounts.stake_account
-        } else {
-            accounts.alice_stake.pubkey()
-        },
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&accounts.alice.pubkey()),
-        &[&accounts.alice],
-        context.last_blockhash,
-    );
-
-    if activate {
-        advance_epoch(&mut context).await;
-    }
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-
-    if automorph {
-        check_error(e, SinglePoolError::InvalidPoolStakeAccountUsage);
-    } else {
-        check_error(e, SinglePoolError::WrongStakeStake);
-    }
-}
-
-#[test_case(true; "pool_active")]
-#[test_case(false; "user_active")]
-#[tokio::test]
-async fn fail_activation_mismatch(pool_first: bool) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-
-    let minimum_delegation = get_pool_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    create_vote(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &accounts.validator,
-        &accounts.voter.pubkey(),
-        &accounts.withdrawer.pubkey(),
-        &accounts.vote_account,
-    )
-    .await;
-
-    if pool_first {
-        accounts.initialize(&mut context).await;
-        advance_epoch(&mut context).await;
-    }
-
-    create_independent_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.payer,
-        &context.last_blockhash,
-        &accounts.alice_stake,
-        &Authorized::auto(&accounts.alice.pubkey()),
-        &Lockup::default(),
-        minimum_delegation,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice,
-        &accounts.vote_account.pubkey(),
-    )
-    .await;
-
-    if !pool_first {
-        advance_epoch(&mut context).await;
-        accounts.initialize(&mut context).await;
-    }
-
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&accounts.alice.pubkey()),
-        &[&accounts.alice],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::WrongStakeStake);
-}
diff --git a/single-pool/program/tests/fixtures/mpl_token_metadata.so b/single-pool/program/tests/fixtures/mpl_token_metadata.so
deleted file mode 120000
index 43816797329..00000000000
--- a/single-pool/program/tests/fixtures/mpl_token_metadata.so
+++ /dev/null
@@ -1 +0,0 @@
-../../../../stake-pool/program/tests/fixtures/mpl_token_metadata.so
\ No newline at end of file
diff --git a/single-pool/program/tests/helpers/mod.rs b/single-pool/program/tests/helpers/mod.rs
deleted file mode 100644
index a56a072c291..00000000000
--- a/single-pool/program/tests/helpers/mod.rs
+++ /dev/null
@@ -1,450 +0,0 @@
-#![allow(dead_code)] // needed because cargo doesn't understand test usage
-
-use {
-    solana_program_test::*,
-    solana_sdk::{
-        account::Account as SolanaAccount,
-        feature_set::stake_raise_minimum_delegation_to_1_sol,
-        hash::Hash,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        stake::state::{Authorized, Lockup},
-        system_instruction, system_program,
-        transaction::{Transaction, TransactionError},
-    },
-    solana_vote_program::{
-        self, vote_instruction,
-        vote_state::{VoteInit, VoteState},
-    },
-    spl_associated_token_account as atoken,
-    spl_single_pool::{
-        find_pool_address, find_pool_mint_address, find_pool_mint_authority_address,
-        find_pool_mpl_authority_address, find_pool_stake_address,
-        find_pool_stake_authority_address, id, inline_mpl_token_metadata, instruction,
-        processor::Processor,
-    },
-};
-
-pub mod token;
-pub use token::*;
-
-pub mod stake;
-pub use stake::*;
-
-pub const FIRST_NORMAL_EPOCH: u64 = 15;
-pub const USER_STARTING_LAMPORTS: u64 = 10_000_000_000_000; // 10k sol
-
-pub fn program_test(enable_minimum_delegation: bool) -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-
-    program_test.add_program("mpl_token_metadata", inline_mpl_token_metadata::id(), None);
-    program_test.add_program("spl_single_pool", id(), processor!(Processor::process));
-    program_test.prefer_bpf(false);
-
-    if !enable_minimum_delegation {
-        program_test.deactivate_feature(stake_raise_minimum_delegation_to_1_sol::id());
-    }
-
-    program_test
-}
-
-#[derive(Debug, PartialEq)]
-pub struct SinglePoolAccounts {
-    pub validator: Keypair,
-    pub voter: Keypair,
-    pub withdrawer: Keypair,
-    pub vote_account: Keypair,
-    pub pool: Pubkey,
-    pub stake_account: Pubkey,
-    pub mint: Pubkey,
-    pub stake_authority: Pubkey,
-    pub mint_authority: Pubkey,
-    pub mpl_authority: Pubkey,
-    pub alice: Keypair,
-    pub bob: Keypair,
-    pub alice_stake: Keypair,
-    pub bob_stake: Keypair,
-    pub alice_token: Pubkey,
-    pub bob_token: Pubkey,
-    pub token_program_id: Pubkey,
-}
-impl SinglePoolAccounts {
-    // does everything in initialize_for_deposit plus performs the deposit(s) and
-    // creates blank account(s) optionally advances to activation before the
-    // deposit
-    pub async fn initialize_for_withdraw(
-        &self,
-        context: &mut ProgramTestContext,
-        alice_amount: u64,
-        maybe_bob_amount: Option<u64>,
-        activate: bool,
-    ) -> u64 {
-        let minimum_delegation = self
-            .initialize_for_deposit(context, alice_amount, maybe_bob_amount)
-            .await;
-
-        if activate {
-            advance_epoch(context).await;
-        }
-
-        let instructions = instruction::deposit(
-            &id(),
-            &self.pool,
-            &self.alice_stake.pubkey(),
-            &self.alice_token,
-            &self.alice.pubkey(),
-            &self.alice.pubkey(),
-        );
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &self.alice],
-            context.last_blockhash,
-        );
-
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-
-        create_blank_stake_account(
-            &mut context.banks_client,
-            &context.payer,
-            &self.alice,
-            &context.last_blockhash,
-            &self.alice_stake,
-        )
-        .await;
-
-        if maybe_bob_amount.is_some() {
-            let instructions = instruction::deposit(
-                &id(),
-                &self.pool,
-                &self.bob_stake.pubkey(),
-                &self.bob_token,
-                &self.bob.pubkey(),
-                &self.bob.pubkey(),
-            );
-            let transaction = Transaction::new_signed_with_payer(
-                &instructions,
-                Some(&context.payer.pubkey()),
-                &[&context.payer, &self.bob],
-                context.last_blockhash,
-            );
-
-            context
-                .banks_client
-                .process_transaction(transaction)
-                .await
-                .unwrap();
-
-            create_blank_stake_account(
-                &mut context.banks_client,
-                &context.payer,
-                &self.bob,
-                &context.last_blockhash,
-                &self.bob_stake,
-            )
-            .await;
-        }
-
-        minimum_delegation
-    }
-
-    // does everything in initialize plus creates/delegates one or both stake
-    // accounts for our users note this does not advance time, so everything is
-    // in an activating state
-    pub async fn initialize_for_deposit(
-        &self,
-        context: &mut ProgramTestContext,
-        alice_amount: u64,
-        maybe_bob_amount: Option<u64>,
-    ) -> u64 {
-        let minimum_delegation = self.initialize(context).await;
-
-        create_independent_stake_account(
-            &mut context.banks_client,
-            &context.payer,
-            &self.alice,
-            &context.last_blockhash,
-            &self.alice_stake,
-            &Authorized::auto(&self.alice.pubkey()),
-            &Lockup::default(),
-            alice_amount,
-        )
-        .await;
-
-        delegate_stake_account(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &self.alice_stake.pubkey(),
-            &self.alice,
-            &self.vote_account.pubkey(),
-        )
-        .await;
-
-        if let Some(bob_amount) = maybe_bob_amount {
-            create_independent_stake_account(
-                &mut context.banks_client,
-                &context.payer,
-                &self.bob,
-                &context.last_blockhash,
-                &self.bob_stake,
-                &Authorized::auto(&self.bob.pubkey()),
-                &Lockup::default(),
-                bob_amount,
-            )
-            .await;
-
-            delegate_stake_account(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-                &self.bob_stake.pubkey(),
-                &self.bob,
-                &self.vote_account.pubkey(),
-            )
-            .await;
-        };
-
-        minimum_delegation
-    }
-
-    // creates a vote account and stake pool for it. also sets up two users with sol
-    // and token accounts note this leaves the pool in an activating state.
-    // caller can advance to next epoch if they please
-    pub async fn initialize(&self, context: &mut ProgramTestContext) -> u64 {
-        let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-        context.warp_to_slot(slot).unwrap();
-
-        create_vote(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &self.validator,
-            &self.voter.pubkey(),
-            &self.withdrawer.pubkey(),
-            &self.vote_account,
-        )
-        .await;
-
-        let rent = context.banks_client.get_rent().await.unwrap();
-        let minimum_delegation = get_pool_minimum_delegation(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-
-        let instructions = instruction::initialize(
-            &id(),
-            &self.vote_account.pubkey(),
-            &context.payer.pubkey(),
-            &rent,
-            minimum_delegation,
-        );
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&context.payer.pubkey()),
-            &[&context.payer],
-            context.last_blockhash,
-        );
-
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &self.alice.pubkey(),
-            USER_STARTING_LAMPORTS,
-        )
-        .await;
-
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &self.bob.pubkey(),
-            USER_STARTING_LAMPORTS,
-        )
-        .await;
-
-        create_ata(
-            &mut context.banks_client,
-            &context.payer,
-            &self.alice.pubkey(),
-            &context.last_blockhash,
-            &self.mint,
-        )
-        .await;
-
-        create_ata(
-            &mut context.banks_client,
-            &context.payer,
-            &self.bob.pubkey(),
-            &context.last_blockhash,
-            &self.mint,
-        )
-        .await;
-
-        minimum_delegation
-    }
-}
-impl Default for SinglePoolAccounts {
-    fn default() -> Self {
-        let vote_account = Keypair::new();
-        let alice = Keypair::new();
-        let bob = Keypair::new();
-        let pool = find_pool_address(&id(), &vote_account.pubkey());
-        let mint = find_pool_mint_address(&id(), &pool);
-
-        Self {
-            validator: Keypair::new(),
-            voter: Keypair::new(),
-            withdrawer: Keypair::new(),
-            stake_account: find_pool_stake_address(&id(), &pool),
-            pool,
-            mint,
-            stake_authority: find_pool_stake_authority_address(&id(), &pool),
-            mint_authority: find_pool_mint_authority_address(&id(), &pool),
-            mpl_authority: find_pool_mpl_authority_address(&id(), &pool),
-            vote_account,
-            alice_stake: Keypair::new(),
-            bob_stake: Keypair::new(),
-            alice_token: atoken::get_associated_token_address(&alice.pubkey(), &mint),
-            bob_token: atoken::get_associated_token_address(&bob.pubkey(), &mint),
-            alice,
-            bob,
-            token_program_id: spl_token::id(),
-        }
-    }
-}
-
-pub async fn refresh_blockhash(context: &mut ProgramTestContext) {
-    context.last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-}
-
-pub async fn advance_epoch(context: &mut ProgramTestContext) {
-    let root_slot = context.banks_client.get_root_slot().await.unwrap();
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    context.warp_to_slot(root_slot + slots_per_epoch).unwrap();
-}
-
-pub async fn get_account(banks_client: &mut BanksClient, pubkey: &Pubkey) -> SolanaAccount {
-    banks_client
-        .get_account(*pubkey)
-        .await
-        .expect("client error")
-        .expect("account not found")
-}
-
-pub async fn create_vote(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    validator: &Keypair,
-    voter: &Pubkey,
-    withdrawer: &Pubkey,
-    vote_account: &Keypair,
-) {
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_voter = rent.minimum_balance(VoteState::size_of());
-
-    let mut instructions = vec![system_instruction::create_account(
-        &payer.pubkey(),
-        &validator.pubkey(),
-        rent.minimum_balance(0),
-        0,
-        &system_program::id(),
-    )];
-    instructions.append(&mut vote_instruction::create_account_with_config(
-        &payer.pubkey(),
-        &vote_account.pubkey(),
-        &VoteInit {
-            node_pubkey: validator.pubkey(),
-            authorized_voter: *voter,
-            authorized_withdrawer: *withdrawer,
-            ..VoteInit::default()
-        },
-        rent_voter,
-        vote_instruction::CreateVoteAccountConfig {
-            space: VoteState::size_of() as u64,
-            ..Default::default()
-        },
-    ));
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &[validator, vote_account, payer],
-        *recent_blockhash,
-    );
-
-    // ignore errors for idempotency
-    let _ = banks_client.process_transaction(transaction).await;
-}
-
-pub async fn transfer(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    recipient: &Pubkey,
-    amount: u64,
-) {
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::transfer(
-            &payer.pubkey(),
-            recipient,
-            amount,
-        )],
-        Some(&payer.pubkey()),
-        &[payer],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub fn check_error<T: Clone + std::fmt::Debug>(got: BanksClientError, expected: T)
-where
-    ProgramError: TryFrom<T>,
-{
-    // banks error -> transaction error -> instruction error -> program error
-    let got_p: ProgramError = if let TransactionError::InstructionError(_, e) = got.unwrap() {
-        e.try_into().unwrap()
-    } else {
-        panic!(
-            "couldn't convert {:?} to ProgramError (expected {:?})",
-            got, expected
-        );
-    };
-
-    // this silly thing is because we can guarantee From<T> has a Debug for T
-    // but TryFrom<T> produces Result<T, E> and E may not have Debug. so we cant
-    // call unwrap also we use TryFrom because we have to go `instruction
-    // error-> program error` because StakeError impls the former but not the
-    // latter... and that conversion is merely surjective........
-    // infomercial lady: "if only there were a better way!"
-    let expected_p = match expected.clone().try_into() {
-        Ok(v) => v,
-        Err(_) => panic!("could not unwrap {:?}", expected),
-    };
-
-    if got_p != expected_p {
-        panic!(
-            "error comparison failed!\n\nGOT: {:#?} / ({:?})\n\nEXPECTED: {:#?} / ({:?})\n\n",
-            got, got_p, expected, expected_p
-        );
-    }
-}
diff --git a/single-pool/program/tests/helpers/stake.rs b/single-pool/program/tests/helpers/stake.rs
deleted file mode 100644
index 73047eeb310..00000000000
--- a/single-pool/program/tests/helpers/stake.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-#![allow(dead_code)] // needed because cargo doesn't understand test usage
-
-use {
-    crate::get_account,
-    bincode::deserialize,
-    solana_program_test::BanksClient,
-    solana_sdk::{
-        hash::Hash,
-        native_token::LAMPORTS_PER_SOL,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        stake::{
-            self,
-            state::{Meta, Stake, StakeStateV2},
-        },
-        system_instruction,
-        transaction::Transaction,
-    },
-    std::convert::TryInto,
-};
-
-pub const TEST_STAKE_AMOUNT: u64 = 10_000_000_000; // 10 sol
-
-pub async fn get_stake_account(
-    banks_client: &mut BanksClient,
-    pubkey: &Pubkey,
-) -> (Meta, Option<Stake>, u64) {
-    let stake_account = get_account(banks_client, pubkey).await;
-    let lamports = stake_account.lamports;
-    match deserialize::<StakeStateV2>(&stake_account.data).unwrap() {
-        StakeStateV2::Initialized(meta) => (meta, None, lamports),
-        StakeStateV2::Stake(meta, stake, _) => (meta, Some(stake), lamports),
-        _ => unimplemented!(),
-    }
-}
-
-pub async fn get_stake_account_rent(banks_client: &mut BanksClient) -> u64 {
-    let rent = banks_client.get_rent().await.unwrap();
-    rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>())
-}
-
-pub async fn get_pool_minimum_delegation(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-) -> u64 {
-    let transaction = Transaction::new_signed_with_payer(
-        &[stake::instruction::get_minimum_delegation()],
-        Some(&payer.pubkey()),
-        &[payer],
-        *recent_blockhash,
-    );
-    let mut data = banks_client
-        .simulate_transaction(transaction)
-        .await
-        .unwrap()
-        .simulation_details
-        .unwrap()
-        .return_data
-        .unwrap()
-        .data;
-    data.resize(8, 0);
-    let stake_program_minimum = data.try_into().map(u64::from_le_bytes).unwrap();
-
-    std::cmp::max(stake_program_minimum, LAMPORTS_PER_SOL)
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn create_independent_stake_account(
-    banks_client: &mut BanksClient,
-    fee_payer: &Keypair,
-    rent_payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Keypair,
-    authorized: &stake::state::Authorized,
-    lockup: &stake::state::Lockup,
-    stake_amount: u64,
-) -> u64 {
-    let lamports = get_stake_account_rent(banks_client).await + stake_amount;
-    let transaction = Transaction::new_signed_with_payer(
-        &stake::instruction::create_account(
-            &rent_payer.pubkey(),
-            &stake.pubkey(),
-            authorized,
-            lockup,
-            lamports,
-        ),
-        Some(&fee_payer.pubkey()),
-        &[fee_payer, rent_payer, stake],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    lamports
-}
-
-pub async fn create_blank_stake_account(
-    banks_client: &mut BanksClient,
-    fee_payer: &Keypair,
-    rent_payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Keypair,
-) -> u64 {
-    let lamports = get_stake_account_rent(banks_client).await;
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &rent_payer.pubkey(),
-            &stake.pubkey(),
-            lamports,
-            std::mem::size_of::<stake::state::StakeStateV2>() as u64,
-            &stake::program::id(),
-        )],
-        Some(&fee_payer.pubkey()),
-        &[fee_payer, rent_payer, stake],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    lamports
-}
-
-pub async fn delegate_stake_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Pubkey,
-    authorized: &Keypair,
-    vote: &Pubkey,
-) {
-    let mut transaction = Transaction::new_with_payer(
-        &[stake::instruction::delegate_stake(
-            stake,
-            &authorized.pubkey(),
-            vote,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[payer, authorized], *recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-}
diff --git a/single-pool/program/tests/helpers/token.rs b/single-pool/program/tests/helpers/token.rs
deleted file mode 100644
index 582bd7ab6cd..00000000000
--- a/single-pool/program/tests/helpers/token.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-#![allow(dead_code)]
-
-use {
-    borsh::BorshDeserialize,
-    solana_program_test::BanksClient,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        hash::Hash,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
-    spl_associated_token_account as atoken,
-    spl_single_pool::inline_mpl_token_metadata::pda::find_metadata_account,
-    spl_token::state::{Account, Mint},
-};
-
-pub async fn create_ata(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    owner: &Pubkey,
-    recent_blockhash: &Hash,
-    pool_mint: &Pubkey,
-) {
-    let instruction = atoken::instruction::create_associated_token_account(
-        &payer.pubkey(),
-        owner,
-        pool_mint,
-        &spl_token::id(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[payer],
-        *recent_blockhash,
-    );
-
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub async fn get_token_balance(banks_client: &mut BanksClient, token: &Pubkey) -> u64 {
-    let token_account = banks_client.get_account(*token).await.unwrap().unwrap();
-    let account_info = Account::unpack_from_slice(&token_account.data).unwrap();
-    account_info.amount
-}
-
-pub async fn get_token_supply(banks_client: &mut BanksClient, mint: &Pubkey) -> u64 {
-    let mint_account = banks_client.get_account(*mint).await.unwrap().unwrap();
-    let account_info = Mint::unpack_from_slice(&mint_account.data).unwrap();
-    account_info.supply
-}
-
-#[derive(Clone, BorshDeserialize, Debug, PartialEq, Eq)]
-pub struct Metadata {
-    pub key: u8,
-    pub update_authority: Pubkey,
-    pub mint: Pubkey,
-    pub name: String,
-    pub symbol: String,
-    pub uri: String,
-    pub seller_fee_basis_points: u16,
-    pub creators: Option<Vec<u8>>,
-    pub primary_sale_happened: bool,
-    pub is_mutable: bool,
-}
-
-pub async fn get_metadata_account(banks_client: &mut BanksClient, token_mint: &Pubkey) -> Metadata {
-    let (token_metadata, _) = find_metadata_account(token_mint);
-    let token_metadata_account = banks_client
-        .get_account(token_metadata)
-        .await
-        .unwrap()
-        .unwrap();
-    try_from_slice_unchecked(token_metadata_account.data.as_slice()).unwrap()
-}
diff --git a/single-pool/program/tests/initialize.rs b/single-pool/program/tests/initialize.rs
deleted file mode 100644
index 88fddd89282..00000000000
--- a/single-pool/program/tests/initialize.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{program_pack::Pack, signature::Signer, stake, transaction::Transaction},
-    spl_single_pool::{error::SinglePoolError, id, instruction},
-    spl_token::state::Mint,
-    test_case::test_case,
-};
-
-#[test_case(true; "minimum_enabled")]
-#[test_case(false; "minimum_disabled")]
-#[tokio::test]
-async fn success(enable_minimum_delegation: bool) {
-    let mut context = program_test(enable_minimum_delegation)
-        .start_with_context()
-        .await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    // mint exists
-    let mint_account = get_account(&mut context.banks_client, &accounts.mint).await;
-    Mint::unpack_from_slice(&mint_account.data).unwrap();
-
-    // stake account exists
-    let stake_account = get_account(&mut context.banks_client, &accounts.stake_account).await;
-    assert_eq!(stake_account.owner, stake::program::id());
-}
-
-#[tokio::test]
-async fn fail_double_init() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    let minimum_delegation = accounts.initialize(&mut context).await;
-    refresh_blockhash(&mut context).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let instructions = instruction::initialize(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &context.payer.pubkey(),
-        &rent,
-        minimum_delegation,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::PoolAlreadyInitialized);
-}
-
-#[test_case(true; "minimum_enabled")]
-#[test_case(false; "minimum_disabled")]
-#[tokio::test]
-async fn fail_below_pool_minimum(enable_minimum_delegation: bool) {
-    let mut context = program_test(enable_minimum_delegation)
-        .start_with_context()
-        .await;
-    let accounts = SinglePoolAccounts::default();
-    let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    create_vote(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &accounts.validator,
-        &accounts.voter.pubkey(),
-        &accounts.withdrawer.pubkey(),
-        &accounts.vote_account,
-    )
-    .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let minimum_delegation = get_pool_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let instructions = instruction::initialize(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &context.payer.pubkey(),
-        &rent,
-        minimum_delegation - 1,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::WrongRentAmount);
-}
-
-// TODO test that init can succeed without mpl program
diff --git a/single-pool/program/tests/reactivate.rs b/single-pool/program/tests/reactivate.rs
deleted file mode 100644
index 2b43dfa3149..00000000000
--- a/single-pool/program/tests/reactivate.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        account::AccountSharedData,
-        signature::Signer,
-        stake::{
-            stake_flags::StakeFlags,
-            state::{Delegation, Stake, StakeStateV2},
-        },
-        transaction::Transaction,
-    },
-    spl_single_pool::{error::SinglePoolError, id, instruction},
-    test_case::test_case,
-};
-
-#[tokio::test]
-async fn success() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts
-        .initialize_for_deposit(&mut context, TEST_STAKE_AMOUNT, None)
-        .await;
-    advance_epoch(&mut context).await;
-
-    // deactivate the pool stake account
-    let (meta, stake, _) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let delegation = Delegation {
-        activation_epoch: 0,
-        deactivation_epoch: 0,
-        ..stake.unwrap().delegation
-    };
-    let mut account_data = vec![0; std::mem::size_of::<StakeStateV2>()];
-    bincode::serialize_into(
-        &mut account_data[..],
-        &StakeStateV2::Stake(
-            meta,
-            Stake {
-                delegation,
-                ..stake.unwrap()
-            },
-            StakeFlags::empty(),
-        ),
-    )
-    .unwrap();
-
-    let mut stake_account = get_account(&mut context.banks_client, &accounts.stake_account).await;
-    stake_account.data = account_data;
-    context.set_account(
-        &accounts.stake_account,
-        &AccountSharedData::from(stake_account),
-    );
-
-    // make sure deposit fails
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::WrongStakeStake);
-
-    // reactivate
-    let instruction = instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey());
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    advance_epoch(&mut context).await;
-
-    // deposit works again
-    let instructions = instruction::deposit(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        &accounts.alice.pubkey(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    assert!(context
-        .banks_client
-        .get_account(accounts.alice_stake.pubkey())
-        .await
-        .expect("get_account")
-        .is_none());
-}
-
-#[test_case(true; "activated")]
-#[test_case(false; "activating")]
-#[tokio::test]
-async fn fail_not_deactivated(activate: bool) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    if activate {
-        advance_epoch(&mut context).await;
-    }
-
-    let instruction = instruction::reactivate_pool_stake(&id(), &accounts.vote_account.pubkey());
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::WrongStakeStake);
-}
diff --git a/single-pool/program/tests/update_pool_token_metadata.rs b/single-pool/program/tests/update_pool_token_metadata.rs
deleted file mode 100644
index 6642af4b04e..00000000000
--- a/single-pool/program/tests/update_pool_token_metadata.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{signature::Signer, transaction::Transaction},
-    spl_single_pool::{error::SinglePoolError, id, instruction},
-    test_case::test_case,
-};
-
-const UPDATED_NAME: &str = "updated_name";
-const UPDATED_SYMBOL: &str = "USYM";
-const UPDATED_URI: &str = "updated_uri";
-
-#[tokio::test]
-async fn success_update_pool_token_metadata() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    let instruction = instruction::update_token_metadata(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &accounts.withdrawer.pubkey(),
-        UPDATED_NAME.to_string(),
-        UPDATED_SYMBOL.to_string(),
-        UPDATED_URI.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.withdrawer],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let metadata = get_metadata_account(&mut context.banks_client, &accounts.mint).await;
-
-    assert!(metadata.name.starts_with(UPDATED_NAME));
-    assert!(metadata.symbol.starts_with(UPDATED_SYMBOL));
-    assert!(metadata.uri.starts_with(UPDATED_URI));
-}
-
-#[tokio::test]
-async fn fail_no_signature() {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    let mut instruction = instruction::update_token_metadata(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &accounts.withdrawer.pubkey(),
-        UPDATED_NAME.to_string(),
-        UPDATED_SYMBOL.to_string(),
-        UPDATED_URI.to_string(),
-    );
-    assert_eq!(instruction.accounts[3].pubkey, accounts.withdrawer.pubkey());
-    instruction.accounts[3].is_signer = false;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::SignatureMissing);
-}
-
-enum BadWithdrawer {
-    Validator,
-    Voter,
-    VoteAccount,
-}
-
-#[test_case(BadWithdrawer::Validator; "validator")]
-#[test_case(BadWithdrawer::Voter; "voter")]
-#[test_case(BadWithdrawer::VoteAccount; "vote_account")]
-#[tokio::test]
-async fn fail_bad_withdrawer(withdrawer_type: BadWithdrawer) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts.initialize(&mut context).await;
-
-    let withdrawer = match withdrawer_type {
-        BadWithdrawer::Validator => &accounts.validator,
-        BadWithdrawer::Voter => &accounts.voter,
-        BadWithdrawer::VoteAccount => &accounts.vote_account,
-    };
-
-    let instruction = instruction::update_token_metadata(
-        &id(),
-        &accounts.vote_account.pubkey(),
-        &withdrawer.pubkey(),
-        UPDATED_NAME.to_string(),
-        UPDATED_SYMBOL.to_string(),
-        UPDATED_URI.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, withdrawer],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::InvalidMetadataSigner);
-}
diff --git a/single-pool/program/tests/withdraw.rs b/single-pool/program/tests/withdraw.rs
deleted file mode 100644
index 4619613b668..00000000000
--- a/single-pool/program/tests/withdraw.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{signature::Signer, transaction::Transaction},
-    spl_single_pool::{error::SinglePoolError, id, instruction},
-    test_case::test_case,
-};
-
-#[test_case(true, 0, false, false, false; "activated::minimum_disabled")]
-#[test_case(true, 0, false, false, true; "activated::minimum_disabled::small")]
-#[test_case(true, 0, false, true, false; "activated::minimum_enabled")]
-#[test_case(false, 0, false, false, false; "activating::minimum_disabled")]
-#[test_case(false, 0, false, false, true; "activating::minimum_disabled::small")]
-#[test_case(false, 0, false, true, false; "activating::minimum_enabled")]
-#[test_case(true, 100_000, false, false, false; "activated::extra")]
-#[test_case(false, 100_000, false, false, false; "activating::extra")]
-#[test_case(true, 0, true, false, false; "activated::second")]
-#[test_case(false, 0, true, false, false; "activating::second")]
-#[tokio::test]
-async fn success(
-    activate: bool,
-    extra_lamports: u64,
-    prior_deposit: bool,
-    enable_minimum_delegation: bool,
-    small_deposit: bool,
-) {
-    let mut context = program_test(enable_minimum_delegation)
-        .start_with_context()
-        .await;
-    let accounts = SinglePoolAccounts::default();
-
-    let amount_deposited = if small_deposit { 1 } else { TEST_STAKE_AMOUNT };
-
-    let minimum_delegation = accounts
-        .initialize_for_withdraw(
-            &mut context,
-            amount_deposited,
-            if prior_deposit {
-                Some(TEST_STAKE_AMOUNT * 10)
-            } else {
-                None
-            },
-            activate,
-        )
-        .await;
-
-    let (_, _, pool_lamports_before) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-
-    let wallet_lamports_before = get_account(&mut context.banks_client, &accounts.alice.pubkey())
-        .await
-        .lamports;
-
-    if extra_lamports > 0 {
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &accounts.stake_account,
-            extra_lamports,
-        )
-        .await;
-    }
-
-    let instructions = instruction::withdraw(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let wallet_lamports_after = get_account(&mut context.banks_client, &accounts.alice.pubkey())
-        .await
-        .lamports;
-
-    let (_, alice_stake_after, _) =
-        get_stake_account(&mut context.banks_client, &accounts.alice_stake.pubkey()).await;
-    let alice_stake_after = alice_stake_after.unwrap().delegation.stake;
-
-    let (_, pool_stake_after, pool_lamports_after) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let pool_stake_after = pool_stake_after.unwrap().delegation.stake;
-
-    // when active, the depositor gets their rent back, but when activating, its
-    // just added to stake
-    let expected_deposit = if activate {
-        amount_deposited
-    } else {
-        amount_deposited + get_stake_account_rent(&mut context.banks_client).await
-    };
-
-    let prior_deposits = if prior_deposit {
-        if activate {
-            TEST_STAKE_AMOUNT * 10
-        } else {
-            TEST_STAKE_AMOUNT * 10 + get_stake_account_rent(&mut context.banks_client).await
-        }
-    } else {
-        0
-    };
-
-    // alice received her stake back
-    assert_eq!(alice_stake_after, expected_deposit);
-
-    // alice nothing to withdraw
-    // (we create the blank account before getting wallet_lamports_before)
-    assert_eq!(wallet_lamports_after, wallet_lamports_before);
-
-    // pool retains minstake
-    assert_eq!(pool_stake_after, prior_deposits + minimum_delegation);
-
-    // pool lamports otherwise unchanged. unexpected transfers affect nothing
-    assert_eq!(
-        pool_lamports_after,
-        pool_lamports_before - expected_deposit + extra_lamports
-    );
-
-    // alice has no tokens
-    assert_eq!(
-        get_token_balance(&mut context.banks_client, &accounts.alice_token).await,
-        0,
-    );
-
-    // tokens were burned
-    assert_eq!(
-        get_token_supply(&mut context.banks_client, &accounts.mint).await,
-        prior_deposits,
-    );
-}
-
-#[tokio::test]
-async fn success_with_rewards() {
-    let alice_deposit = TEST_STAKE_AMOUNT;
-    let bob_deposit = TEST_STAKE_AMOUNT * 3;
-
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    let minimum_delegation = accounts
-        .initialize_for_withdraw(&mut context, alice_deposit, Some(bob_deposit), true)
-        .await;
-
-    context.increment_vote_account_credits(&accounts.vote_account.pubkey(), 1);
-    advance_epoch(&mut context).await;
-
-    let alice_tokens = get_token_balance(&mut context.banks_client, &accounts.alice_token).await;
-    let bob_tokens = get_token_balance(&mut context.banks_client, &accounts.bob_token).await;
-
-    // tokens correspond to deposit after rewards
-    assert_eq!(alice_tokens, alice_deposit);
-    assert_eq!(bob_tokens, bob_deposit);
-
-    let (_, pool_stake, _) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let pool_stake = pool_stake.unwrap().delegation.stake;
-    let total_rewards = pool_stake - alice_deposit - bob_deposit - minimum_delegation;
-
-    let instructions = instruction::withdraw(
-        &id(),
-        &accounts.pool,
-        &accounts.alice_stake.pubkey(),
-        &accounts.alice.pubkey(),
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        alice_tokens,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&accounts.alice.pubkey()),
-        &[&accounts.alice],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let alice_tokens = get_token_balance(&mut context.banks_client, &accounts.alice_token).await;
-    let bob_tokens = get_token_balance(&mut context.banks_client, &accounts.bob_token).await;
-
-    let (_, alice_stake, _) =
-        get_stake_account(&mut context.banks_client, &accounts.alice_stake.pubkey()).await;
-    let alice_rewards = alice_stake.unwrap().delegation.stake - alice_deposit;
-
-    let (_, bob_stake, _) =
-        get_stake_account(&mut context.banks_client, &accounts.stake_account).await;
-    let bob_rewards = bob_stake.unwrap().delegation.stake - minimum_delegation - bob_deposit;
-
-    // alice tokens are fully burned, bob remains unchanged
-    assert_eq!(alice_tokens, 0);
-    assert_eq!(bob_tokens, bob_deposit);
-
-    // reward amounts are proportional to deposits
-    assert_eq!(
-        (alice_rewards as f64 / total_rewards as f64 * 100.0).round(),
-        25.0
-    );
-    assert_eq!(
-        (bob_rewards as f64 / total_rewards as f64 * 100.0).round(),
-        75.0
-    );
-}
-
-#[test_case(true; "activated")]
-#[test_case(false; "activating")]
-#[tokio::test]
-async fn fail_automorphic(activate: bool) {
-    let mut context = program_test(false).start_with_context().await;
-    let accounts = SinglePoolAccounts::default();
-    accounts
-        .initialize_for_withdraw(&mut context, TEST_STAKE_AMOUNT, None, activate)
-        .await;
-
-    let instructions = instruction::withdraw(
-        &id(),
-        &accounts.pool,
-        &accounts.stake_account,
-        &accounts.stake_authority,
-        &accounts.alice_token,
-        &accounts.alice.pubkey(),
-        TEST_STAKE_AMOUNT,
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&accounts.alice.pubkey()),
-        &[&accounts.alice],
-        context.last_blockhash,
-    );
-
-    let e = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err();
-    check_error(e, SinglePoolError::InvalidPoolStakeAccountUsage);
-}
diff --git a/slashing/README.md b/slashing/README.md
new file mode 100644
index 00000000000..93dcccf439d
--- /dev/null
+++ b/slashing/README.md
@@ -0,0 +1,2 @@
+NOTE: The slashing program and clients are now maintained at
+[solana-program/slashing](https://github.com/solana-program/slashing).
diff --git a/stake-pool/README.md b/stake-pool/README.md
index c8df8f6b6f6..7320995c63c 100644
--- a/stake-pool/README.md
+++ b/stake-pool/README.md
@@ -1,14 +1,2 @@
-# stake-pool program
-
-Full documentation is available at https://spl.solana.com/stake-pool
-
-The command-line interface tool is available in the `./cli` directory.
-
-Javascript bindings are available in the `./js` directory.
-
-Python bindings are available in the `./py` directory.
-
-## Audit
-
-The repository [README](https://github.com/solana-labs/solana-program-library#audits)
-contains information about program audits.
+NOTE: The stake-pool program and clients are now maintained at
+[solana-program/stake-pool](https://github.com/solana-program/stake-pool).
diff --git a/stake-pool/cli/Cargo.toml b/stake-pool/cli/Cargo.toml
deleted file mode 100644
index 16a5debb0b4..00000000000
--- a/stake-pool/cli/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL-Stake-Pool Command-line Utility"
-edition = "2021"
-homepage = "https://spl.solana.com/stake-pool"
-license = "Apache-2.0"
-name = "spl-stake-pool-cli"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "1.0.0"
-
-[dependencies]
-borsh = "1.5.1"
-clap = "2.33.3"
-serde = "1.0.203"
-serde_derive = "1.0.130"
-serde_json = "1.0.117"
-solana-account-decoder = ">=1.18.11,<=2"
-solana-clap-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-cli-output = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-program = ">=1.18.11,<=2"
-solana-remote-wallet = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "=3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-spl-stake-pool = { version = "=1.0.0", path = "../program", features = [
-  "no-entrypoint",
-] }
-spl-token = { version = "=4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-bs58 = "0.4.0"
-bincode = "1.3.1"
-
-[[bin]]
-name = "spl-stake-pool"
-path = "src/main.rs"
diff --git a/stake-pool/cli/README.md b/stake-pool/cli/README.md
deleted file mode 100644
index b3ed9f3ff84..00000000000
--- a/stake-pool/cli/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# SPL Stake Pool program command-line utility
-
-A basic command-line for creating and using SPL Stake Pools.  See https://spl.solana.com/stake-pool for more details.
-
-Under `./scripts`, there are helpful Bash scripts for setting up and running a
-stake pool. More information at the
-[stake pool quick start guide](https://spl.solana.com/stake-pool/quickstart).
diff --git a/stake-pool/cli/scripts/add-validators.sh b/stake-pool/cli/scripts/add-validators.sh
deleted file mode 100755
index 4bdcbdf1e1e..00000000000
--- a/stake-pool/cli/scripts/add-validators.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to add new validators to a stake pool, given the stake pool keyfile and
-# a file listing validator vote account pubkeys
-
-cd "$(dirname "$0")" || exit
-stake_pool_keyfile=$1
-validator_list=$2  # File containing validator vote account addresses, each will be added to the stake pool after creation
-
-add_validator_stakes () {
-  stake_pool=$1
-  validator_list=$2
-  while read -r validator
-  do
-    $spl_stake_pool add-validator "$stake_pool" "$validator"
-  done < "$validator_list"
-}
-
-spl_stake_pool=spl-stake-pool
-# Uncomment to use a local build
-#spl_stake_pool=../../../target/debug/spl-stake-pool
-
-stake_pool_pubkey=$(solana-keygen pubkey "$stake_pool_keyfile")
-echo "Adding validator stake accounts to the pool"
-add_validator_stakes "$stake_pool_pubkey" "$validator_list"
diff --git a/stake-pool/cli/scripts/deposit.sh b/stake-pool/cli/scripts/deposit.sh
deleted file mode 100755
index 56cea56148e..00000000000
--- a/stake-pool/cli/scripts/deposit.sh
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to deposit stakes and SOL into a stake pool, given the stake pool keyfile
-# and a path to a file containing a list of validator vote accounts
-
-cd "$(dirname "$0")" || exit
-stake_pool_keyfile=$1
-validator_list=$2
-sol_amount=$3
-
-create_keypair () {
-  if test ! -f "$1"
-  then
-    solana-keygen new --no-passphrase -s -o "$1"
-  fi
-}
-
-create_user_stakes () {
-  validator_list=$1
-  sol_amount=$2
-  authority=$3
-  while read -r validator
-  do
-    create_keypair "$keys_dir/stake_$validator".json
-    solana create-stake-account "$keys_dir/stake_$validator.json" "$sol_amount" --withdraw-authority "$authority" --stake-authority "$authority"
-  done < "$validator_list"
-}
-
-delegate_user_stakes () {
-  validator_list=$1
-  authority=$2
-  while read -r validator
-  do
-    solana delegate-stake --force "$keys_dir/stake_$validator.json" "$validator" --stake-authority "$authority"
-  done < "$validator_list"
-}
-
-deposit_stakes () {
-  stake_pool_pubkey=$1
-  validator_list=$2
-  authority=$3
-  while read -r validator
-  do
-    stake=$(solana-keygen pubkey "$keys_dir/stake_$validator.json")
-    $spl_stake_pool deposit-stake "$stake_pool_pubkey" "$stake" --withdraw-authority "$authority"
-  done < "$validator_list"
-}
-
-keys_dir=keys
-stake_pool_pubkey=$(solana-keygen pubkey "$stake_pool_keyfile")
-
-spl_stake_pool=spl-stake-pool
-# Uncomment to use a locally build CLI
-#spl_stake_pool=../../../target/debug/spl-stake-pool
-
-echo "Setting up keys directory $keys_dir"
-mkdir -p $keys_dir
-authority=$keys_dir/authority.json
-echo "Setting up authority for deposited stake accounts at $authority"
-create_keypair $authority
-
-echo "Creating user stake accounts to deposit into the pool"
-create_user_stakes "$validator_list" "$sol_amount" $authority
-echo "Delegating user stakes so that deposit will work"
-delegate_user_stakes "$validator_list" $authority
-
-echo "Waiting for stakes to activate, this may take awhile depending on the network!"
-echo "If you are running on localnet with 32 slots per epoch, wait 12 seconds..."
-sleep 12
-echo "Depositing stakes into stake pool"
-deposit_stakes "$stake_pool_pubkey" "$validator_list" $authority
diff --git a/stake-pool/cli/scripts/rebalance.sh b/stake-pool/cli/scripts/rebalance.sh
deleted file mode 100755
index 3db44972227..00000000000
--- a/stake-pool/cli/scripts/rebalance.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to add a certain amount of SOL into a stake pool, given the stake pool
-# keyfile and a path to a file containing a list of validator vote accounts
-
-cd "$(dirname "$0")" || exit
-stake_pool_keyfile=$1
-validator_list=$2
-sol_amount=$3
-
-spl_stake_pool=spl-stake-pool
-# Uncomment to use a locally build CLI
-#spl_stake_pool=../../../target/debug/spl-stake-pool
-
-increase_stakes () {
-  stake_pool_pubkey=$1
-  validator_list=$2
-  sol_amount=$3
-  while read -r validator
-  do
-    $spl_stake_pool increase-validator-stake "$stake_pool_pubkey" "$validator" "$sol_amount"
-  done < "$validator_list"
-}
-
-stake_pool_pubkey=$(solana-keygen pubkey "$stake_pool_keyfile")
-echo "Increasing amount delegated to each validator in stake pool"
-increase_stakes "$stake_pool_pubkey" "$validator_list" "$sol_amount"
diff --git a/stake-pool/cli/scripts/setup-stake-pool.sh b/stake-pool/cli/scripts/setup-stake-pool.sh
deleted file mode 100755
index 9bcb5b8b98e..00000000000
--- a/stake-pool/cli/scripts/setup-stake-pool.sh
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to setup a stake pool from scratch.  Please modify the parameters to
-# create a stake pool to your liking!
-
-cd "$(dirname "$0")" || exit
-command_args=()
-sol_amount=$1
-
-###################################################
-### MODIFY PARAMETERS BELOW THIS LINE FOR YOUR POOL
-###################################################
-
-# Epoch fee, assessed as a percentage of rewards earned by the pool every epoch,
-# represented as `numerator / denominator`
-command_args+=( --epoch-fee-numerator 1 )
-command_args+=( --epoch-fee-denominator 100 )
-
-# Withdrawal fee for SOL and stake accounts, represented as `numerator / denominator`
-command_args+=( --withdrawal-fee-numerator 2 )
-command_args+=( --withdrawal-fee-denominator 100 )
-
-# Deposit fee for SOL and stake accounts, represented as `numerator / denominator`
-command_args+=( --deposit-fee-numerator 3 )
-command_args+=( --deposit-fee-denominator 100 )
-
-command_args+=( --referral-fee 0 ) # Percentage of deposit fee that goes towards the referrer (a number between 0 and 100, inclusive)
-
-command_args+=( --max-validators 2350 ) # Maximum number of validators in the stake pool, 2350 is the current maximum possible
-
-# (Optional) Deposit authority, required to sign all deposits into the pool.
-# Setting this variable makes the pool "private" or "restricted".
-# Uncomment and set to a valid keypair if you want the pool to be restricted.
-#command_args+=( --deposit-authority keys/authority.json )
-
-###################################################
-### MODIFY PARAMETERS ABOVE THIS LINE FOR YOUR POOL
-###################################################
-
-keys_dir=keys
-spl_stake_pool=spl-stake-pool
-# Uncomment to use a local build
-#spl_stake_pool=../../../target/debug/spl-stake-pool
-
-mkdir -p $keys_dir
-
-create_keypair () {
-  if test ! -f "$1"
-  then
-    solana-keygen new --no-passphrase -s -o "$1"
-  fi
-}
-
-echo "Creating pool"
-stake_pool_keyfile=$keys_dir/stake-pool.json
-validator_list_keyfile=$keys_dir/validator-list.json
-mint_keyfile=$keys_dir/mint.json
-reserve_keyfile=$keys_dir/reserve.json
-create_keypair $stake_pool_keyfile
-create_keypair $validator_list_keyfile
-create_keypair $mint_keyfile
-create_keypair $reserve_keyfile
-
-set -ex
-$spl_stake_pool \
-  create-pool \
-  "${command_args[@]}" \
-  --pool-keypair "$stake_pool_keyfile" \
-  --validator-list-keypair "$validator_list_keyfile" \
-  --mint-keypair "$mint_keyfile" \
-  --reserve-keypair "$reserve_keyfile"
-
-set +ex
-stake_pool_pubkey=$(solana-keygen pubkey "$stake_pool_keyfile")
-set -ex
-
-echo "Creating token metadata"
-$spl_stake_pool \
-  create-token-metadata \
-  "$stake_pool_pubkey" \
-  NAME \
-  SYMBOL \
-  URI
-
-echo "Depositing SOL into stake pool"
-$spl_stake_pool deposit-sol "$stake_pool_pubkey" "$sol_amount"
diff --git a/stake-pool/cli/scripts/setup-test-validator.sh b/stake-pool/cli/scripts/setup-test-validator.sh
deleted file mode 100755
index 073e9f01830..00000000000
--- a/stake-pool/cli/scripts/setup-test-validator.sh
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to setup a local solana-test-validator with the stake pool program
-# given a maximum number of validators and a file path to store the list of
-# test validator vote accounts.
-
-cd "$(dirname "$0")" || exit
-max_validators=$1
-validator_file=$2
-
-create_keypair () {
-  if test ! -f "$1"
-  then
-    solana-keygen new --no-passphrase -s -o "$1"
-  fi
-}
-
-setup_test_validator() {
-  solana-test-validator \
-    --clone-upgradeable-program SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy \
-    --clone-upgradeable-program metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s \
-    --url mainnet-beta \
-    --slots-per-epoch 32 \
-    --quiet --reset &
-  # Uncomment to use a locally built stake program
-  #solana-test-validator \
-  #  --bpf-program SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy ../../../target/deploy/spl_stake_pool.so \
-  #  --bpf-program metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s ../../program/tests/fixtures/mpl_token_metadata.so \
-  #  --slots-per-epoch 32 \
-  #  --quiet --reset &
-  pid=$!
-  solana config set --url http://127.0.0.1:8899
-  solana config set --commitment confirmed
-  echo "waiting for solana-test-validator, pid: $pid"
-  sleep 15
-}
-
-create_vote_accounts () {
-  max_validators=$1
-  validator_file=$2
-  for number in $(seq 1 "$max_validators")
-  do
-    create_keypair "$keys_dir/identity_$number.json"
-    create_keypair "$keys_dir/vote_$number.json"
-    create_keypair "$keys_dir/withdrawer_$number.json"
-    solana create-vote-account "$keys_dir/vote_$number.json" "$keys_dir/identity_$number.json" "$keys_dir/withdrawer_$number.json" --commission 1
-    vote_pubkey=$(solana-keygen pubkey "$keys_dir/vote_$number.json")
-    echo "$vote_pubkey" >> "$validator_file"
-  done
-}
-
-
-echo "Setup keys directory and clear old validator list file if found"
-keys_dir=keys
-mkdir -p $keys_dir
-if test -f "$validator_file"
-then
-  rm "$validator_file"
-fi
-
-echo "Setting up local test validator"
-setup_test_validator
-
-echo "Creating vote accounts, these accounts be added to the stake pool"
-create_vote_accounts "$max_validators" "$validator_file"
-
-echo "Done adding $max_validators validator vote accounts, their pubkeys can be found in $validator_file"
diff --git a/stake-pool/cli/scripts/withdraw.sh b/stake-pool/cli/scripts/withdraw.sh
deleted file mode 100755
index 6ad2e327fbc..00000000000
--- a/stake-pool/cli/scripts/withdraw.sh
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-
-# Script to withdraw stakes and SOL from a stake pool, given the stake pool public key
-# and a path to a file containing a list of validator vote accounts
-
-cd "$(dirname "$0")" || exit
-stake_pool_keyfile=$1
-validator_list=$2
-withdraw_sol_amount=$3
-
-create_keypair () {
-  if test ! -f "$1"
-  then
-    solana-keygen new --no-passphrase -s -o "$1"
-  fi
-}
-
-create_stake_account () {
-  authority=$1
-  while read -r validator
-  do
-    solana-keygen new --no-passphrase -o "$keys_dir/stake_account_$validator.json"
-    solana create-stake-account "$keys_dir/stake_account_$validator.json" 2 
-    solana delegate-stake --force "$keys_dir/stake_account_$validator.json"  "$validator" 
-  done < "$validator_list"
-}
-
-withdraw_stakes () {
-  stake_pool_pubkey=$1
-  validator_list=$2
-  pool_amount=$3
-  while read -r validator
-  do
-    $spl_stake_pool withdraw-stake "$stake_pool_pubkey" "$pool_amount" --vote-account "$validator"
-  done < "$validator_list"
-}
-
-withdraw_stakes_to_stake_receiver () {
-  stake_pool_pubkey=$1
-  validator_list=$2
-  pool_amount=$3
-  while read -r validator
-  do
-    stake_receiver=$(solana-keygen pubkey "$keys_dir/stake_account_$validator.json")
-    $spl_stake_pool withdraw-stake "$stake_pool_pubkey" "$pool_amount" --vote-account "$validator" --stake-receiver "$stake_receiver"
-  done < "$validator_list"
-}
-
-spl_stake_pool=spl-stake-pool
-# Uncomment to use a locally build CLI
-# spl_stake_pool=../../../target/debug/spl-stake-pool
-
-stake_pool_pubkey=$(solana-keygen pubkey "$stake_pool_keyfile")
-keys_dir=keys
-
-echo "Setting up keys directory $keys_dir"
-mkdir -p $keys_dir
-authority=$keys_dir/authority.json
-
-create_stake_account $authority
-echo "Waiting for stakes to activate, this may take awhile depending on the network!"
-echo "If you are running on localnet with 32 slots per epoch, wait 12 seconds..."
-sleep 12
-
-echo "Setting up authority for withdrawn stake accounts at $authority"
-create_keypair $authority
-
-echo "Withdrawing stakes from stake pool"
-withdraw_stakes "$stake_pool_pubkey" "$validator_list" "$withdraw_sol_amount"
-
-echo "Withdrawing stakes from stake pool to receive it in stake receiver account"
-withdraw_stakes_to_stake_receiver "$stake_pool_pubkey" "$validator_list" "$withdraw_sol_amount"
-
-echo "Withdrawing SOL from stake pool to authority"
-$spl_stake_pool withdraw-sol "$stake_pool_pubkey" $authority "$withdraw_sol_amount"
diff --git a/stake-pool/cli/src/client.rs b/stake-pool/cli/src/client.rs
deleted file mode 100644
index 5d3974a585a..00000000000
--- a/stake-pool/cli/src/client.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use {
-    bincode::deserialize,
-    solana_account_decoder::UiAccountEncoding,
-    solana_client::{
-        client_error::ClientError,
-        rpc_client::RpcClient,
-        rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
-        rpc_filter::{Memcmp, RpcFilterType},
-    },
-    solana_program::{
-        borsh1::try_from_slice_unchecked, hash::Hash, instruction::Instruction, message::Message,
-        program_pack::Pack, pubkey::Pubkey, stake,
-    },
-    solana_sdk::{compute_budget::ComputeBudgetInstruction, transaction::Transaction},
-    spl_stake_pool::{
-        find_withdraw_authority_program_address,
-        state::{StakePool, ValidatorList},
-    },
-    std::collections::HashSet,
-};
-
-pub(crate) type Error = Box<dyn std::error::Error>;
-
-pub fn get_stake_pool(
-    rpc_client: &RpcClient,
-    stake_pool_address: &Pubkey,
-) -> Result<StakePool, Error> {
-    let account_data = rpc_client.get_account_data(stake_pool_address)?;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(account_data.as_slice())
-        .map_err(|err| format!("Invalid stake pool {}: {}", stake_pool_address, err))?;
-    Ok(stake_pool)
-}
-
-pub fn get_validator_list(
-    rpc_client: &RpcClient,
-    validator_list_address: &Pubkey,
-) -> Result<ValidatorList, Error> {
-    let account_data = rpc_client.get_account_data(validator_list_address)?;
-    let validator_list = try_from_slice_unchecked::<ValidatorList>(account_data.as_slice())
-        .map_err(|err| format!("Invalid validator list {}: {}", validator_list_address, err))?;
-    Ok(validator_list)
-}
-
-pub fn get_token_account(
-    rpc_client: &RpcClient,
-    token_account_address: &Pubkey,
-    expected_token_mint: &Pubkey,
-) -> Result<spl_token::state::Account, Error> {
-    let account_data = rpc_client.get_account_data(token_account_address)?;
-    let token_account = spl_token::state::Account::unpack_from_slice(account_data.as_slice())
-        .map_err(|err| format!("Invalid token account {}: {}", token_account_address, err))?;
-
-    if token_account.mint != *expected_token_mint {
-        Err(format!(
-            "Invalid token mint for {}, expected mint is {}",
-            token_account_address, expected_token_mint
-        )
-        .into())
-    } else {
-        Ok(token_account)
-    }
-}
-
-pub fn get_token_mint(
-    rpc_client: &RpcClient,
-    token_mint_address: &Pubkey,
-) -> Result<spl_token::state::Mint, Error> {
-    let account_data = rpc_client.get_account_data(token_mint_address)?;
-    let token_mint = spl_token::state::Mint::unpack_from_slice(account_data.as_slice())
-        .map_err(|err| format!("Invalid token mint {}: {}", token_mint_address, err))?;
-
-    Ok(token_mint)
-}
-
-pub(crate) fn get_stake_state(
-    rpc_client: &RpcClient,
-    stake_address: &Pubkey,
-) -> Result<stake::state::StakeStateV2, Error> {
-    let account_data = rpc_client.get_account_data(stake_address)?;
-    let stake_state = deserialize(account_data.as_slice())
-        .map_err(|err| format!("Invalid stake account {}: {}", stake_address, err))?;
-    Ok(stake_state)
-}
-
-pub(crate) fn get_stake_pools(
-    rpc_client: &RpcClient,
-) -> Result<Vec<(Pubkey, StakePool, ValidatorList, Pubkey)>, ClientError> {
-    rpc_client
-        .get_program_accounts_with_config(
-            &spl_stake_pool::id(),
-            RpcProgramAccountsConfig {
-                // 0 is the account type
-                filters: Some(vec![RpcFilterType::Memcmp(Memcmp::new_raw_bytes(
-                    0,
-                    vec![1],
-                ))]),
-                account_config: RpcAccountInfoConfig {
-                    encoding: Some(UiAccountEncoding::Base64),
-                    ..RpcAccountInfoConfig::default()
-                },
-                ..RpcProgramAccountsConfig::default()
-            },
-        )
-        .map(|accounts| {
-            accounts
-                .into_iter()
-                .filter_map(|(address, account)| {
-                    let pool_withdraw_authority =
-                        find_withdraw_authority_program_address(&spl_stake_pool::id(), &address).0;
-                    match try_from_slice_unchecked::<StakePool>(account.data.as_slice()) {
-                        Ok(stake_pool) => {
-                            get_validator_list(rpc_client, &stake_pool.validator_list)
-                                .map(|validator_list| {
-                                    (address, stake_pool, validator_list, pool_withdraw_authority)
-                                })
-                                .ok()
-                        }
-                        Err(err) => {
-                            eprintln!("Invalid stake pool data for {}: {}", address, err);
-                            None
-                        }
-                    }
-                })
-                .collect()
-        })
-}
-
-pub(crate) fn get_all_stake(
-    rpc_client: &RpcClient,
-    authorized_staker: &Pubkey,
-) -> Result<HashSet<Pubkey>, ClientError> {
-    let all_stake_accounts = rpc_client.get_program_accounts_with_config(
-        &stake::program::id(),
-        RpcProgramAccountsConfig {
-            filters: Some(vec![
-                // Filter by `Meta::authorized::staker`, which begins at byte offset 12
-                RpcFilterType::Memcmp(Memcmp::new_base58_encoded(12, authorized_staker.as_ref())),
-            ]),
-            account_config: RpcAccountInfoConfig {
-                encoding: Some(solana_account_decoder::UiAccountEncoding::Base64),
-                commitment: Some(rpc_client.commitment()),
-                ..RpcAccountInfoConfig::default()
-            },
-            ..RpcProgramAccountsConfig::default()
-        },
-    )?;
-
-    Ok(all_stake_accounts
-        .into_iter()
-        .map(|(address, _)| address)
-        .collect())
-}
-
-/// Helper function to add a compute unit limit instruction to a given set
-/// of instructions
-pub(crate) fn add_compute_unit_limit_from_simulation(
-    rpc_client: &RpcClient,
-    instructions: &mut Vec<Instruction>,
-    payer: &Pubkey,
-    blockhash: &Hash,
-) -> Result<(), Error> {
-    // add a max compute unit limit instruction for the simulation
-    const MAX_COMPUTE_UNIT_LIMIT: u32 = 1_400_000;
-    instructions.push(ComputeBudgetInstruction::set_compute_unit_limit(
-        MAX_COMPUTE_UNIT_LIMIT,
-    ));
-
-    let transaction = Transaction::new_unsigned(Message::new_with_blockhash(
-        instructions,
-        Some(payer),
-        blockhash,
-    ));
-    let simulation_result = rpc_client.simulate_transaction(&transaction)?.value;
-    let units_consumed = simulation_result
-        .units_consumed
-        .ok_or("No units consumed on simulation")?;
-    // Overwrite the compute unit limit instruction with the actual units consumed
-    let compute_unit_limit = u32::try_from(units_consumed)?;
-    instructions
-        .last_mut()
-        .expect("Compute budget instruction was added earlier")
-        .data = ComputeBudgetInstruction::set_compute_unit_limit(compute_unit_limit).data;
-    Ok(())
-}
diff --git a/stake-pool/cli/src/main.rs b/stake-pool/cli/src/main.rs
deleted file mode 100644
index 3c8e4af58bb..00000000000
--- a/stake-pool/cli/src/main.rs
+++ /dev/null
@@ -1,3287 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-mod client;
-mod output;
-
-// use instruction::create_associated_token_account once ATA 1.0.5 is released
-#[allow(deprecated)]
-use spl_associated_token_account::create_associated_token_account;
-use {
-    crate::{
-        client::*,
-        output::{CliStakePool, CliStakePoolDetails, CliStakePoolStakeAccountInfo, CliStakePools},
-    },
-    bincode::deserialize,
-    clap::{
-        crate_description, crate_name, crate_version, value_t, value_t_or_exit, App, AppSettings,
-        Arg, ArgGroup, ArgMatches, SubCommand,
-    },
-    solana_clap_utils::{
-        compute_unit_price::{compute_unit_price_arg, COMPUTE_UNIT_PRICE_ARG},
-        input_parsers::{keypair_of, pubkey_of},
-        input_validators::{
-            is_amount, is_keypair_or_ask_keyword, is_parsable, is_pubkey, is_url,
-            is_valid_percentage, is_valid_pubkey, is_valid_signer,
-        },
-        keypair::{signer_from_path_with_config, SignerFromPathConfig},
-        ArgConstant,
-    },
-    solana_cli_output::OutputFormat,
-    solana_client::rpc_client::RpcClient,
-    solana_program::{
-        borsh1::{get_instance_packed_len, get_packed_len},
-        instruction::Instruction,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        stake,
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        commitment_config::CommitmentConfig,
-        compute_budget::ComputeBudgetInstruction,
-        hash::Hash,
-        message::Message,
-        native_token::{self, Sol},
-        signature::{Keypair, Signer},
-        signers::Signers,
-        system_instruction,
-        transaction::Transaction,
-    },
-    spl_associated_token_account::get_associated_token_address,
-    spl_stake_pool::{
-        self, find_stake_program_address, find_transient_stake_program_address,
-        find_withdraw_authority_program_address,
-        instruction::{FundingType, PreferredValidatorType},
-        minimum_delegation,
-        state::{Fee, FeeType, StakePool, ValidatorList, ValidatorStakeInfo},
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-    std::{cmp::Ordering, num::NonZeroU32, process::exit, rc::Rc},
-};
-
-pub(crate) struct Config {
-    rpc_client: RpcClient,
-    verbose: bool,
-    output_format: OutputFormat,
-    manager: Box<dyn Signer>,
-    staker: Box<dyn Signer>,
-    funding_authority: Option<Box<dyn Signer>>,
-    token_owner: Box<dyn Signer>,
-    fee_payer: Box<dyn Signer>,
-    dry_run: bool,
-    no_update: bool,
-    compute_unit_price: Option<u64>,
-    compute_unit_limit: ComputeUnitLimit,
-}
-
-type CommandResult = Result<(), Error>;
-
-const STAKE_STATE_LEN: usize = 200;
-
-macro_rules! unique_signers {
-    ($vec:ident) => {
-        $vec.sort_by_key(|l| l.pubkey());
-        $vec.dedup();
-    };
-}
-
-fn check_fee_payer_balance(config: &Config, required_balance: u64) -> Result<(), Error> {
-    let balance = config.rpc_client.get_balance(&config.fee_payer.pubkey())?;
-    if balance < required_balance {
-        Err(format!(
-            "Fee payer, {}, has insufficient balance: {} required, {} available",
-            config.fee_payer.pubkey(),
-            Sol(required_balance),
-            Sol(balance)
-        )
-        .into())
-    } else {
-        Ok(())
-    }
-}
-
-const FEES_REFERENCE: &str = "Consider setting a minimal fee. \
-                              See https://spl.solana.com/stake-pool/fees for more \
-                              information about fees and best practices. If you are \
-                              aware of the possible risks of a stake pool with no fees, \
-                              you may force pool creation with the --unsafe-fees flag.";
-
-enum ComputeUnitLimit {
-    Default,
-    Static(u32),
-    Simulated,
-}
-const COMPUTE_UNIT_LIMIT_ARG: ArgConstant<'static> = ArgConstant {
-    name: "compute_unit_limit",
-    long: "--with-compute-unit-limit",
-    help: "Set compute unit limit for transaction, in compute units; also accepts \
-        keyword DEFAULT to use the default compute unit limit, which is 200k per \
-        top-level instruction, with a maximum of 1.4 million. \
-        If nothing is set, transactions are simulated prior to sending, and the \
-        compute units consumed are set as the limit. This may may fail if accounts \
-        are modified by another transaction between simulation and execution.",
-};
-fn is_compute_unit_limit_or_simulated<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + std::fmt::Display,
-{
-    if string.as_ref().parse::<u32>().is_ok() || string.as_ref() == "DEFAULT" {
-        Ok(())
-    } else {
-        Err(format!(
-            "Unable to parse input compute unit limit as integer or DEFAULT, provided: {string}"
-        ))
-    }
-}
-fn parse_compute_unit_limit<T>(string: T) -> Result<ComputeUnitLimit, String>
-where
-    T: AsRef<str> + std::fmt::Display,
-{
-    match string.as_ref().parse::<u32>() {
-        Ok(compute_unit_limit) => Ok(ComputeUnitLimit::Static(compute_unit_limit)),
-        Err(_) if string.as_ref() == "DEFAULT" => Ok(ComputeUnitLimit::Default),
-        _ => Err(format!(
-            "Unable to parse compute unit limit, provided: {string}"
-        )),
-    }
-}
-
-fn check_stake_pool_fees(
-    epoch_fee: &Fee,
-    withdrawal_fee: &Fee,
-    deposit_fee: &Fee,
-) -> Result<(), Error> {
-    if epoch_fee.numerator == 0 || epoch_fee.denominator == 0 {
-        return Err(format!("Epoch fee should not be 0. {}", FEES_REFERENCE,).into());
-    }
-    let is_withdrawal_fee_zero = withdrawal_fee.numerator == 0 || withdrawal_fee.denominator == 0;
-    let is_deposit_fee_zero = deposit_fee.numerator == 0 || deposit_fee.denominator == 0;
-    if is_withdrawal_fee_zero && is_deposit_fee_zero {
-        return Err(format!(
-            "Withdrawal and deposit fee should not both be 0. {}",
-            FEES_REFERENCE,
-        )
-        .into());
-    }
-    Ok(())
-}
-
-fn get_signer(
-    matches: &ArgMatches<'_>,
-    keypair_name: &str,
-    keypair_path: &str,
-    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    signer_from_path_config: SignerFromPathConfig,
-) -> Box<dyn Signer> {
-    signer_from_path_with_config(
-        matches,
-        matches.value_of(keypair_name).unwrap_or(keypair_path),
-        keypair_name,
-        wallet_manager,
-        &signer_from_path_config,
-    )
-    .unwrap_or_else(|e| {
-        eprintln!("error: {}", e);
-        exit(1);
-    })
-}
-
-fn get_latest_blockhash(client: &RpcClient) -> Result<Hash, Error> {
-    Ok(client
-        .get_latest_blockhash_with_commitment(CommitmentConfig::confirmed())?
-        .0)
-}
-
-fn send_transaction_no_wait(
-    config: &Config,
-    transaction: Transaction,
-) -> solana_client::client_error::Result<()> {
-    if config.dry_run {
-        let result = config.rpc_client.simulate_transaction(&transaction)?;
-        println!("Simulate result: {:?}", result);
-    } else {
-        let signature = config.rpc_client.send_transaction(&transaction)?;
-        println!("Signature: {}", signature);
-    }
-    Ok(())
-}
-
-fn send_transaction(
-    config: &Config,
-    transaction: Transaction,
-) -> solana_client::client_error::Result<()> {
-    if config.dry_run {
-        let result = config.rpc_client.simulate_transaction(&transaction)?;
-        println!("Simulate result: {:?}", result);
-    } else {
-        let signature = config
-            .rpc_client
-            .send_and_confirm_transaction_with_spinner(&transaction)?;
-        println!("Signature: {}", signature);
-    }
-    Ok(())
-}
-
-fn checked_transaction_with_signers_and_additional_fee<T: Signers>(
-    config: &Config,
-    instructions: &[Instruction],
-    signers: &T,
-    additional_fee: u64,
-) -> Result<Transaction, Error> {
-    let recent_blockhash = get_latest_blockhash(&config.rpc_client)?;
-    let mut instructions = instructions.to_vec();
-    if let Some(compute_unit_price) = config.compute_unit_price {
-        instructions.push(ComputeBudgetInstruction::set_compute_unit_price(
-            compute_unit_price,
-        ));
-    }
-    match config.compute_unit_limit {
-        ComputeUnitLimit::Default => {}
-        ComputeUnitLimit::Static(compute_unit_limit) => {
-            instructions.push(ComputeBudgetInstruction::set_compute_unit_limit(
-                compute_unit_limit,
-            ));
-        }
-        ComputeUnitLimit::Simulated => {
-            add_compute_unit_limit_from_simulation(
-                &config.rpc_client,
-                &mut instructions,
-                &config.fee_payer.pubkey(),
-                &recent_blockhash,
-            )?;
-        }
-    }
-    let message = Message::new_with_blockhash(
-        &instructions,
-        Some(&config.fee_payer.pubkey()),
-        &recent_blockhash,
-    );
-    check_fee_payer_balance(
-        config,
-        additional_fee.saturating_add(config.rpc_client.get_fee_for_message(&message)?),
-    )?;
-    let transaction = Transaction::new(signers, message, recent_blockhash);
-    Ok(transaction)
-}
-
-fn checked_transaction_with_signers<T: Signers>(
-    config: &Config,
-    instructions: &[Instruction],
-    signers: &T,
-) -> Result<Transaction, Error> {
-    checked_transaction_with_signers_and_additional_fee(config, instructions, signers, 0)
-}
-
-fn new_stake_account(
-    fee_payer: &Pubkey,
-    instructions: &mut Vec<Instruction>,
-    lamports: u64,
-) -> Keypair {
-    // Account for tokens not specified, creating one
-    let stake_receiver_keypair = Keypair::new();
-    let stake_receiver_pubkey = stake_receiver_keypair.pubkey();
-    println!(
-        "Creating account to receive stake {}",
-        stake_receiver_pubkey
-    );
-
-    instructions.push(
-        // Creating new account
-        system_instruction::create_account(
-            fee_payer,
-            &stake_receiver_pubkey,
-            lamports,
-            STAKE_STATE_LEN as u64,
-            &stake::program::id(),
-        ),
-    );
-
-    stake_receiver_keypair
-}
-
-#[allow(clippy::too_many_arguments)]
-fn command_create_pool(
-    config: &Config,
-    deposit_authority: Option<Keypair>,
-    epoch_fee: Fee,
-    withdrawal_fee: Fee,
-    deposit_fee: Fee,
-    referral_fee: u8,
-    max_validators: u32,
-    stake_pool_keypair: Option<Keypair>,
-    validator_list_keypair: Option<Keypair>,
-    mint_keypair: Option<Keypair>,
-    reserve_keypair: Option<Keypair>,
-    unsafe_fees: bool,
-) -> CommandResult {
-    if !unsafe_fees {
-        check_stake_pool_fees(&epoch_fee, &withdrawal_fee, &deposit_fee)?;
-    }
-    let reserve_keypair = reserve_keypair.unwrap_or_else(Keypair::new);
-    println!("Creating reserve stake {}", reserve_keypair.pubkey());
-
-    let mint_keypair = mint_keypair.unwrap_or_else(Keypair::new);
-    println!("Creating mint {}", mint_keypair.pubkey());
-
-    let stake_pool_keypair = stake_pool_keypair.unwrap_or_else(Keypair::new);
-
-    let validator_list_keypair = validator_list_keypair.unwrap_or_else(Keypair::new);
-
-    let reserve_stake_balance = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(STAKE_STATE_LEN)?
-        + MINIMUM_RESERVE_LAMPORTS;
-    let mint_account_balance = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(spl_token::state::Mint::LEN)?;
-    let pool_fee_account_balance = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(spl_token::state::Account::LEN)?;
-    let stake_pool_account_lamports = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(get_packed_len::<StakePool>())?;
-    let empty_validator_list = ValidatorList::new(max_validators);
-    let validator_list_size = get_instance_packed_len(&empty_validator_list)?;
-    let validator_list_balance = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(validator_list_size)?;
-    let mut total_rent_free_balances = reserve_stake_balance
-        + mint_account_balance
-        + pool_fee_account_balance
-        + stake_pool_account_lamports
-        + validator_list_balance;
-
-    let default_decimals = spl_token::native_mint::DECIMALS;
-
-    // Calculate withdraw authority used for minting pool tokens
-    let (withdraw_authority, _) = find_withdraw_authority_program_address(
-        &spl_stake_pool::id(),
-        &stake_pool_keypair.pubkey(),
-    );
-
-    if config.verbose {
-        println!("Stake pool withdraw authority {}", withdraw_authority);
-    }
-
-    let mut setup_instructions = vec![
-        // Account for the stake pool reserve
-        system_instruction::create_account(
-            &config.fee_payer.pubkey(),
-            &reserve_keypair.pubkey(),
-            reserve_stake_balance,
-            STAKE_STATE_LEN as u64,
-            &stake::program::id(),
-        ),
-        stake::instruction::initialize(
-            &reserve_keypair.pubkey(),
-            &stake::state::Authorized {
-                staker: withdraw_authority,
-                withdrawer: withdraw_authority,
-            },
-            &stake::state::Lockup::default(),
-        ),
-        // Account for the stake pool mint
-        system_instruction::create_account(
-            &config.fee_payer.pubkey(),
-            &mint_keypair.pubkey(),
-            mint_account_balance,
-            spl_token::state::Mint::LEN as u64,
-            &spl_token::id(),
-        ),
-        // Initialize pool token mint account
-        spl_token::instruction::initialize_mint(
-            &spl_token::id(),
-            &mint_keypair.pubkey(),
-            &withdraw_authority,
-            None,
-            default_decimals,
-        )?,
-    ];
-
-    let pool_fee_account = add_associated_token_account(
-        config,
-        &mint_keypair.pubkey(),
-        &config.manager.pubkey(),
-        &mut setup_instructions,
-        &mut total_rent_free_balances,
-    );
-    println!("Creating pool fee collection account {}", pool_fee_account);
-
-    let initialize_instructions = &[
-        // Validator stake account list storage
-        system_instruction::create_account(
-            &config.fee_payer.pubkey(),
-            &validator_list_keypair.pubkey(),
-            validator_list_balance,
-            validator_list_size as u64,
-            &spl_stake_pool::id(),
-        ),
-        // Account for the stake pool
-        system_instruction::create_account(
-            &config.fee_payer.pubkey(),
-            &stake_pool_keypair.pubkey(),
-            stake_pool_account_lamports,
-            get_packed_len::<StakePool>() as u64,
-            &spl_stake_pool::id(),
-        ),
-        // Initialize stake pool
-        spl_stake_pool::instruction::initialize(
-            &spl_stake_pool::id(),
-            &stake_pool_keypair.pubkey(),
-            &config.manager.pubkey(),
-            &config.staker.pubkey(),
-            &withdraw_authority,
-            &validator_list_keypair.pubkey(),
-            &reserve_keypair.pubkey(),
-            &mint_keypair.pubkey(),
-            &pool_fee_account,
-            &spl_token::id(),
-            deposit_authority.as_ref().map(|x| x.pubkey()),
-            epoch_fee,
-            withdrawal_fee,
-            deposit_fee,
-            referral_fee,
-            max_validators,
-        ),
-    ];
-
-    {
-        let mut setup_signers = vec![config.fee_payer.as_ref(), &mint_keypair, &reserve_keypair];
-        unique_signers!(setup_signers);
-
-        let setup_transaction =
-            checked_transaction_with_signers(config, &setup_instructions, &setup_signers)?;
-
-        println!(
-            "Setting up required accounts for stake pool: reserve stake {} and mint {}",
-            reserve_keypair.pubkey(),
-            mint_keypair.pubkey()
-        );
-        send_transaction(config, setup_transaction)?;
-    }
-
-    {
-        let mut initialize_signers = vec![
-            config.fee_payer.as_ref(),
-            &stake_pool_keypair,
-            &validator_list_keypair,
-            config.manager.as_ref(),
-        ];
-        let initialize_transaction = if let Some(deposit_authority) = deposit_authority {
-            println!(
-                "Deposits will be restricted to {} only, this can be changed using the set-funding-authority command.",
-                deposit_authority.pubkey()
-            );
-            let mut initialize_signers = initialize_signers.clone();
-            initialize_signers.push(&deposit_authority);
-            unique_signers!(initialize_signers);
-            checked_transaction_with_signers(config, initialize_instructions, &initialize_signers)?
-        } else {
-            unique_signers!(initialize_signers);
-            checked_transaction_with_signers(config, initialize_instructions, &initialize_signers)?
-        };
-
-        println!(
-            "Creating stake pool {} with validator list {}",
-            stake_pool_keypair.pubkey(),
-            validator_list_keypair.pubkey()
-        );
-        send_transaction(config, initialize_transaction)?;
-    }
-
-    Ok(())
-}
-
-fn create_token_metadata(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> CommandResult {
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.manager.as_ref()];
-    let instructions = vec![spl_stake_pool::instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        stake_pool_address,
-        &stake_pool.manager,
-        &stake_pool.pool_mint,
-        &config.fee_payer.pubkey(),
-        name,
-        symbol,
-        uri,
-    )];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(config, &instructions, &signers)?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn update_token_metadata(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> CommandResult {
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.manager.as_ref()];
-    let instructions = vec![spl_stake_pool::instruction::update_token_metadata(
-        &spl_stake_pool::id(),
-        stake_pool_address,
-        &stake_pool.manager,
-        &stake_pool.pool_mint,
-        name,
-        symbol,
-        uri,
-    )];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(config, &instructions, &signers)?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_vsa_add(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    vote_account: &Pubkey,
-) -> CommandResult {
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    if validator_list.contains(vote_account) {
-        println!(
-            "Stake pool already contains validator {}, ignoring",
-            vote_account
-        );
-        return Ok(());
-    }
-
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    // iterate until a free account is found
-    let (stake_account_address, validator_seed) = {
-        let mut i = 0;
-        loop {
-            let seed = NonZeroU32::new(i);
-            let (address, _) = find_stake_program_address(
-                &spl_stake_pool::id(),
-                vote_account,
-                stake_pool_address,
-                seed,
-            );
-            let maybe_account = config
-                .rpc_client
-                .get_account_with_commitment(
-                    &stake_pool.reserve_stake,
-                    config.rpc_client.commitment(),
-                )?
-                .value;
-            if maybe_account.is_some() {
-                break (address, seed);
-            }
-            i += 1;
-        }
-    };
-    println!(
-        "Adding stake account {}, delegated to {}",
-        stake_account_address, vote_account
-    );
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.staker.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[
-            spl_stake_pool::instruction::add_validator_to_pool_with_vote(
-                &spl_stake_pool::id(),
-                &stake_pool,
-                stake_pool_address,
-                vote_account,
-                validator_seed,
-            ),
-        ],
-        &signers,
-    )?;
-
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_vsa_remove(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    vote_account: &Pubkey,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let validator_stake_info = validator_list
-        .find(vote_account)
-        .ok_or("Vote account not found in validator list")?;
-
-    let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-    let (stake_account_address, _) = find_stake_program_address(
-        &spl_stake_pool::id(),
-        vote_account,
-        stake_pool_address,
-        validator_seed,
-    );
-    println!(
-        "Removing stake account {}, delegated to {}",
-        stake_account_address, vote_account
-    );
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.staker.as_ref()];
-    let instructions = vec![
-        // Create new validator stake account address
-        spl_stake_pool::instruction::remove_validator_from_pool_with_vote(
-            &spl_stake_pool::id(),
-            &stake_pool,
-            stake_pool_address,
-            vote_account,
-            validator_seed,
-            validator_stake_info.transient_seed_suffix.into(),
-        ),
-    ];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(config, &instructions, &signers)?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_increase_validator_stake(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    vote_account: &Pubkey,
-    amount: f64,
-) -> CommandResult {
-    let lamports = native_token::sol_to_lamports(amount);
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let validator_stake_info = validator_list
-        .find(vote_account)
-        .ok_or("Vote account not found in validator list")?;
-    let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.staker.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[
-            spl_stake_pool::instruction::increase_validator_stake_with_vote(
-                &spl_stake_pool::id(),
-                &stake_pool,
-                stake_pool_address,
-                vote_account,
-                lamports,
-                validator_seed,
-                validator_stake_info.transient_seed_suffix.into(),
-            ),
-        ],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_decrease_validator_stake(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    vote_account: &Pubkey,
-    amount: f64,
-) -> CommandResult {
-    let lamports = native_token::sol_to_lamports(amount);
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let validator_stake_info = validator_list
-        .find(vote_account)
-        .ok_or("Vote account not found in validator list")?;
-    let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-
-    let mut signers = vec![config.fee_payer.as_ref(), config.staker.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[
-            spl_stake_pool::instruction::decrease_validator_stake_with_vote(
-                &spl_stake_pool::id(),
-                &stake_pool,
-                stake_pool_address,
-                vote_account,
-                lamports,
-                validator_seed,
-                validator_stake_info.transient_seed_suffix.into(),
-            ),
-        ],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_set_preferred_validator(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    preferred_type: PreferredValidatorType,
-    vote_address: Option<Pubkey>,
-) -> CommandResult {
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let mut signers = vec![config.fee_payer.as_ref(), config.staker.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[spl_stake_pool::instruction::set_preferred_validator(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &config.staker.pubkey(),
-            &stake_pool.validator_list,
-            preferred_type,
-            vote_address,
-        )],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn add_associated_token_account(
-    config: &Config,
-    mint: &Pubkey,
-    owner: &Pubkey,
-    instructions: &mut Vec<Instruction>,
-    rent_free_balances: &mut u64,
-) -> Pubkey {
-    // Account for tokens not specified, creating one
-    let account = get_associated_token_address(owner, mint);
-    if get_token_account(&config.rpc_client, &account, mint).is_err() {
-        println!("Creating associated token account {} to receive stake pool tokens of mint {}, owned by {}", account, mint, owner);
-
-        let min_account_balance = config
-            .rpc_client
-            .get_minimum_balance_for_rent_exemption(spl_token::state::Account::LEN)
-            .unwrap();
-
-        #[allow(deprecated)]
-        instructions.push(create_associated_token_account(
-            &config.fee_payer.pubkey(),
-            owner,
-            mint,
-        ));
-
-        *rent_free_balances += min_account_balance;
-    } else {
-        println!("Using existing associated token account {} to receive stake pool tokens of mint {}, owned by {}", account, mint, owner);
-    }
-
-    account
-}
-
-fn command_deposit_stake(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    stake: &Pubkey,
-    withdraw_authority: Box<dyn Signer>,
-    pool_token_receiver_account: &Option<Pubkey>,
-    referrer_token_account: &Option<Pubkey>,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let stake_state = get_stake_state(&config.rpc_client, stake)?;
-
-    if config.verbose {
-        println!("Depositing stake account {:?}", stake_state);
-    }
-    let vote_account = match stake_state {
-        stake::state::StakeStateV2::Stake(_, stake, _) => Ok(stake.delegation.voter_pubkey),
-        _ => Err("Wrong stake account state, must be delegated to validator"),
-    }?;
-
-    // Check if this vote account has staking account in the pool
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let validator_stake_info = validator_list
-        .find(&vote_account)
-        .ok_or("Vote account not found in the stake pool")?;
-    let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-
-    // Calculate validator stake account address linked to the pool
-    let (validator_stake_account, _) = find_stake_program_address(
-        &spl_stake_pool::id(),
-        &vote_account,
-        stake_pool_address,
-        validator_seed,
-    );
-
-    let validator_stake_state = get_stake_state(&config.rpc_client, &validator_stake_account)?;
-    println!(
-        "Depositing stake {} into stake pool account {}",
-        stake, validator_stake_account
-    );
-    if config.verbose {
-        println!("{:?}", validator_stake_state);
-    }
-
-    let mut instructions: Vec<Instruction> = vec![];
-    let mut signers = vec![config.fee_payer.as_ref(), withdraw_authority.as_ref()];
-
-    let mut total_rent_free_balances: u64 = 0;
-
-    // Create token account if not specified
-    let pool_token_receiver_account =
-        pool_token_receiver_account.unwrap_or(add_associated_token_account(
-            config,
-            &stake_pool.pool_mint,
-            &config.token_owner.pubkey(),
-            &mut instructions,
-            &mut total_rent_free_balances,
-        ));
-
-    let referrer_token_account = referrer_token_account.unwrap_or(pool_token_receiver_account);
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-
-    let mut deposit_instructions =
-        if let Some(stake_deposit_authority) = config.funding_authority.as_ref() {
-            signers.push(stake_deposit_authority.as_ref());
-            if stake_deposit_authority.pubkey() != stake_pool.stake_deposit_authority {
-                let error = format!(
-                    "Invalid deposit authority specified, expected {}, received {}",
-                    stake_pool.stake_deposit_authority,
-                    stake_deposit_authority.pubkey()
-                );
-                return Err(error.into());
-            }
-
-            spl_stake_pool::instruction::deposit_stake_with_authority(
-                &spl_stake_pool::id(),
-                stake_pool_address,
-                &stake_pool.validator_list,
-                &stake_deposit_authority.pubkey(),
-                &pool_withdraw_authority,
-                stake,
-                &withdraw_authority.pubkey(),
-                &validator_stake_account,
-                &stake_pool.reserve_stake,
-                &pool_token_receiver_account,
-                &stake_pool.manager_fee_account,
-                &referrer_token_account,
-                &stake_pool.pool_mint,
-                &spl_token::id(),
-            )
-        } else {
-            spl_stake_pool::instruction::deposit_stake(
-                &spl_stake_pool::id(),
-                stake_pool_address,
-                &stake_pool.validator_list,
-                &pool_withdraw_authority,
-                stake,
-                &withdraw_authority.pubkey(),
-                &validator_stake_account,
-                &stake_pool.reserve_stake,
-                &pool_token_receiver_account,
-                &stake_pool.manager_fee_account,
-                &referrer_token_account,
-                &stake_pool.pool_mint,
-                &spl_token::id(),
-            )
-        };
-
-    instructions.append(&mut deposit_instructions);
-
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers_and_additional_fee(
-        config,
-        &instructions,
-        &signers,
-        total_rent_free_balances,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_deposit_all_stake(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    stake_authority: &Pubkey,
-    withdraw_authority: Box<dyn Signer>,
-    pool_token_receiver_account: &Option<Pubkey>,
-    referrer_token_account: &Option<Pubkey>,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_addresses = get_all_stake(&config.rpc_client, stake_authority)?;
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-
-    // Create token account if not specified
-    let mut total_rent_free_balances = 0;
-    let mut create_token_account_instructions = vec![];
-    let pool_token_receiver_account =
-        pool_token_receiver_account.unwrap_or(add_associated_token_account(
-            config,
-            &stake_pool.pool_mint,
-            &config.token_owner.pubkey(),
-            &mut create_token_account_instructions,
-            &mut total_rent_free_balances,
-        ));
-    if !create_token_account_instructions.is_empty() {
-        let transaction = checked_transaction_with_signers_and_additional_fee(
-            config,
-            &create_token_account_instructions,
-            &[config.fee_payer.as_ref()],
-            total_rent_free_balances,
-        )?;
-        send_transaction(config, transaction)?;
-    }
-
-    let referrer_token_account = referrer_token_account.unwrap_or(pool_token_receiver_account);
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let mut signers = if let Some(stake_deposit_authority) = config.funding_authority.as_ref() {
-        if stake_deposit_authority.pubkey() != stake_pool.stake_deposit_authority {
-            let error = format!(
-                "Invalid deposit authority specified, expected {}, received {}",
-                stake_pool.stake_deposit_authority,
-                stake_deposit_authority.pubkey()
-            );
-            return Err(error.into());
-        }
-
-        vec![
-            config.fee_payer.as_ref(),
-            withdraw_authority.as_ref(),
-            stake_deposit_authority.as_ref(),
-        ]
-    } else {
-        vec![config.fee_payer.as_ref(), withdraw_authority.as_ref()]
-    };
-    unique_signers!(signers);
-
-    for stake_address in stake_addresses {
-        let stake_state = get_stake_state(&config.rpc_client, &stake_address)?;
-
-        let vote_account = match stake_state {
-            stake::state::StakeStateV2::Stake(_, stake, _) => Ok(stake.delegation.voter_pubkey),
-            _ => Err("Wrong stake account state, must be delegated to validator"),
-        }?;
-
-        let validator_stake_info = validator_list
-            .find(&vote_account)
-            .ok_or("Vote account not found in the stake pool")?;
-        let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-
-        // Calculate validator stake account address linked to the pool
-        let (validator_stake_account, _) = find_stake_program_address(
-            &spl_stake_pool::id(),
-            &vote_account,
-            stake_pool_address,
-            validator_seed,
-        );
-
-        let validator_stake_state = get_stake_state(&config.rpc_client, &validator_stake_account)?;
-        println!("Depositing user stake {}: {:?}", stake_address, stake_state);
-        println!(
-            "..into pool stake {}: {:?}",
-            validator_stake_account, validator_stake_state
-        );
-
-        let instructions = if let Some(stake_deposit_authority) = config.funding_authority.as_ref()
-        {
-            spl_stake_pool::instruction::deposit_stake_with_authority(
-                &spl_stake_pool::id(),
-                stake_pool_address,
-                &stake_pool.validator_list,
-                &stake_deposit_authority.pubkey(),
-                &pool_withdraw_authority,
-                &stake_address,
-                &withdraw_authority.pubkey(),
-                &validator_stake_account,
-                &stake_pool.reserve_stake,
-                &pool_token_receiver_account,
-                &stake_pool.manager_fee_account,
-                &referrer_token_account,
-                &stake_pool.pool_mint,
-                &spl_token::id(),
-            )
-        } else {
-            spl_stake_pool::instruction::deposit_stake(
-                &spl_stake_pool::id(),
-                stake_pool_address,
-                &stake_pool.validator_list,
-                &pool_withdraw_authority,
-                &stake_address,
-                &withdraw_authority.pubkey(),
-                &validator_stake_account,
-                &stake_pool.reserve_stake,
-                &pool_token_receiver_account,
-                &stake_pool.manager_fee_account,
-                &referrer_token_account,
-                &stake_pool.pool_mint,
-                &spl_token::id(),
-            )
-        };
-
-        let transaction = checked_transaction_with_signers(config, &instructions, &signers)?;
-        send_transaction(config, transaction)?;
-    }
-    Ok(())
-}
-
-fn command_deposit_sol(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    from: &Option<Keypair>,
-    pool_token_receiver_account: &Option<Pubkey>,
-    referrer_token_account: &Option<Pubkey>,
-    amount: f64,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let amount = native_token::sol_to_lamports(amount);
-
-    // Check withdraw_from balance
-    let from_pubkey = from
-        .as_ref()
-        .map_or_else(|| config.fee_payer.pubkey(), |keypair| keypair.pubkey());
-    let from_balance = config.rpc_client.get_balance(&from_pubkey)?;
-    if from_balance < amount {
-        return Err(format!(
-            "Not enough SOL to deposit into pool: {}.\nMaximum deposit amount is {} SOL.",
-            Sol(amount),
-            Sol(from_balance)
-        )
-        .into());
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-
-    let mut instructions: Vec<Instruction> = vec![];
-
-    // ephemeral SOL account just to do the transfer
-    let user_sol_transfer = Keypair::new();
-    let mut signers = vec![config.fee_payer.as_ref(), &user_sol_transfer];
-    if let Some(keypair) = from.as_ref() {
-        signers.push(keypair)
-    }
-
-    let mut total_rent_free_balances: u64 = 0;
-
-    // Create the ephemeral SOL account
-    instructions.push(system_instruction::transfer(
-        &from_pubkey,
-        &user_sol_transfer.pubkey(),
-        amount,
-    ));
-
-    // Create token account if not specified
-    let pool_token_receiver_account =
-        pool_token_receiver_account.unwrap_or(add_associated_token_account(
-            config,
-            &stake_pool.pool_mint,
-            &config.token_owner.pubkey(),
-            &mut instructions,
-            &mut total_rent_free_balances,
-        ));
-
-    let referrer_token_account = referrer_token_account.unwrap_or(pool_token_receiver_account);
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-
-    let deposit_instruction = if let Some(deposit_authority) = config.funding_authority.as_ref() {
-        let expected_sol_deposit_authority = stake_pool.sol_deposit_authority.ok_or_else(|| {
-            "SOL deposit authority specified in arguments but stake pool has none".to_string()
-        })?;
-        signers.push(deposit_authority.as_ref());
-        if deposit_authority.pubkey() != expected_sol_deposit_authority {
-            let error = format!(
-                "Invalid deposit authority specified, expected {}, received {}",
-                expected_sol_deposit_authority,
-                deposit_authority.pubkey()
-            );
-            return Err(error.into());
-        }
-
-        spl_stake_pool::instruction::deposit_sol_with_authority(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &deposit_authority.pubkey(),
-            &pool_withdraw_authority,
-            &stake_pool.reserve_stake,
-            &user_sol_transfer.pubkey(),
-            &pool_token_receiver_account,
-            &stake_pool.manager_fee_account,
-            &referrer_token_account,
-            &stake_pool.pool_mint,
-            &spl_token::id(),
-            amount,
-        )
-    } else {
-        spl_stake_pool::instruction::deposit_sol(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &pool_withdraw_authority,
-            &stake_pool.reserve_stake,
-            &user_sol_transfer.pubkey(),
-            &pool_token_receiver_account,
-            &stake_pool.manager_fee_account,
-            &referrer_token_account,
-            &stake_pool.pool_mint,
-            &spl_token::id(),
-            amount,
-        )
-    };
-
-    instructions.push(deposit_instruction);
-
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers_and_additional_fee(
-        config,
-        &instructions,
-        &signers,
-        total_rent_free_balances,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_list(config: &Config, stake_pool_address: &Pubkey) -> CommandResult {
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let reserve_stake_account_address = stake_pool.reserve_stake.to_string();
-    let total_lamports = stake_pool.total_lamports;
-    let last_update_epoch = stake_pool.last_update_epoch;
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-    let max_number_of_validators = validator_list.header.max_validators;
-    let current_number_of_validators = validator_list.validators.len();
-    let pool_mint = get_token_mint(&config.rpc_client, &stake_pool.pool_mint)?;
-    let epoch_info = config.rpc_client.get_epoch_info()?;
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-    let reserve_stake = config.rpc_client.get_account(&stake_pool.reserve_stake)?;
-    let minimum_reserve_stake_balance = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(STAKE_STATE_LEN)?
-        + MINIMUM_RESERVE_LAMPORTS;
-    let cli_stake_pool_stake_account_infos = validator_list
-        .validators
-        .iter()
-        .map(|validator| {
-            let validator_seed = NonZeroU32::new(validator.validator_seed_suffix.into());
-            let (stake_account_address, _) = find_stake_program_address(
-                &spl_stake_pool::id(),
-                &validator.vote_account_address,
-                stake_pool_address,
-                validator_seed,
-            );
-            let (transient_stake_account_address, _) = find_transient_stake_program_address(
-                &spl_stake_pool::id(),
-                &validator.vote_account_address,
-                stake_pool_address,
-                validator.transient_seed_suffix.into(),
-            );
-            let update_required = u64::from(validator.last_update_epoch) != epoch_info.epoch;
-            CliStakePoolStakeAccountInfo {
-                vote_account_address: validator.vote_account_address.to_string(),
-                stake_account_address: stake_account_address.to_string(),
-                validator_active_stake_lamports: validator.active_stake_lamports.into(),
-                validator_last_update_epoch: validator.last_update_epoch.into(),
-                validator_lamports: validator.stake_lamports().unwrap(),
-                validator_transient_stake_account_address: transient_stake_account_address
-                    .to_string(),
-                validator_transient_stake_lamports: validator.transient_stake_lamports.into(),
-                update_required,
-            }
-        })
-        .collect();
-    let total_pool_tokens =
-        spl_token::amount_to_ui_amount(stake_pool.pool_token_supply, pool_mint.decimals);
-    let mut cli_stake_pool = CliStakePool::from((
-        *stake_pool_address,
-        stake_pool,
-        validator_list,
-        pool_withdraw_authority,
-    ));
-    let update_required = last_update_epoch != epoch_info.epoch;
-    let cli_stake_pool_details = CliStakePoolDetails {
-        reserve_stake_account_address,
-        reserve_stake_lamports: reserve_stake.lamports,
-        minimum_reserve_stake_balance,
-        stake_accounts: cli_stake_pool_stake_account_infos,
-        total_lamports,
-        total_pool_tokens,
-        current_number_of_validators: current_number_of_validators as u32,
-        max_number_of_validators,
-        update_required,
-    };
-    cli_stake_pool.details = Some(cli_stake_pool_details);
-    println!("{}", config.output_format.formatted_string(&cli_stake_pool));
-    Ok(())
-}
-
-fn command_update(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    force: bool,
-    no_merge: bool,
-    stale_only: bool,
-) -> CommandResult {
-    if config.no_update {
-        println!("Update requested, but --no-update flag specified, so doing nothing");
-        return Ok(());
-    }
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let epoch_info = config.rpc_client.get_epoch_info()?;
-
-    if stake_pool.last_update_epoch == epoch_info.epoch {
-        if force {
-            println!("Update not required, but --force flag specified, so doing it anyway");
-        } else {
-            println!("Update not required");
-            return Ok(());
-        }
-    }
-
-    let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-
-    let (mut update_list_instructions, final_instructions) = if stale_only {
-        spl_stake_pool::instruction::update_stale_stake_pool(
-            &spl_stake_pool::id(),
-            &stake_pool,
-            &validator_list,
-            stake_pool_address,
-            no_merge,
-            epoch_info.epoch,
-        )
-    } else {
-        spl_stake_pool::instruction::update_stake_pool(
-            &spl_stake_pool::id(),
-            &stake_pool,
-            &validator_list,
-            stake_pool_address,
-            no_merge,
-        )
-    };
-
-    let update_list_instructions_len = update_list_instructions.len();
-    if update_list_instructions_len > 0 {
-        let last_instruction = update_list_instructions.split_off(update_list_instructions_len - 1);
-        // send the first ones without waiting
-        for instruction in update_list_instructions {
-            let transaction = checked_transaction_with_signers(
-                config,
-                &[instruction],
-                &[config.fee_payer.as_ref()],
-            )?;
-            send_transaction_no_wait(config, transaction)?;
-        }
-
-        // wait on the last one
-        let transaction = checked_transaction_with_signers(
-            config,
-            &last_instruction,
-            &[config.fee_payer.as_ref()],
-        )?;
-        send_transaction(config, transaction)?;
-    }
-    let transaction = checked_transaction_with_signers(
-        config,
-        &final_instructions,
-        &[config.fee_payer.as_ref()],
-    )?;
-    send_transaction(config, transaction)?;
-
-    Ok(())
-}
-
-#[derive(PartialEq, Debug)]
-struct WithdrawAccount {
-    stake_address: Pubkey,
-    vote_address: Option<Pubkey>,
-    pool_amount: u64,
-}
-
-fn sorted_accounts<F>(
-    validator_list: &ValidatorList,
-    stake_pool: &StakePool,
-    get_info: F,
-) -> Vec<(Pubkey, u64, Option<Pubkey>)>
-where
-    F: Fn(&ValidatorStakeInfo) -> (Pubkey, u64, Option<Pubkey>),
-{
-    let mut result: Vec<(Pubkey, u64, Option<Pubkey>)> = validator_list
-        .validators
-        .iter()
-        .map(get_info)
-        .collect::<Vec<_>>();
-
-    result.sort_by(|left, right| {
-        if left.2 == stake_pool.preferred_withdraw_validator_vote_address {
-            Ordering::Less
-        } else if right.2 == stake_pool.preferred_withdraw_validator_vote_address {
-            Ordering::Greater
-        } else {
-            right.1.cmp(&left.1)
-        }
-    });
-
-    result
-}
-
-fn prepare_withdraw_accounts(
-    rpc_client: &RpcClient,
-    stake_pool: &StakePool,
-    pool_amount: u64,
-    stake_pool_address: &Pubkey,
-    skip_fee: bool,
-) -> Result<Vec<WithdrawAccount>, Error> {
-    let stake_minimum_delegation = rpc_client.get_stake_minimum_delegation()?;
-    let stake_pool_minimum_delegation = minimum_delegation(stake_minimum_delegation);
-    let min_balance = rpc_client
-        .get_minimum_balance_for_rent_exemption(STAKE_STATE_LEN)?
-        .saturating_add(stake_pool_minimum_delegation);
-    let pool_mint = get_token_mint(rpc_client, &stake_pool.pool_mint)?;
-    let validator_list: ValidatorList = get_validator_list(rpc_client, &stake_pool.validator_list)?;
-
-    let mut accounts: Vec<(Pubkey, u64, Option<Pubkey>)> = Vec::new();
-
-    accounts.append(&mut sorted_accounts(
-        &validator_list,
-        stake_pool,
-        |validator| {
-            let validator_seed = NonZeroU32::new(validator.validator_seed_suffix.into());
-            let (stake_account_address, _) = find_stake_program_address(
-                &spl_stake_pool::id(),
-                &validator.vote_account_address,
-                stake_pool_address,
-                validator_seed,
-            );
-
-            (
-                stake_account_address,
-                validator.active_stake_lamports.into(),
-                Some(validator.vote_account_address),
-            )
-        },
-    ));
-
-    accounts.append(&mut sorted_accounts(
-        &validator_list,
-        stake_pool,
-        |validator| {
-            let (transient_stake_account_address, _) = find_transient_stake_program_address(
-                &spl_stake_pool::id(),
-                &validator.vote_account_address,
-                stake_pool_address,
-                validator.transient_seed_suffix.into(),
-            );
-
-            (
-                transient_stake_account_address,
-                u64::from(validator.transient_stake_lamports).saturating_sub(min_balance),
-                Some(validator.vote_account_address),
-            )
-        },
-    ));
-
-    let reserve_stake = rpc_client.get_account(&stake_pool.reserve_stake)?;
-
-    accounts.push((
-        stake_pool.reserve_stake,
-        reserve_stake.lamports
-            - rpc_client.get_minimum_balance_for_rent_exemption(STAKE_STATE_LEN)?
-            - MINIMUM_RESERVE_LAMPORTS,
-        None,
-    ));
-
-    // Prepare the list of accounts to withdraw from
-    let mut withdraw_from: Vec<WithdrawAccount> = vec![];
-    let mut remaining_amount = pool_amount;
-
-    let fee = stake_pool.stake_withdrawal_fee;
-    let inverse_fee = Fee {
-        numerator: fee.denominator - fee.numerator,
-        denominator: fee.denominator,
-    };
-
-    // Go through available accounts and withdraw from largest to smallest
-    for (stake_address, lamports, vote_address_opt) in accounts {
-        if lamports <= min_balance {
-            continue;
-        }
-
-        let available_for_withdrawal_wo_fee =
-            stake_pool.calc_pool_tokens_for_deposit(lamports).unwrap();
-
-        let available_for_withdrawal = if skip_fee {
-            available_for_withdrawal_wo_fee
-        } else {
-            available_for_withdrawal_wo_fee * inverse_fee.denominator / inverse_fee.numerator
-        };
-
-        let pool_amount = u64::min(available_for_withdrawal, remaining_amount);
-
-        // Those accounts will be withdrawn completely with `claim` instruction
-        withdraw_from.push(WithdrawAccount {
-            stake_address,
-            vote_address: vote_address_opt,
-            pool_amount,
-        });
-        remaining_amount -= pool_amount;
-
-        if remaining_amount == 0 {
-            break;
-        }
-    }
-
-    // Not enough stake to withdraw the specified amount
-    if remaining_amount > 0 {
-        return Err(format!(
-            "No stake accounts found in this pool with enough balance to withdraw {} pool tokens.",
-            spl_token::amount_to_ui_amount(pool_amount, pool_mint.decimals)
-        )
-        .into());
-    }
-
-    Ok(withdraw_from)
-}
-
-fn command_withdraw_stake(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    use_reserve: bool,
-    vote_account_address: &Option<Pubkey>,
-    stake_receiver_param: &Option<Pubkey>,
-    pool_token_account: &Option<Pubkey>,
-    pool_amount: f64,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let pool_mint = get_token_mint(&config.rpc_client, &stake_pool.pool_mint)?;
-    let pool_amount = spl_token::ui_amount_to_amount(pool_amount, pool_mint.decimals);
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-
-    let pool_token_account = pool_token_account.unwrap_or(get_associated_token_address(
-        &config.token_owner.pubkey(),
-        &stake_pool.pool_mint,
-    ));
-    let token_account = get_token_account(
-        &config.rpc_client,
-        &pool_token_account,
-        &stake_pool.pool_mint,
-    )?;
-    let stake_account_rent_exemption = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(STAKE_STATE_LEN)?;
-
-    // Check withdraw_from balance
-    if token_account.amount < pool_amount {
-        return Err(format!(
-            "Not enough token balance to withdraw {} pool tokens.\nMaximum withdraw amount is {} pool tokens.",
-            spl_token::amount_to_ui_amount(pool_amount, pool_mint.decimals),
-            spl_token::amount_to_ui_amount(token_account.amount, pool_mint.decimals)
-        )
-        .into());
-    }
-
-    // Check for the delegated stake receiver
-    let maybe_stake_receiver_state = stake_receiver_param
-        .map(|stake_receiver_pubkey| {
-            let stake_account = config.rpc_client.get_account(&stake_receiver_pubkey).ok()?;
-            let stake_state: stake::state::StakeStateV2 =
-                deserialize(stake_account.data.as_slice())
-                    .map_err(|err| {
-                        format!("Invalid stake account {}: {}", stake_receiver_pubkey, err)
-                    })
-                    .ok()?;
-            if stake_state.delegation().is_some() && stake_account.owner == stake::program::id() {
-                Some(stake_state)
-            } else {
-                None
-            }
-        })
-        .flatten();
-
-    let stake_minimum_delegation = config.rpc_client.get_stake_minimum_delegation()?;
-    let stake_pool_minimum_delegation = minimum_delegation(stake_minimum_delegation);
-
-    let withdraw_accounts = if use_reserve {
-        vec![WithdrawAccount {
-            stake_address: stake_pool.reserve_stake,
-            vote_address: None,
-            pool_amount,
-        }]
-    } else if maybe_stake_receiver_state.is_some() {
-        let vote_account = maybe_stake_receiver_state
-            .unwrap()
-            .delegation()
-            .unwrap()
-            .voter_pubkey;
-        if let Some(vote_account_address) = vote_account_address {
-            if *vote_account_address != vote_account {
-                return Err(format!("Provided withdrawal vote account {} does not match delegation on stake receiver account {},
-                remove this flag or provide a different stake account delegated to {}", vote_account_address, vote_account, vote_account_address).into());
-            }
-        }
-        // Check if the vote account exists in the stake pool
-        let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-        let validator_stake_info = validator_list
-            .find(&vote_account)
-            .ok_or(format!("Provided stake account is delegated to a vote account {} which does not exist in the stake pool", vote_account))?;
-        let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-        let (stake_account_address, _) = find_stake_program_address(
-            &spl_stake_pool::id(),
-            &vote_account,
-            stake_pool_address,
-            validator_seed,
-        );
-        let stake_account = config.rpc_client.get_account(&stake_account_address)?;
-
-        let available_for_withdrawal = stake_pool
-            .calc_lamports_withdraw_amount(
-                stake_account
-                    .lamports
-                    .saturating_sub(stake_pool_minimum_delegation)
-                    .saturating_sub(stake_account_rent_exemption),
-            )
-            .unwrap();
-
-        if available_for_withdrawal < pool_amount {
-            return Err(format!(
-                "Not enough lamports available for withdrawal from {}, {} asked, {} available",
-                stake_account_address, pool_amount, available_for_withdrawal
-            )
-            .into());
-        }
-        vec![WithdrawAccount {
-            stake_address: stake_account_address,
-            vote_address: Some(vote_account),
-            pool_amount,
-        }]
-    } else if let Some(vote_account_address) = vote_account_address {
-        let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
-        let validator_stake_info = validator_list.find(vote_account_address).ok_or(format!(
-            "Provided vote account address {} does not exist in the stake pool",
-            vote_account_address
-        ))?;
-        let validator_seed = NonZeroU32::new(validator_stake_info.validator_seed_suffix.into());
-        let (stake_account_address, _) = find_stake_program_address(
-            &spl_stake_pool::id(),
-            vote_account_address,
-            stake_pool_address,
-            validator_seed,
-        );
-        let stake_account = config.rpc_client.get_account(&stake_account_address)?;
-
-        let available_for_withdrawal = stake_pool
-            .calc_lamports_withdraw_amount(
-                stake_account
-                    .lamports
-                    .saturating_sub(stake_pool_minimum_delegation)
-                    .saturating_sub(stake_account_rent_exemption),
-            )
-            .unwrap();
-
-        if available_for_withdrawal < pool_amount {
-            return Err(format!(
-                "Not enough lamports available for withdrawal from {}, {} asked, {} available",
-                stake_account_address, pool_amount, available_for_withdrawal
-            )
-            .into());
-        }
-        vec![WithdrawAccount {
-            stake_address: stake_account_address,
-            vote_address: Some(*vote_account_address),
-            pool_amount,
-        }]
-    } else {
-        // Get the list of accounts to withdraw from
-        prepare_withdraw_accounts(
-            &config.rpc_client,
-            &stake_pool,
-            pool_amount,
-            stake_pool_address,
-            stake_pool.manager_fee_account == pool_token_account,
-        )?
-    };
-
-    // Construct transaction to withdraw from withdraw_accounts account list
-    let mut instructions: Vec<Instruction> = vec![];
-    let user_transfer_authority = Keypair::new(); // ephemeral keypair just to do the transfer
-    let mut signers = vec![
-        config.fee_payer.as_ref(),
-        config.token_owner.as_ref(),
-        &user_transfer_authority,
-    ];
-    let mut new_stake_keypairs = vec![];
-
-    instructions.push(
-        // Approve spending token
-        spl_token::instruction::approve(
-            &spl_token::id(),
-            &pool_token_account,
-            &user_transfer_authority.pubkey(),
-            &config.token_owner.pubkey(),
-            &[],
-            pool_amount,
-        )?,
-    );
-
-    let mut total_rent_free_balances = 0;
-    // Go through prepared accounts and withdraw/claim them
-    for withdraw_account in withdraw_accounts {
-        // Convert pool tokens amount to lamports
-        let sol_withdraw_amount = stake_pool
-            .calc_lamports_withdraw_amount(withdraw_account.pool_amount)
-            .unwrap();
-
-        if let Some(vote_address) = withdraw_account.vote_address {
-            println!(
-                "Withdrawing {}, or {} pool tokens, from stake account {}, delegated to {}",
-                Sol(sol_withdraw_amount),
-                spl_token::amount_to_ui_amount(withdraw_account.pool_amount, pool_mint.decimals),
-                withdraw_account.stake_address,
-                vote_address,
-            );
-        } else {
-            println!(
-                "Withdrawing {}, or {} pool tokens, from stake account {}",
-                Sol(sol_withdraw_amount),
-                spl_token::amount_to_ui_amount(withdraw_account.pool_amount, pool_mint.decimals),
-                withdraw_account.stake_address,
-            );
-        }
-        let stake_receiver =
-            if (stake_receiver_param.is_none()) || (maybe_stake_receiver_state.is_some()) {
-                // Creating new account to split the stake into new account
-                let stake_keypair = new_stake_account(
-                    &config.fee_payer.pubkey(),
-                    &mut instructions,
-                    stake_account_rent_exemption,
-                );
-                let stake_pubkey = stake_keypair.pubkey();
-                total_rent_free_balances += stake_account_rent_exemption;
-                new_stake_keypairs.push(stake_keypair);
-                stake_pubkey
-            } else {
-                stake_receiver_param.unwrap()
-            };
-
-        instructions.push(spl_stake_pool::instruction::withdraw_stake(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &stake_pool.validator_list,
-            &pool_withdraw_authority,
-            &withdraw_account.stake_address,
-            &stake_receiver,
-            &config.staker.pubkey(),
-            &user_transfer_authority.pubkey(),
-            &pool_token_account,
-            &stake_pool.manager_fee_account,
-            &stake_pool.pool_mint,
-            &spl_token::id(),
-            withdraw_account.pool_amount,
-        ));
-    }
-
-    // Merging the stake with account provided by user
-    if maybe_stake_receiver_state.is_some() {
-        for new_stake_keypair in &new_stake_keypairs {
-            instructions.extend(stake::instruction::merge(
-                &stake_receiver_param.unwrap(),
-                &new_stake_keypair.pubkey(),
-                &config.fee_payer.pubkey(),
-            ));
-        }
-    }
-
-    for new_stake_keypair in &new_stake_keypairs {
-        signers.push(new_stake_keypair);
-    }
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers_and_additional_fee(
-        config,
-        &instructions,
-        &signers,
-        total_rent_free_balances,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_withdraw_sol(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    pool_token_account: &Option<Pubkey>,
-    sol_receiver: &Pubkey,
-    pool_amount: f64,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-    let pool_mint = get_token_mint(&config.rpc_client, &stake_pool.pool_mint)?;
-    let pool_amount = spl_token::ui_amount_to_amount(pool_amount, pool_mint.decimals);
-
-    let pool_token_account = pool_token_account.unwrap_or(get_associated_token_address(
-        &config.token_owner.pubkey(),
-        &stake_pool.pool_mint,
-    ));
-    let token_account = get_token_account(
-        &config.rpc_client,
-        &pool_token_account,
-        &stake_pool.pool_mint,
-    )?;
-
-    // Check withdraw_from balance
-    if token_account.amount < pool_amount {
-        return Err(format!(
-            "Not enough token balance to withdraw {} pool tokens.\nMaximum withdraw amount is {} pool tokens.",
-            spl_token::amount_to_ui_amount(pool_amount, pool_mint.decimals),
-            spl_token::amount_to_ui_amount(token_account.amount, pool_mint.decimals)
-        )
-        .into());
-    }
-
-    // Construct transaction to withdraw from withdraw_accounts account list
-    let user_transfer_authority = Keypair::new(); // ephemeral keypair just to do the transfer
-    let mut signers = vec![
-        config.fee_payer.as_ref(),
-        config.token_owner.as_ref(),
-        &user_transfer_authority,
-    ];
-
-    let mut instructions = vec![
-        // Approve spending token
-        spl_token::instruction::approve(
-            &spl_token::id(),
-            &pool_token_account,
-            &user_transfer_authority.pubkey(),
-            &config.token_owner.pubkey(),
-            &[],
-            pool_amount,
-        )?,
-    ];
-
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
-
-    let withdraw_instruction = if let Some(withdraw_authority) = config.funding_authority.as_ref() {
-        let expected_sol_withdraw_authority =
-            stake_pool.sol_withdraw_authority.ok_or_else(|| {
-                "SOL withdraw authority specified in arguments but stake pool has none".to_string()
-            })?;
-        signers.push(withdraw_authority.as_ref());
-        if withdraw_authority.pubkey() != expected_sol_withdraw_authority {
-            let error = format!(
-                "Invalid deposit withdraw specified, expected {}, received {}",
-                expected_sol_withdraw_authority,
-                withdraw_authority.pubkey()
-            );
-            return Err(error.into());
-        }
-
-        spl_stake_pool::instruction::withdraw_sol_with_authority(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &withdraw_authority.pubkey(),
-            &pool_withdraw_authority,
-            &user_transfer_authority.pubkey(),
-            &pool_token_account,
-            &stake_pool.reserve_stake,
-            sol_receiver,
-            &stake_pool.manager_fee_account,
-            &stake_pool.pool_mint,
-            &spl_token::id(),
-            pool_amount,
-        )
-    } else {
-        spl_stake_pool::instruction::withdraw_sol(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &pool_withdraw_authority,
-            &user_transfer_authority.pubkey(),
-            &pool_token_account,
-            &stake_pool.reserve_stake,
-            sol_receiver,
-            &stake_pool.manager_fee_account,
-            &stake_pool.pool_mint,
-            &spl_token::id(),
-            pool_amount,
-        )
-    };
-
-    instructions.push(withdraw_instruction);
-
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(config, &instructions, &signers)?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_set_manager(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    new_manager: &Option<Box<dyn Signer>>,
-    new_fee_receiver: &Option<Pubkey>,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-    let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
-
-    // If new accounts are missing in the arguments use the old ones
-    let (new_manager_pubkey, mut signers): (Pubkey, Vec<&dyn Signer>) = match new_manager {
-        None => (stake_pool.manager, vec![]),
-        Some(value) => (value.pubkey(), vec![value.as_ref()]),
-    };
-
-    let new_fee_receiver = match new_fee_receiver {
-        None => stake_pool.manager_fee_account,
-        Some(value) => {
-            // Check for fee receiver being a valid token account and have to same mint as
-            // the stake pool
-            let token_account =
-                get_token_account(&config.rpc_client, value, &stake_pool.pool_mint)?;
-            if token_account.mint != stake_pool.pool_mint {
-                return Err("Fee receiver account belongs to a different mint"
-                    .to_string()
-                    .into());
-            }
-            *value
-        }
-    };
-
-    signers.append(&mut vec![
-        config.fee_payer.as_ref(),
-        config.manager.as_ref(),
-    ]);
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[spl_stake_pool::instruction::set_manager(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &config.manager.pubkey(),
-            &new_manager_pubkey,
-            &new_fee_receiver,
-        )],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_set_staker(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    new_staker: &Pubkey,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-    let mut signers = vec![config.fee_payer.as_ref(), config.manager.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[spl_stake_pool::instruction::set_staker(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &config.manager.pubkey(),
-            new_staker,
-        )],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_set_funding_authority(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    new_authority: Option<Pubkey>,
-    funding_type: FundingType,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-    let mut signers = vec![config.fee_payer.as_ref(), config.manager.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[spl_stake_pool::instruction::set_funding_authority(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &config.manager.pubkey(),
-            new_authority.as_ref(),
-            funding_type,
-        )],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_set_fee(
-    config: &Config,
-    stake_pool_address: &Pubkey,
-    new_fee: FeeType,
-) -> CommandResult {
-    if !config.no_update {
-        command_update(config, stake_pool_address, false, false, false)?;
-    }
-    let mut signers = vec![config.fee_payer.as_ref(), config.manager.as_ref()];
-    unique_signers!(signers);
-    let transaction = checked_transaction_with_signers(
-        config,
-        &[spl_stake_pool::instruction::set_fee(
-            &spl_stake_pool::id(),
-            stake_pool_address,
-            &config.manager.pubkey(),
-            new_fee,
-        )],
-        &signers,
-    )?;
-    send_transaction(config, transaction)?;
-    Ok(())
-}
-
-fn command_list_all_pools(config: &Config) -> CommandResult {
-    let all_pools = get_stake_pools(&config.rpc_client)?;
-    let cli_stake_pool_vec: Vec<CliStakePool> =
-        all_pools.into_iter().map(CliStakePool::from).collect();
-    let cli_stake_pools = CliStakePools {
-        pools: cli_stake_pool_vec,
-    };
-    println!(
-        "{}",
-        config.output_format.formatted_string(&cli_stake_pools)
-    );
-    Ok(())
-}
-
-fn main() {
-    solana_logger::setup_with_default("solana=info");
-
-    let matches = App::new(crate_name!())
-        .about(crate_description!())
-        .version(crate_version!())
-        .setting(AppSettings::SubcommandRequiredElseHelp)
-        .arg({
-            let arg = Arg::with_name("config_file")
-                .short("C")
-                .long("config")
-                .value_name("PATH")
-                .takes_value(true)
-                .global(true)
-                .help("Configuration file to use");
-            if let Some(ref config_file) = *solana_cli_config::CONFIG_FILE {
-                arg.default_value(config_file)
-            } else {
-                arg
-            }
-        })
-        .arg(
-            Arg::with_name("verbose")
-                .long("verbose")
-                .short("v")
-                .takes_value(false)
-                .global(true)
-                .help("Show additional information"),
-        )
-        .arg(
-            Arg::with_name("output_format")
-                .long("output")
-                .value_name("FORMAT")
-                .global(true)
-                .takes_value(true)
-                .possible_values(&["json", "json-compact"])
-                .help("Return information in specified output format"),
-        )
-        .arg(
-            Arg::with_name("dry_run")
-                .long("dry-run")
-                .takes_value(false)
-                .global(true)
-                .help("Simulate transaction instead of executing"),
-        )
-        .arg(
-            Arg::with_name("no_update")
-                .long("no-update")
-                .takes_value(false)
-                .global(true)
-                .help("Do not automatically update the stake pool if needed"),
-        )
-        .arg(
-            Arg::with_name("json_rpc_url")
-                .long("url")
-                .value_name("URL")
-                .takes_value(true)
-                .validator(is_url)
-                .global(true)
-                .help("JSON RPC URL for the cluster.  Default from the configuration file."),
-        )
-        .arg(
-            Arg::with_name("staker")
-                .long("staker")
-                .value_name("KEYPAIR")
-                .validator(is_valid_signer)
-                .takes_value(true)
-                .global(true)
-                .help("Stake pool staker. [default: cli config keypair]"),
-        )
-        .arg(
-            Arg::with_name("manager")
-                .long("manager")
-                .value_name("KEYPAIR")
-                .validator(is_valid_signer)
-                .takes_value(true)
-                .global(true)
-                .help("Stake pool manager. [default: cli config keypair]"),
-        )
-        .arg(
-            Arg::with_name("funding_authority")
-                .long("funding-authority")
-                .value_name("KEYPAIR")
-                .validator(is_valid_signer)
-                .takes_value(true)
-                .global(true)
-                .help("Stake pool funding authority for deposits or withdrawals. [default: cli config keypair]"),
-        )
-        .arg(
-            Arg::with_name("token_owner")
-                .long("token-owner")
-                .value_name("KEYPAIR")
-                .validator(is_valid_signer)
-                .takes_value(true)
-                .global(true)
-                .help("Owner of pool token account [default: cli config keypair]"),
-        )
-        .arg(
-            Arg::with_name("fee_payer")
-                .long("fee-payer")
-                .value_name("KEYPAIR")
-                .validator(is_valid_signer)
-                .takes_value(true)
-                .global(true)
-                .help("Transaction fee payer account [default: cli config keypair]"),
-        )
-        .arg(compute_unit_price_arg().validator(is_parsable::<u64>).global(true))
-        .arg(
-            Arg::with_name(COMPUTE_UNIT_LIMIT_ARG.name)
-                .long(COMPUTE_UNIT_LIMIT_ARG.long)
-                .takes_value(true)
-                .value_name("COMPUTE-UNIT-LIMIT")
-                .help(COMPUTE_UNIT_LIMIT_ARG.help)
-                .validator(is_compute_unit_limit_or_simulated)
-                .global(true)
-        )
-        .subcommand(SubCommand::with_name("create-pool")
-            .about("Create a new stake pool")
-            .arg(
-                Arg::with_name("epoch_fee_numerator")
-                    .long("epoch-fee-numerator")
-                    .short("n")
-                    .validator(is_parsable::<u64>)
-                    .value_name("NUMERATOR")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Epoch fee numerator, fee amount is numerator divided by denominator."),
-            )
-            .arg(
-                Arg::with_name("epoch_fee_denominator")
-                    .long("epoch-fee-denominator")
-                    .short("d")
-                    .validator(is_parsable::<u64>)
-                    .value_name("DENOMINATOR")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Epoch fee denominator, fee amount is numerator divided by denominator."),
-            )
-            .arg(
-                Arg::with_name("withdrawal_fee_numerator")
-                    .long("withdrawal-fee-numerator")
-                    .validator(is_parsable::<u64>)
-                    .value_name("NUMERATOR")
-                    .takes_value(true)
-                    .requires("withdrawal_fee_denominator")
-                    .help("Withdrawal fee numerator, fee amount is numerator divided by denominator [default: 0]"),
-            ).arg(
-                Arg::with_name("withdrawal_fee_denominator")
-                    .long("withdrawal-fee-denominator")
-                    .validator(is_parsable::<u64>)
-                    .value_name("DENOMINATOR")
-                    .takes_value(true)
-                    .requires("withdrawal_fee_numerator")
-                    .help("Withdrawal fee denominator, fee amount is numerator divided by denominator [default: 0]"),
-            )
-            .arg(
-                Arg::with_name("deposit_fee_numerator")
-                    .long("deposit-fee-numerator")
-                    .validator(is_parsable::<u64>)
-                    .value_name("NUMERATOR")
-                    .takes_value(true)
-                    .requires("deposit_fee_denominator")
-                    .help("Deposit fee numerator, fee amount is numerator divided by denominator [default: 0]"),
-            ).arg(
-                Arg::with_name("deposit_fee_denominator")
-                    .long("deposit-fee-denominator")
-                    .validator(is_parsable::<u64>)
-                    .value_name("DENOMINATOR")
-                    .takes_value(true)
-                    .requires("deposit_fee_numerator")
-                    .help("Deposit fee denominator, fee amount is numerator divided by denominator [default: 0]"),
-            )
-            .arg(
-                Arg::with_name("referral_fee")
-                    .long("referral-fee")
-                    .validator(is_valid_percentage)
-                    .value_name("FEE_PERCENTAGE")
-                    .takes_value(true)
-                    .help("Referral fee percentage, maximum 100"),
-            )
-            .arg(
-                Arg::with_name("max_validators")
-                    .long("max-validators")
-                    .short("m")
-                    .validator(is_parsable::<u32>)
-                    .value_name("NUMBER")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Max number of validators included in the stake pool"),
-            )
-            .arg(
-                Arg::with_name("deposit_authority")
-                    .long("deposit-authority")
-                    .short("a")
-                    .validator(is_valid_signer)
-                    .value_name("DEPOSIT_AUTHORITY_KEYPAIR")
-                    .takes_value(true)
-                    .help("Deposit authority required to sign all deposits into the stake pool"),
-            )
-            .arg(
-                Arg::with_name("pool_keypair")
-                    .long("pool-keypair")
-                    .short("p")
-                    .validator(is_keypair_or_ask_keyword)
-                    .value_name("PATH")
-                    .takes_value(true)
-                    .help("Stake pool keypair [default: new keypair]"),
-            )
-            .arg(
-                Arg::with_name("validator_list_keypair")
-                    .long("validator-list-keypair")
-                    .validator(is_keypair_or_ask_keyword)
-                    .value_name("PATH")
-                    .takes_value(true)
-                    .help("Validator list keypair [default: new keypair]"),
-            )
-            .arg(
-                Arg::with_name("mint_keypair")
-                    .long("mint-keypair")
-                    .validator(is_keypair_or_ask_keyword)
-                    .value_name("PATH")
-                    .takes_value(true)
-                    .help("Stake pool mint keypair [default: new keypair]"),
-            )
-            .arg(
-                Arg::with_name("reserve_keypair")
-                    .long("reserve-keypair")
-                    .validator(is_keypair_or_ask_keyword)
-                    .value_name("PATH")
-                    .takes_value(true)
-                    .help("Stake pool reserve keypair [default: new keypair]"),
-            )
-            .arg(
-                Arg::with_name("unsafe_fees")
-                    .long("unsafe-fees")
-                    .takes_value(false)
-                    .help("Bypass fee checks, allowing pool to be created with unsafe fees"),
-            )
-        )
-        .subcommand(SubCommand::with_name("create-token-metadata")
-        .about("Creates stake pool token metadata")
-        .arg(
-            Arg::with_name("pool")
-                .index(1)
-                .validator(is_pubkey)
-                .value_name("POOL_ADDRESS")
-                .takes_value(true)
-                .required(true)
-                .help("Stake pool address"),
-        )
-        .arg(
-            Arg::with_name("name")
-                .index(2)
-                .value_name("TOKEN_NAME")
-                .takes_value(true)
-                .required(true)
-                .help("Name of the token"),
-        )
-        .arg(
-            Arg::with_name("symbol")
-                .index(3)
-                .value_name("TOKEN_SYMBOL")
-                .takes_value(true)
-                .required(true)
-                .help("Symbol of the token"),
-        )
-        .arg(
-            Arg::with_name("uri")
-                .index(4)
-                .value_name("TOKEN_URI")
-                .takes_value(true)
-                .required(true)
-                .help("URI of the token metadata json"),
-        )
-    )
-    .subcommand(SubCommand::with_name("update-token-metadata")
-    .about("Updates stake pool token metadata")
-    .arg(
-        Arg::with_name("pool")
-            .index(1)
-            .validator(is_pubkey)
-            .value_name("POOL_ADDRESS")
-            .takes_value(true)
-            .required(true)
-            .help("Stake pool address"),
-    )
-    .arg(
-        Arg::with_name("name")
-            .index(2)
-            .value_name("TOKEN_NAME")
-            .takes_value(true)
-            .required(true)
-            .help("Name of the token"),
-    )
-    .arg(
-        Arg::with_name("symbol")
-            .index(3)
-            .value_name("TOKEN_SYMBOL")
-            .takes_value(true)
-            .required(true)
-            .help("Symbol of the token"),
-    )
-    .arg(
-        Arg::with_name("uri")
-            .index(4)
-            .value_name("TOKEN_URI")
-            .takes_value(true)
-            .required(true)
-            .help("URI of the token metadata json"),
-        )
-    )
-        .subcommand(SubCommand::with_name("add-validator")
-            .about("Add validator account to the stake pool. Must be signed by the pool staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("The validator vote account that the stake is delegated to"),
-            )
-        )
-        .subcommand(SubCommand::with_name("remove-validator")
-            .about("Remove validator account from the stake pool. Must be signed by the pool staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Vote account for the validator to remove from the pool"),
-            )
-        )
-        .subcommand(SubCommand::with_name("increase-validator-stake")
-            .about("Increase stake to a validator, drawing from the stake pool reserve. Must be signed by the pool staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Vote account for the validator to increase stake to"),
-            )
-            .arg(
-                Arg::with_name("amount")
-                    .index(3)
-                    .validator(is_amount)
-                    .value_name("AMOUNT")
-                    .takes_value(true)
-                    .help("Amount in SOL to add to the validator stake account. Must be at least the rent-exempt amount for a stake plus 1 SOL for merging."),
-            )
-        )
-        .subcommand(SubCommand::with_name("decrease-validator-stake")
-            .about("Decrease stake to a validator, splitting from the active stake. Must be signed by the pool staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Vote account for the validator to decrease stake from"),
-            )
-            .arg(
-                Arg::with_name("amount")
-                    .index(3)
-                    .validator(is_amount)
-                    .value_name("AMOUNT")
-                    .takes_value(true)
-                    .help("Amount in SOL to remove from the validator stake account. Must be at least the rent-exempt amount for a stake."),
-            )
-        )
-        .subcommand(SubCommand::with_name("set-preferred-validator")
-            .about("Set the preferred validator for deposits or withdrawals. Must be signed by the pool staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("preferred_type")
-                    .index(2)
-                    .value_name("OPERATION")
-                    .possible_values(&["deposit", "withdraw"]) // PreferredValidatorType enum
-                    .takes_value(true)
-                    .required(true)
-                    .help("Operation for which to restrict the validator"),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .long("vote-account")
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .help("Vote account for the validator that users must deposit into."),
-            )
-            .arg(
-                Arg::with_name("unset")
-                    .long("unset")
-                    .takes_value(false)
-                    .help("Unset the preferred validator."),
-            )
-            .group(ArgGroup::with_name("validator")
-                .arg("vote_account")
-                .arg("unset")
-                .required(true)
-            )
-        )
-        .subcommand(SubCommand::with_name("deposit-stake")
-            .about("Deposit active stake account into the stake pool in exchange for pool tokens")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("stake_account")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("STAKE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake address to join the pool"),
-            )
-            .arg(
-                Arg::with_name("withdraw_authority")
-                    .long("withdraw-authority")
-                    .validator(is_valid_signer)
-                    .value_name("KEYPAIR")
-                    .takes_value(true)
-                    .help("Withdraw authority for the stake account to be deposited. [default: cli config keypair]"),
-            )
-            .arg(
-                Arg::with_name("token_receiver")
-                    .long("token-receiver")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Account to receive the minted pool tokens. \
-                          Defaults to the token-owner's associated pool token account. \
-                          Creates the account if it does not exist."),
-            )
-            .arg(
-                Arg::with_name("referrer")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Pool token account to receive the referral fees for deposits. \
-                          Defaults to the token receiver."),
-            )
-        )
-        .subcommand(SubCommand::with_name("deposit-all-stake")
-            .about("Deposit all active stake accounts into the stake pool in exchange for pool tokens")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            )
-            .arg(
-                Arg::with_name("stake_authority")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake authority address to search for stake accounts"),
-            )
-            .arg(
-                Arg::with_name("withdraw_authority")
-                    .long("withdraw-authority")
-                    .validator(is_valid_signer)
-                    .value_name("KEYPAIR")
-                    .takes_value(true)
-                    .help("Withdraw authority for the stake account to be deposited. [default: cli config keypair]"),
-            )
-            .arg(
-                Arg::with_name("token_receiver")
-                    .long("token-receiver")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Account to receive the minted pool tokens. \
-                          Defaults to the token-owner's associated pool token account. \
-                          Creates the account if it does not exist."),
-            )
-            .arg(
-                Arg::with_name("referrer")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Pool token account to receive the referral fees for deposits. \
-                          Defaults to the token receiver."),
-            )
-        )
-        .subcommand(SubCommand::with_name("deposit-sol")
-            .about("Deposit SOL into the stake pool in exchange for pool tokens")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address"),
-            ).arg(
-                Arg::with_name("amount")
-                    .index(2)
-                    .validator(is_amount)
-                    .value_name("AMOUNT")
-                    .takes_value(true)
-                    .help("Amount in SOL to deposit into the stake pool reserve account."),
-            )
-            .arg(
-                Arg::with_name("from")
-                    .long("from")
-                    .validator(is_valid_signer)
-                    .value_name("KEYPAIR")
-                    .takes_value(true)
-                    .help("Source account of funds. [default: cli config keypair]"),
-            )
-            .arg(
-                Arg::with_name("token_receiver")
-                    .long("token-receiver")
-                    .validator(is_pubkey)
-                    .value_name("POOL_TOKEN_RECEIVER_ADDRESS")
-                    .takes_value(true)
-                    .help("Account to receive the minted pool tokens. \
-                          Defaults to the token-owner's associated pool token account. \
-                          Creates the account if it does not exist."),
-            )
-            .arg(
-                Arg::with_name("referrer")
-                    .long("referrer")
-                    .validator(is_pubkey)
-                    .value_name("REFERRER_TOKEN_ADDRESS")
-                    .takes_value(true)
-                    .help("Account to receive the referral fees for deposits. \
-                          Defaults to the token receiver."),
-            )
-        )
-        .subcommand(SubCommand::with_name("list")
-            .about("List stake accounts managed by this pool")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-        )
-        .subcommand(SubCommand::with_name("update")
-            .about("Updates all balances in the pool after validator stake accounts receive rewards.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("force")
-                    .long("force")
-                    .takes_value(false)
-                    .help("Update balances, even if it has already been performed this epoch."),
-            )
-            .arg(
-                Arg::with_name("no_merge")
-                    .long("no-merge")
-                    .takes_value(false)
-                    .help("Do not automatically merge transient stakes. Useful if the stake pool is in an expected state, but the balances still need to be updated."),
-            )
-            .arg(
-                Arg::with_name("stale_only")
-                    .long("stale-only")
-                    .takes_value(false)
-                    .help("If set, only updates validator list balances that have not been updated for this epoch. Otherwise, updates all validator balances on the validator list."),
-            )
-        )
-        .subcommand(SubCommand::with_name("withdraw-stake")
-            .about("Withdraw active stake from the stake pool in exchange for pool tokens")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("amount")
-                    .index(2)
-                    .validator(is_amount)
-                    .value_name("AMOUNT")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Amount of pool tokens to withdraw for activated stake."),
-            )
-            .arg(
-                Arg::with_name("pool_account")
-                    .long("pool-account")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Pool token account to withdraw tokens from. Defaults to the token-owner's associated token account."),
-            )
-            .arg(
-                Arg::with_name("stake_receiver")
-                    .long("stake-receiver")
-                    .validator(is_pubkey)
-                    .value_name("STAKE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .requires("withdraw_from")
-                    .help("Stake account from which to receive a stake from the stake pool. Defaults to a new stake account."),
-            )
-            .arg(
-                Arg::with_name("vote_account")
-                    .long("vote-account")
-                    .validator(is_pubkey)
-                    .value_name("VOTE_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .help("Validator to withdraw from. Defaults to the largest validator stakes in the pool."),
-            )
-            .arg(
-                Arg::with_name("use_reserve")
-                    .long("use-reserve")
-                    .takes_value(false)
-                    .help("Withdraw from the stake pool's reserve. Only possible if all validator stakes are at the minimum possible amount."),
-            )
-            .group(ArgGroup::with_name("withdraw_from")
-                .arg("use_reserve")
-                .arg("vote_account")
-            )
-        )
-        .subcommand(SubCommand::with_name("withdraw-sol")
-            .about("Withdraw SOL from the stake pool's reserve in exchange for pool tokens")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("sol_receiver")
-                    .index(2)
-                    .validator(is_valid_pubkey)
-                    .value_name("SYSTEM_ACCOUNT_ADDRESS_OR_KEYPAIR")
-                    .takes_value(true)
-                    .required(true)
-                    .help("System account to receive SOL from the stake pool. Defaults to the payer."),
-            )
-            .arg(
-                Arg::with_name("amount")
-                    .index(3)
-                    .validator(is_amount)
-                    .value_name("AMOUNT")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Amount of pool tokens to withdraw for SOL."),
-            )
-            .arg(
-                Arg::with_name("pool_account")
-                    .long("pool-account")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Pool token account to withdraw tokens from. Defaults to the token-owner's associated token account."),
-            )
-        )
-        .subcommand(SubCommand::with_name("set-manager")
-            .about("Change manager or fee receiver account for the stake pool. Must be signed by the current manager.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("new_manager")
-                    .long("new-manager")
-                    .validator(is_valid_signer)
-                    .value_name("KEYPAIR")
-                    .takes_value(true)
-                    .help("Keypair for the new stake pool manager."),
-            )
-            .arg(
-                Arg::with_name("new_fee_receiver")
-                    .long("new-fee-receiver")
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Public key for the new account to set as the stake pool fee receiver."),
-            )
-            .group(ArgGroup::with_name("new_accounts")
-                .arg("new_manager")
-                .arg("new_fee_receiver")
-                .required(true)
-                .multiple(true)
-            )
-        )
-        .subcommand(SubCommand::with_name("set-staker")
-            .about("Change staker account for the stake pool. Must be signed by the manager or current staker.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("new_staker")
-                    .index(2)
-                    .validator(is_pubkey)
-                    .value_name("ADDRESS")
-                    .takes_value(true)
-                    .help("Public key for the new stake pool staker."),
-            )
-        )
-        .subcommand(SubCommand::with_name("set-funding-authority")
-            .about("Change one of the funding authorities for the stake pool. Must be signed by the manager.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(
-                Arg::with_name("funding_type")
-                    .index(2)
-                    .value_name("FUNDING_TYPE")
-                    .possible_values(&["stake-deposit", "sol-deposit", "sol-withdraw"]) // FundingType enum
-                    .takes_value(true)
-                    .required(true)
-                    .help("Funding type to be updated."),
-            )
-            .arg(
-                Arg::with_name("new_authority")
-                    .index(3)
-                    .validator(is_pubkey)
-                    .value_name("AUTHORITY_ADDRESS")
-                    .takes_value(true)
-                    .help("Public key for the new stake pool funding authority."),
-            )
-            .arg(
-                Arg::with_name("unset")
-                    .long("unset")
-                    .takes_value(false)
-                    .help("Unset the stake deposit authority. The program will use a program derived address.")
-            )
-            .group(ArgGroup::with_name("validator")
-                .arg("new_authority")
-                .arg("unset")
-                .required(true)
-            )
-        )
-        .subcommand(SubCommand::with_name("set-fee")
-            .about("Change the [epoch/withdraw/stake deposit/sol deposit] fee assessed by the stake pool. Must be signed by the manager.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(Arg::with_name("fee_type")
-                .index(2)
-                .value_name("FEE_TYPE")
-                .possible_values(&["epoch", "stake-deposit", "sol-deposit", "stake-withdrawal", "sol-withdrawal"]) // FeeType enum
-                .takes_value(true)
-                .required(true)
-                .help("Fee type to be updated."),
-            )
-            .arg(
-                Arg::with_name("fee_numerator")
-                    .index(3)
-                    .validator(is_parsable::<u64>)
-                    .value_name("NUMERATOR")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Fee numerator, fee amount is numerator divided by denominator."),
-            )
-            .arg(
-                Arg::with_name("fee_denominator")
-                    .index(4)
-                    .validator(is_parsable::<u64>)
-                    .value_name("DENOMINATOR")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Fee denominator, fee amount is numerator divided by denominator."),
-            )
-        )
-        .subcommand(SubCommand::with_name("set-referral-fee")
-            .about("Change the referral fee assessed by the stake pool for stake deposits. Must be signed by the manager.")
-            .arg(
-                Arg::with_name("pool")
-                    .index(1)
-                    .validator(is_pubkey)
-                    .value_name("POOL_ADDRESS")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Stake pool address."),
-            )
-            .arg(Arg::with_name("fee_type")
-                .index(2)
-                .value_name("FEE_TYPE")
-                .possible_values(&["stake", "sol"]) // FeeType enum, kind of
-                .takes_value(true)
-                .required(true)
-                .help("Fee type to be updated."),
-            )
-            .arg(
-                Arg::with_name("fee")
-                    .index(3)
-                    .validator(is_valid_percentage)
-                    .value_name("FEE_PERCENTAGE")
-                    .takes_value(true)
-                    .required(true)
-                    .help("Fee percentage, maximum 100"),
-            )
-        )
-        .subcommand(SubCommand::with_name("list-all")
-            .about("List information about all stake pools")
-        )
-        .get_matches();
-
-    let mut wallet_manager = None;
-    let cli_config = if let Some(config_file) = matches.value_of("config_file") {
-        solana_cli_config::Config::load(config_file).unwrap_or_default()
-    } else {
-        solana_cli_config::Config::default()
-    };
-    let config = {
-        let json_rpc_url = value_t!(matches, "json_rpc_url", String)
-            .unwrap_or_else(|_| cli_config.json_rpc_url.clone());
-
-        let staker = get_signer(
-            &matches,
-            "staker",
-            &cli_config.keypair_path,
-            &mut wallet_manager,
-            SignerFromPathConfig {
-                allow_null_signer: false,
-            },
-        );
-
-        let funding_authority = if matches.is_present("funding_authority") {
-            Some(get_signer(
-                &matches,
-                "funding_authority",
-                &cli_config.keypair_path,
-                &mut wallet_manager,
-                SignerFromPathConfig {
-                    allow_null_signer: false,
-                },
-            ))
-        } else {
-            None
-        };
-        let manager = get_signer(
-            &matches,
-            "manager",
-            &cli_config.keypair_path,
-            &mut wallet_manager,
-            SignerFromPathConfig {
-                allow_null_signer: false,
-            },
-        );
-        let token_owner = get_signer(
-            &matches,
-            "token_owner",
-            &cli_config.keypair_path,
-            &mut wallet_manager,
-            SignerFromPathConfig {
-                allow_null_signer: false,
-            },
-        );
-        let fee_payer = get_signer(
-            &matches,
-            "fee_payer",
-            &cli_config.keypair_path,
-            &mut wallet_manager,
-            SignerFromPathConfig {
-                allow_null_signer: false,
-            },
-        );
-        let verbose = matches.is_present("verbose");
-        let output_format = matches
-            .value_of("output_format")
-            .map(|value| match value {
-                "json" => OutputFormat::Json,
-                "json-compact" => OutputFormat::JsonCompact,
-                _ => unreachable!(),
-            })
-            .unwrap_or(if verbose {
-                OutputFormat::DisplayVerbose
-            } else {
-                OutputFormat::Display
-            });
-        let dry_run = matches.is_present("dry_run");
-        let no_update = matches.is_present("no_update");
-        let compute_unit_price = value_t!(matches, COMPUTE_UNIT_PRICE_ARG.name, u64).ok();
-        let compute_unit_limit = matches
-            .value_of(COMPUTE_UNIT_LIMIT_ARG.name)
-            .map(|x| parse_compute_unit_limit(x).unwrap())
-            .unwrap_or_else(|| {
-                if compute_unit_price.is_some() {
-                    ComputeUnitLimit::Simulated
-                } else {
-                    ComputeUnitLimit::Default
-                }
-            });
-
-        Config {
-            rpc_client: RpcClient::new_with_commitment(json_rpc_url, CommitmentConfig::confirmed()),
-            verbose,
-            output_format,
-            manager,
-            staker,
-            funding_authority,
-            token_owner,
-            fee_payer,
-            dry_run,
-            no_update,
-            compute_unit_price,
-            compute_unit_limit,
-        }
-    };
-
-    let _ = match matches.subcommand() {
-        ("create-pool", Some(arg_matches)) => {
-            let deposit_authority = keypair_of(arg_matches, "deposit_authority");
-            let e_numerator = value_t_or_exit!(arg_matches, "epoch_fee_numerator", u64);
-            let e_denominator = value_t_or_exit!(arg_matches, "epoch_fee_denominator", u64);
-            let w_numerator = value_t!(arg_matches, "withdrawal_fee_numerator", u64);
-            let w_denominator = value_t!(arg_matches, "withdrawal_fee_denominator", u64);
-            let d_numerator = value_t!(arg_matches, "deposit_fee_numerator", u64);
-            let d_denominator = value_t!(arg_matches, "deposit_fee_denominator", u64);
-            let referral_fee = value_t!(arg_matches, "referral_fee", u8);
-            let max_validators = value_t_or_exit!(arg_matches, "max_validators", u32);
-            let pool_keypair = keypair_of(arg_matches, "pool_keypair");
-            let validator_list_keypair = keypair_of(arg_matches, "validator_list_keypair");
-            let mint_keypair = keypair_of(arg_matches, "mint_keypair");
-            let reserve_keypair = keypair_of(arg_matches, "reserve_keypair");
-            let unsafe_fees = arg_matches.is_present("unsafe_fees");
-            command_create_pool(
-                &config,
-                deposit_authority,
-                Fee {
-                    numerator: e_numerator,
-                    denominator: e_denominator,
-                },
-                Fee {
-                    numerator: w_numerator.unwrap_or(0),
-                    denominator: w_denominator.unwrap_or(0),
-                },
-                Fee {
-                    numerator: d_numerator.unwrap_or(0),
-                    denominator: d_denominator.unwrap_or(0),
-                },
-                referral_fee.unwrap_or(0),
-                max_validators,
-                pool_keypair,
-                validator_list_keypair,
-                mint_keypair,
-                reserve_keypair,
-                unsafe_fees,
-            )
-        }
-        ("create-token-metadata", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let name = value_t_or_exit!(arg_matches, "name", String);
-            let symbol = value_t_or_exit!(arg_matches, "symbol", String);
-            let uri = value_t_or_exit!(arg_matches, "uri", String);
-            create_token_metadata(&config, &stake_pool_address, name, symbol, uri)
-        }
-        ("update-token-metadata", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let name = value_t_or_exit!(arg_matches, "name", String);
-            let symbol = value_t_or_exit!(arg_matches, "symbol", String);
-            let uri = value_t_or_exit!(arg_matches, "uri", String);
-            update_token_metadata(&config, &stake_pool_address, name, symbol, uri)
-        }
-        ("add-validator", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let vote_account_address = pubkey_of(arg_matches, "vote_account").unwrap();
-            command_vsa_add(&config, &stake_pool_address, &vote_account_address)
-        }
-        ("remove-validator", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let vote_account = pubkey_of(arg_matches, "vote_account").unwrap();
-            command_vsa_remove(&config, &stake_pool_address, &vote_account)
-        }
-        ("increase-validator-stake", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let vote_account = pubkey_of(arg_matches, "vote_account").unwrap();
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            command_increase_validator_stake(&config, &stake_pool_address, &vote_account, amount)
-        }
-        ("decrease-validator-stake", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let vote_account = pubkey_of(arg_matches, "vote_account").unwrap();
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            command_decrease_validator_stake(&config, &stake_pool_address, &vote_account, amount)
-        }
-        ("set-preferred-validator", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let preferred_type = match arg_matches.value_of("preferred_type").unwrap() {
-                "deposit" => PreferredValidatorType::Deposit,
-                "withdraw" => PreferredValidatorType::Withdraw,
-                _ => unreachable!(),
-            };
-            let vote_account = pubkey_of(arg_matches, "vote_account");
-            let _unset = arg_matches.is_present("unset");
-            // since unset and vote_account can't both be set, if unset is set
-            // then vote_account will be None, which is valid for the program
-            command_set_preferred_validator(
-                &config,
-                &stake_pool_address,
-                preferred_type,
-                vote_account,
-            )
-        }
-        ("deposit-stake", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let stake_account = pubkey_of(arg_matches, "stake_account").unwrap();
-            let token_receiver: Option<Pubkey> = pubkey_of(arg_matches, "token_receiver");
-            let referrer: Option<Pubkey> = pubkey_of(arg_matches, "referrer");
-            let withdraw_authority = get_signer(
-                arg_matches,
-                "withdraw_authority",
-                &cli_config.keypair_path,
-                &mut wallet_manager,
-                SignerFromPathConfig {
-                    allow_null_signer: false,
-                },
-            );
-            command_deposit_stake(
-                &config,
-                &stake_pool_address,
-                &stake_account,
-                withdraw_authority,
-                &token_receiver,
-                &referrer,
-            )
-        }
-        ("deposit-sol", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let token_receiver: Option<Pubkey> = pubkey_of(arg_matches, "token_receiver");
-            let referrer: Option<Pubkey> = pubkey_of(arg_matches, "referrer");
-            let from = keypair_of(arg_matches, "from");
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            command_deposit_sol(
-                &config,
-                &stake_pool_address,
-                &from,
-                &token_receiver,
-                &referrer,
-                amount,
-            )
-        }
-        ("list", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            command_list(&config, &stake_pool_address)
-        }
-        ("update", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let no_merge = arg_matches.is_present("no_merge");
-            let force = arg_matches.is_present("force");
-            let stale_only = arg_matches.is_present("stale_only");
-            command_update(&config, &stake_pool_address, force, no_merge, stale_only)
-        }
-        ("withdraw-stake", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let vote_account = pubkey_of(arg_matches, "vote_account");
-            let pool_account = pubkey_of(arg_matches, "pool_account");
-            let pool_amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let stake_receiver = pubkey_of(arg_matches, "stake_receiver");
-            let use_reserve = arg_matches.is_present("use_reserve");
-            command_withdraw_stake(
-                &config,
-                &stake_pool_address,
-                use_reserve,
-                &vote_account,
-                &stake_receiver,
-                &pool_account,
-                pool_amount,
-            )
-        }
-        ("withdraw-sol", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let pool_account = pubkey_of(arg_matches, "pool_account");
-            let pool_amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let sol_receiver = get_signer(
-                arg_matches,
-                "sol_receiver",
-                &cli_config.keypair_path,
-                &mut wallet_manager,
-                SignerFromPathConfig {
-                    allow_null_signer: true,
-                },
-            )
-            .pubkey();
-            command_withdraw_sol(
-                &config,
-                &stake_pool_address,
-                &pool_account,
-                &sol_receiver,
-                pool_amount,
-            )
-        }
-        ("set-manager", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-
-            let new_manager = if arg_matches.value_of("new_manager").is_some() {
-                let signer = get_signer(
-                    arg_matches,
-                    "new-manager",
-                    arg_matches
-                        .value_of("new_manager")
-                        .expect("new manager argument not found!"),
-                    &mut wallet_manager,
-                    SignerFromPathConfig {
-                        allow_null_signer: true,
-                    },
-                );
-                Some(signer)
-            } else {
-                None
-            };
-
-            let new_fee_receiver: Option<Pubkey> = pubkey_of(arg_matches, "new_fee_receiver");
-            command_set_manager(
-                &config,
-                &stake_pool_address,
-                &new_manager,
-                &new_fee_receiver,
-            )
-        }
-        ("set-staker", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let new_staker = pubkey_of(arg_matches, "new_staker").unwrap();
-            command_set_staker(&config, &stake_pool_address, &new_staker)
-        }
-        ("set-funding-authority", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let new_authority = pubkey_of(arg_matches, "new_authority");
-            let funding_type = match arg_matches.value_of("funding_type").unwrap() {
-                "sol-deposit" => FundingType::SolDeposit,
-                "stake-deposit" => FundingType::StakeDeposit,
-                "sol-withdraw" => FundingType::SolWithdraw,
-                _ => unreachable!(),
-            };
-            let _unset = arg_matches.is_present("unset");
-            command_set_funding_authority(&config, &stake_pool_address, new_authority, funding_type)
-        }
-        ("set-fee", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let numerator = value_t_or_exit!(arg_matches, "fee_numerator", u64);
-            let denominator = value_t_or_exit!(arg_matches, "fee_denominator", u64);
-            let new_fee = Fee {
-                denominator,
-                numerator,
-            };
-            match arg_matches.value_of("fee_type").unwrap() {
-                "epoch" => command_set_fee(&config, &stake_pool_address, FeeType::Epoch(new_fee)),
-                "stake-deposit" => {
-                    command_set_fee(&config, &stake_pool_address, FeeType::StakeDeposit(new_fee))
-                }
-                "sol-deposit" => {
-                    command_set_fee(&config, &stake_pool_address, FeeType::SolDeposit(new_fee))
-                }
-                "stake-withdrawal" => command_set_fee(
-                    &config,
-                    &stake_pool_address,
-                    FeeType::StakeWithdrawal(new_fee),
-                ),
-                "sol-withdrawal" => command_set_fee(
-                    &config,
-                    &stake_pool_address,
-                    FeeType::SolWithdrawal(new_fee),
-                ),
-                _ => unreachable!(),
-            }
-        }
-        ("set-referral-fee", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let fee = value_t_or_exit!(arg_matches, "fee", u8);
-            assert!(
-                fee <= 100u8,
-                "Invalid fee {}%. Fee needs to be in range [0-100]",
-                fee
-            );
-            let fee_type = match arg_matches.value_of("fee_type").unwrap() {
-                "sol" => FeeType::SolReferral(fee),
-                "stake" => FeeType::StakeReferral(fee),
-                _ => unreachable!(),
-            };
-            command_set_fee(&config, &stake_pool_address, fee_type)
-        }
-        ("list-all", _) => command_list_all_pools(&config),
-        ("deposit-all-stake", Some(arg_matches)) => {
-            let stake_pool_address = pubkey_of(arg_matches, "pool").unwrap();
-            let stake_authority = pubkey_of(arg_matches, "stake_authority").unwrap();
-            let token_receiver: Option<Pubkey> = pubkey_of(arg_matches, "token_receiver");
-            let referrer: Option<Pubkey> = pubkey_of(arg_matches, "referrer");
-            let withdraw_authority = get_signer(
-                arg_matches,
-                "withdraw_authority",
-                &cli_config.keypair_path,
-                &mut wallet_manager,
-                SignerFromPathConfig {
-                    allow_null_signer: false,
-                },
-            );
-            command_deposit_all_stake(
-                &config,
-                &stake_pool_address,
-                &stake_authority,
-                withdraw_authority,
-                &token_receiver,
-                &referrer,
-            )
-        }
-        _ => unreachable!(),
-    }
-    .map_err(|err| {
-        eprintln!("{}", err);
-        exit(1);
-    });
-}
diff --git a/stake-pool/cli/src/output.rs b/stake-pool/cli/src/output.rs
deleted file mode 100644
index 5eeb81bcdbd..00000000000
--- a/stake-pool/cli/src/output.rs
+++ /dev/null
@@ -1,505 +0,0 @@
-use {
-    serde::{Deserialize, Serialize},
-    solana_cli_output::{QuietDisplay, VerboseDisplay},
-    solana_sdk::{native_token::Sol, pubkey::Pubkey, stake::state::Lockup},
-    spl_stake_pool::state::{
-        Fee, PodStakeStatus, StakePool, StakeStatus, ValidatorList, ValidatorStakeInfo,
-    },
-    std::fmt::{Display, Formatter, Result, Write},
-};
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePools {
-    pub pools: Vec<CliStakePool>,
-}
-
-impl Display for CliStakePools {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        for pool in &self.pools {
-            writeln!(
-                f,
-                "Address: {}\tManager: {}\tLamports: {}\tPool tokens: {}\tValidators: {}",
-                pool.address,
-                pool.manager,
-                pool.total_lamports,
-                pool.pool_token_supply,
-                pool.validator_list.len()
-            )?;
-        }
-        writeln!(f, "Total number of pools: {}", &self.pools.len())?;
-        Ok(())
-    }
-}
-
-impl QuietDisplay for CliStakePools {}
-impl VerboseDisplay for CliStakePools {}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePool {
-    pub address: String,
-    pub pool_withdraw_authority: String,
-    pub manager: String,
-    pub staker: String,
-    pub stake_deposit_authority: String,
-    pub stake_withdraw_bump_seed: u8,
-    pub max_validators: u32,
-    pub validator_list: Vec<CliStakePoolValidator>,
-    pub validator_list_storage_account: String,
-    pub reserve_stake: String,
-    pub pool_mint: String,
-    pub manager_fee_account: String,
-    pub token_program_id: String,
-    pub total_lamports: u64,
-    pub pool_token_supply: u64,
-    pub last_update_epoch: u64,
-    pub lockup: CliStakePoolLockup,
-    pub epoch_fee: CliStakePoolFee,
-    pub next_epoch_fee: Option<CliStakePoolFee>,
-    pub preferred_deposit_validator_vote_address: Option<String>,
-    pub preferred_withdraw_validator_vote_address: Option<String>,
-    pub stake_deposit_fee: CliStakePoolFee,
-    pub stake_withdrawal_fee: CliStakePoolFee,
-    pub next_stake_withdrawal_fee: Option<CliStakePoolFee>,
-    pub stake_referral_fee: u8,
-    pub sol_deposit_authority: Option<String>,
-    pub sol_deposit_fee: CliStakePoolFee,
-    pub sol_referral_fee: u8,
-    pub sol_withdraw_authority: Option<String>,
-    pub sol_withdrawal_fee: CliStakePoolFee,
-    pub next_sol_withdrawal_fee: Option<CliStakePoolFee>,
-    pub last_epoch_pool_token_supply: u64,
-    pub last_epoch_total_lamports: u64,
-    pub details: Option<CliStakePoolDetails>,
-}
-
-impl QuietDisplay for CliStakePool {}
-impl VerboseDisplay for CliStakePool {
-    fn write_str(&self, w: &mut dyn Write) -> Result {
-        writeln!(w, "Stake Pool Info")?;
-        writeln!(w, "===============")?;
-        writeln!(w, "Stake Pool: {}", &self.address)?;
-        writeln!(
-            w,
-            "Validator List: {}",
-            &self.validator_list_storage_account
-        )?;
-        writeln!(w, "Manager: {}", &self.manager)?;
-        writeln!(w, "Staker: {}", &self.staker)?;
-        writeln!(w, "Depositor: {}", &self.stake_deposit_authority)?;
-        writeln!(
-            w,
-            "SOL Deposit Authority: {}",
-            &self
-                .sol_deposit_authority
-                .as_ref()
-                .unwrap_or(&"None".to_string())
-        )?;
-        writeln!(
-            w,
-            "SOL Withdraw Authority: {}",
-            &self
-                .sol_withdraw_authority
-                .as_ref()
-                .unwrap_or(&"None".to_string())
-        )?;
-        writeln!(w, "Withdraw Authority: {}", &self.pool_withdraw_authority)?;
-        writeln!(w, "Pool Token Mint: {}", &self.pool_mint)?;
-        writeln!(w, "Fee Account: {}", &self.manager_fee_account)?;
-        match &self.preferred_deposit_validator_vote_address {
-            None => {}
-            Some(s) => {
-                writeln!(w, "Preferred Deposit Validator: {}", s)?;
-            }
-        }
-        match &self.preferred_withdraw_validator_vote_address {
-            None => {}
-            Some(s) => {
-                writeln!(w, "Preferred Withraw Validator: {}", s)?;
-            }
-        }
-        writeln!(w, "Epoch Fee: {} of epoch rewards", &self.epoch_fee)?;
-        if let Some(next_epoch_fee) = &self.next_epoch_fee {
-            writeln!(w, "Next Epoch Fee: {} of epoch rewards", next_epoch_fee)?;
-        }
-        writeln!(
-            w,
-            "Stake Withdrawal Fee: {} of withdrawal amount",
-            &self.stake_withdrawal_fee
-        )?;
-        if let Some(next_stake_withdrawal_fee) = &self.next_stake_withdrawal_fee {
-            writeln!(
-                w,
-                "Next Stake Withdrawal Fee: {} of withdrawal amount",
-                next_stake_withdrawal_fee
-            )?;
-        }
-        writeln!(
-            w,
-            "SOL Withdrawal Fee: {} of withdrawal amount",
-            &self.sol_withdrawal_fee
-        )?;
-        if let Some(next_sol_withdrawal_fee) = &self.next_sol_withdrawal_fee {
-            writeln!(
-                w,
-                "Next SOL Withdrawal Fee: {} of withdrawal amount",
-                next_sol_withdrawal_fee
-            )?;
-        }
-        writeln!(
-            w,
-            "Stake Deposit Fee: {} of deposit amount",
-            &self.stake_deposit_fee
-        )?;
-        writeln!(
-            w,
-            "SOL Deposit Fee: {} of deposit amount",
-            &self.sol_deposit_fee
-        )?;
-        writeln!(
-            w,
-            "Stake Deposit Referral Fee: {}% of Stake Deposit Fee",
-            &self.stake_referral_fee
-        )?;
-        writeln!(
-            w,
-            "SOL Deposit Referral Fee: {}% of SOL Deposit Fee",
-            &self.sol_referral_fee
-        )?;
-        writeln!(w)?;
-
-        match &self.details {
-            None => {}
-            Some(details) => {
-                VerboseDisplay::write_str(details, w)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Display for CliStakePool {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(f, "Stake Pool: {}", &self.address)?;
-        writeln!(
-            f,
-            "Validator List: {}",
-            &self.validator_list_storage_account
-        )?;
-        writeln!(f, "Pool Token Mint: {}", &self.pool_mint)?;
-        match &self.preferred_deposit_validator_vote_address {
-            None => {}
-            Some(s) => {
-                writeln!(f, "Preferred Deposit Validator: {}", s)?;
-            }
-        }
-        match &self.preferred_withdraw_validator_vote_address {
-            None => {}
-            Some(s) => {
-                writeln!(f, "Preferred Withraw Validator: {}", s)?;
-            }
-        }
-        writeln!(f, "Epoch Fee: {} of epoch rewards", &self.epoch_fee)?;
-        writeln!(
-            f,
-            "Stake Withdrawal Fee: {} of withdrawal amount",
-            &self.stake_withdrawal_fee
-        )?;
-        writeln!(
-            f,
-            "SOL Withdrawal Fee: {} of withdrawal amount",
-            &self.sol_withdrawal_fee
-        )?;
-        writeln!(
-            f,
-            "Stake Deposit Fee: {} of deposit amount",
-            &self.stake_deposit_fee
-        )?;
-        writeln!(
-            f,
-            "SOL Deposit Fee: {} of deposit amount",
-            &self.sol_deposit_fee
-        )?;
-        writeln!(
-            f,
-            "Stake Deposit Referral Fee: {}% of Stake Deposit Fee",
-            &self.stake_referral_fee
-        )?;
-        writeln!(
-            f,
-            "SOL Deposit Referral Fee: {}% of SOL Deposit Fee",
-            &self.sol_referral_fee
-        )?;
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePoolDetails {
-    pub reserve_stake_account_address: String,
-    pub reserve_stake_lamports: u64,
-    pub minimum_reserve_stake_balance: u64,
-    pub stake_accounts: Vec<CliStakePoolStakeAccountInfo>,
-    pub total_lamports: u64,
-    pub total_pool_tokens: f64,
-    pub current_number_of_validators: u32,
-    pub max_number_of_validators: u32,
-    pub update_required: bool,
-}
-
-impl Display for CliStakePoolDetails {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        writeln!(
-            f,
-            "Reserve Account: {}\tAvailable Balance: {}",
-            &self.reserve_stake_account_address,
-            Sol(self.reserve_stake_lamports - self.minimum_reserve_stake_balance),
-        )?;
-        for stake_account in &self.stake_accounts {
-            writeln!(
-                f,
-                "Vote Account: {}\tBalance: {}\tLast Update Epoch: {}",
-                stake_account.vote_account_address,
-                Sol(stake_account.validator_lamports),
-                stake_account.validator_last_update_epoch,
-            )?;
-        }
-        writeln!(
-            f,
-            "Total Pool Stake: {} {}",
-            Sol(self.total_lamports),
-            if self.update_required {
-                " [UPDATE REQUIRED]"
-            } else {
-                ""
-            },
-        )?;
-        writeln!(f, "Total Pool Tokens: {}", &self.total_pool_tokens,)?;
-        writeln!(
-            f,
-            "Current Number of Validators: {}",
-            &self.current_number_of_validators,
-        )?;
-        writeln!(
-            f,
-            "Max Number of Validators: {}",
-            &self.max_number_of_validators,
-        )?;
-        Ok(())
-    }
-}
-
-impl QuietDisplay for CliStakePoolDetails {}
-impl VerboseDisplay for CliStakePoolDetails {
-    fn write_str(&self, w: &mut dyn Write) -> Result {
-        writeln!(w, "Stake Accounts")?;
-        writeln!(w, "--------------")?;
-        writeln!(
-            w,
-            "Reserve Account: {}\tAvailable Balance: {}",
-            &self.reserve_stake_account_address,
-            Sol(self.reserve_stake_lamports - self.minimum_reserve_stake_balance),
-        )?;
-        for stake_account in &self.stake_accounts {
-            writeln!(
-                w,
-                "Vote Account: {}\tStake Account: {}\tActive Balance: {}\tTransient Stake Account: {}\tTransient Balance: {}\tLast Update Epoch: {}{}",
-                stake_account.vote_account_address,
-                stake_account.stake_account_address,
-                Sol(stake_account.validator_active_stake_lamports),
-                stake_account.validator_transient_stake_account_address,
-                Sol(stake_account.validator_transient_stake_lamports),
-                stake_account.validator_last_update_epoch,
-                if stake_account.update_required {
-                    " [UPDATE REQUIRED]"
-                } else {
-                    ""
-                },
-            )?;
-        }
-        writeln!(
-            w,
-            "Total Pool Stake: {} {}",
-            Sol(self.total_lamports),
-            if self.update_required {
-                " [UPDATE REQUIRED]"
-            } else {
-                ""
-            },
-        )?;
-        writeln!(w, "Total Pool Tokens: {}", &self.total_pool_tokens,)?;
-        writeln!(
-            w,
-            "Current Number of Validators: {}",
-            &self.current_number_of_validators,
-        )?;
-        writeln!(
-            w,
-            "Max Number of Validators: {}",
-            &self.max_number_of_validators,
-        )?;
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePoolStakeAccountInfo {
-    pub vote_account_address: String,
-    pub stake_account_address: String,
-    pub validator_active_stake_lamports: u64,
-    pub validator_last_update_epoch: u64,
-    pub validator_lamports: u64,
-    pub validator_transient_stake_account_address: String,
-    pub validator_transient_stake_lamports: u64,
-    pub update_required: bool,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePoolValidator {
-    pub active_stake_lamports: u64,
-    pub transient_stake_lamports: u64,
-    pub last_update_epoch: u64,
-    pub transient_seed_suffix: u64,
-    pub unused: u32,
-    pub validator_seed_suffix: u32,
-    pub status: CliStakePoolValidatorStakeStatus,
-    pub vote_account_address: String,
-}
-
-impl From<ValidatorStakeInfo> for CliStakePoolValidator {
-    fn from(v: ValidatorStakeInfo) -> Self {
-        Self {
-            active_stake_lamports: v.active_stake_lamports.into(),
-            transient_stake_lamports: v.transient_stake_lamports.into(),
-            last_update_epoch: v.last_update_epoch.into(),
-            transient_seed_suffix: v.transient_seed_suffix.into(),
-            unused: v.unused.into(),
-            validator_seed_suffix: v.validator_seed_suffix.into(),
-            status: CliStakePoolValidatorStakeStatus::from(v.status),
-            vote_account_address: v.vote_account_address.to_string(),
-        }
-    }
-}
-
-impl From<PodStakeStatus> for CliStakePoolValidatorStakeStatus {
-    fn from(s: PodStakeStatus) -> CliStakePoolValidatorStakeStatus {
-        let s = StakeStatus::try_from(s).unwrap();
-        match s {
-            StakeStatus::Active => CliStakePoolValidatorStakeStatus::Active,
-            StakeStatus::DeactivatingTransient => {
-                CliStakePoolValidatorStakeStatus::DeactivatingTransient
-            }
-            StakeStatus::ReadyForRemoval => CliStakePoolValidatorStakeStatus::ReadyForRemoval,
-            StakeStatus::DeactivatingValidator => {
-                CliStakePoolValidatorStakeStatus::DeactivatingValidator
-            }
-            StakeStatus::DeactivatingAll => CliStakePoolValidatorStakeStatus::DeactivatingAll,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub(crate) enum CliStakePoolValidatorStakeStatus {
-    Active,
-    DeactivatingTransient,
-    ReadyForRemoval,
-    DeactivatingValidator,
-    DeactivatingAll,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CliStakePoolLockup {
-    pub unix_timestamp: i64,
-    pub epoch: u64,
-    pub custodian: String,
-}
-
-impl From<Lockup> for CliStakePoolLockup {
-    fn from(l: Lockup) -> Self {
-        Self {
-            unix_timestamp: l.unix_timestamp,
-            epoch: l.epoch,
-            custodian: l.custodian.to_string(),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliStakePoolFee {
-    pub denominator: u64,
-    pub numerator: u64,
-}
-
-impl Display for CliStakePoolFee {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "{}/{}", &self.numerator, &self.denominator)
-    }
-}
-
-impl From<Fee> for CliStakePoolFee {
-    fn from(f: Fee) -> Self {
-        Self {
-            denominator: f.denominator,
-            numerator: f.numerator,
-        }
-    }
-}
-
-impl From<(Pubkey, StakePool, ValidatorList, Pubkey)> for CliStakePool {
-    fn from(s: (Pubkey, StakePool, ValidatorList, Pubkey)) -> Self {
-        let (address, stake_pool, validator_list, pool_withdraw_authority) = s;
-        Self {
-            address: address.to_string(),
-            pool_withdraw_authority: pool_withdraw_authority.to_string(),
-            manager: stake_pool.manager.to_string(),
-            staker: stake_pool.staker.to_string(),
-            stake_deposit_authority: stake_pool.stake_deposit_authority.to_string(),
-            stake_withdraw_bump_seed: stake_pool.stake_withdraw_bump_seed,
-            max_validators: validator_list.header.max_validators,
-            validator_list: validator_list
-                .validators
-                .into_iter()
-                .map(CliStakePoolValidator::from)
-                .collect(),
-            validator_list_storage_account: stake_pool.validator_list.to_string(),
-            reserve_stake: stake_pool.reserve_stake.to_string(),
-            pool_mint: stake_pool.pool_mint.to_string(),
-            manager_fee_account: stake_pool.manager_fee_account.to_string(),
-            token_program_id: stake_pool.token_program_id.to_string(),
-            total_lamports: stake_pool.total_lamports,
-            pool_token_supply: stake_pool.pool_token_supply,
-            last_update_epoch: stake_pool.last_update_epoch,
-            lockup: CliStakePoolLockup::from(stake_pool.lockup),
-            epoch_fee: CliStakePoolFee::from(stake_pool.epoch_fee),
-            next_epoch_fee: Option::<Fee>::from(stake_pool.next_epoch_fee)
-                .map(CliStakePoolFee::from),
-            preferred_deposit_validator_vote_address: stake_pool
-                .preferred_deposit_validator_vote_address
-                .map(|x| x.to_string()),
-            preferred_withdraw_validator_vote_address: stake_pool
-                .preferred_withdraw_validator_vote_address
-                .map(|x| x.to_string()),
-            stake_deposit_fee: CliStakePoolFee::from(stake_pool.stake_deposit_fee),
-            stake_withdrawal_fee: CliStakePoolFee::from(stake_pool.stake_withdrawal_fee),
-            next_stake_withdrawal_fee: Option::<Fee>::from(stake_pool.next_stake_withdrawal_fee)
-                .map(CliStakePoolFee::from),
-            stake_referral_fee: stake_pool.stake_referral_fee,
-            sol_deposit_authority: stake_pool.sol_deposit_authority.map(|x| x.to_string()),
-            sol_deposit_fee: CliStakePoolFee::from(stake_pool.sol_deposit_fee),
-            sol_referral_fee: stake_pool.sol_referral_fee,
-            sol_withdraw_authority: stake_pool.sol_withdraw_authority.map(|x| x.to_string()),
-            sol_withdrawal_fee: CliStakePoolFee::from(stake_pool.sol_withdrawal_fee),
-            next_sol_withdrawal_fee: Option::<Fee>::from(stake_pool.next_sol_withdrawal_fee)
-                .map(CliStakePoolFee::from),
-            last_epoch_pool_token_supply: stake_pool.last_epoch_pool_token_supply,
-            last_epoch_total_lamports: stake_pool.last_epoch_total_lamports,
-            details: None,
-        }
-    }
-}
diff --git a/stake-pool/js/.eslintignore b/stake-pool/js/.eslintignore
deleted file mode 100644
index 58542507948..00000000000
--- a/stake-pool/js/.eslintignore
+++ /dev/null
@@ -1,4 +0,0 @@
-dist
-node_modules
-.vscode
-.idea
diff --git a/stake-pool/js/.eslintrc.js b/stake-pool/js/.eslintrc.js
deleted file mode 100644
index 63db7b8405f..00000000000
--- a/stake-pool/js/.eslintrc.js
+++ /dev/null
@@ -1,21 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    es6: true,
-    node: true,
-    jest: true,
-  },
-  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    sourceType: 'module',
-  },
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-  },
-};
diff --git a/stake-pool/js/.gitignore b/stake-pool/js/.gitignore
deleted file mode 100644
index 3764afb8006..00000000000
--- a/stake-pool/js/.gitignore
+++ /dev/null
@@ -1,22 +0,0 @@
-# IDE & OS specific
-.DS_Store
-.idea
-.vscode
-
-# Logs
-logs
-*.log
-
-# Dependencies
-node_modules
-
-# Coverage
-coverage
-.nyc_output
-
-# Release
-dist
-dist.browser
-
-# TypeScript
-declarations
diff --git a/stake-pool/js/.prettierrc.js b/stake-pool/js/.prettierrc.js
deleted file mode 100644
index 8446d684477..00000000000
--- a/stake-pool/js/.prettierrc.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-  singleQuote: true,
-  trailingComma: 'all',
-  printWidth: 100,
-  endOfLine: 'lf',
-  semi: true,
-};
diff --git a/stake-pool/js/README.md b/stake-pool/js/README.md
deleted file mode 100644
index 947ec739973..00000000000
--- a/stake-pool/js/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# TypeScript bindings for stake-pool program
-
-For use with both node.js and in-browser.
-
-## Installation
-
-```
-npm install
-```
-
-## Build and run
-
-In the `js` folder:
-
-```
-npm run build
-```
-
-The build is available at `dist/index.js` (or `dist.browser/index.iife.js` in the browser).
-
-## Browser bundle
-```html
-<!-- Development (un-minified) -->
-<script src="https://unpkg.com/@solana/spl-stake-pool@latest/dist.browser/index.iife.js"></script>
-
-<!-- Production (minified) -->
-<script src="https://unpkg.com/@solana/spl-stake-pool@latest/dist.browser/index.iife.min.js"></script>
-```
-
-## Test
-
-```
-npm test
-```
-
-## Usage
-
-### JavaScript
-```javascript
-const solanaStakePool = require('@solana/spl-stake-pool');
-console.log(solanaStakePool);
-```
-
-### ES6
-```javascript
-import * as solanaStakePool from '@solana/spl-stake-pool';
-console.log(solanaStakePool);
-```
-
-### Browser bundle
-```javascript
-// `solanaStakePool` is provided in the global namespace by the script bundle.
-console.log(solanaStakePool);
-```
diff --git a/stake-pool/js/package.json b/stake-pool/js/package.json
deleted file mode 100644
index 9f562919ea8..00000000000
--- a/stake-pool/js/package.json
+++ /dev/null
@@ -1,93 +0,0 @@
-{
-  "name": "@solana/spl-stake-pool",
-  "version": "1.1.5",
-  "description": "SPL Stake Pool Program JS API",
-  "scripts": {
-    "build": "tsc && cross-env NODE_ENV=production rollup -c",
-    "build:program": "cargo build-sbf --manifest-path=../program/Cargo.toml",
-    "lint": "eslint --max-warnings 0 .",
-    "lint:fix": "eslint . --fix",
-    "test": "jest",
-    "clean": "rimraf ./dist"
-  },
-  "keywords": [],
-  "contributors": [
-    "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "Lieu Zheng Hong",
-    "mFactory Team (https://mfactory.ch/)",
-    "SolBlaze <contact@solblaze.org> (https://solblaze.org/)"
-  ],
-  "homepage": "https://solana.com",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/solana-labs/solana-program-library"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "browser": {
-    "./dist/index.cjs.js": "./dist/index.browser.cjs.js",
-    "./dist/index.esm.js": "./dist/index.browser.esm.js"
-  },
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
-  "browserslist": [
-    "defaults",
-    "not IE 11",
-    "maintained node versions"
-  ],
-  "files": [
-    "/dist",
-    "/src"
-  ],
-  "license": "ISC",
-  "dependencies": {
-    "@solana/buffer-layout": "^4.0.1",
-    "@solana/spl-token": "0.4.6",
-    "@solana/web3.js": "^1.93.0",
-    "bn.js": "^5.2.0",
-    "buffer": "^6.0.3",
-    "buffer-layout": "^1.2.2",
-    "superstruct": "^1.0.4"
-  },
-  "devDependencies": {
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-multi-entry": "^6.0.0",
-    "@rollup/plugin-node-resolve": "^15.0.2",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "@types/bn.js": "^5.1.0",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.5",
-    "@types/node-fetch": "^2.6.11",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
-    "cross-env": "^7.0.3",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "jest": "^29.0.0",
-    "prettier": "^3.3.2",
-    "rimraf": "^5.0.7",
-    "rollup": "^4.18.0",
-    "rollup-plugin-dts": "^6.1.1",
-    "ts-jest": "^29.1.5",
-    "typescript": "^5.4.5"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": ".",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "testRegex": ".*\\.test\\.ts$",
-    "testEnvironment": "node"
-  }
-}
diff --git a/stake-pool/js/rollup.config.mjs b/stake-pool/js/rollup.config.mjs
deleted file mode 100644
index f1ceb7e4904..00000000000
--- a/stake-pool/js/rollup.config.mjs
+++ /dev/null
@@ -1,113 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import commonjs from '@rollup/plugin-commonjs';
-import json from '@rollup/plugin-json';
-import nodeResolve from '@rollup/plugin-node-resolve';
-import terser from '@rollup/plugin-terser';
-
-const extensions = ['.js', '.ts'];
-
-function generateConfig(configType, format) {
-  const browser = configType === 'browser';
-
-  const config = {
-    input: 'src/index.ts',
-    plugins: [
-      commonjs(),
-      nodeResolve({
-        browser,
-        dedupe: ['bn.js', 'buffer'],
-        extensions,
-        preferBuiltins: !browser,
-      }),
-      typescript(),
-    ],
-    onwarn: function (warning, rollupWarn) {
-      if (warning.code !== 'CIRCULAR_DEPENDENCY') {
-        rollupWarn(warning);
-      }
-    },
-    treeshake: {
-      moduleSideEffects: false,
-    },
-  };
-
-  if (browser) {
-    if (format === 'iife') {
-      config.external = ['http', 'https'];
-
-      config.output = [
-        {
-          file: 'dist/index.iife.js',
-          format: 'iife',
-          name: 'solanaStakePool',
-          sourcemap: true,
-        },
-        {
-          file: 'dist/index.iife.min.js',
-          format: 'iife',
-          name: 'solanaStakePool',
-          sourcemap: true,
-          plugins: [terser({ mangle: false, compress: false })],
-        },
-      ];
-    } else {
-      config.output = [
-        {
-          file: 'dist/index.browser.cjs.js',
-          format: 'cjs',
-          sourcemap: true,
-        },
-        {
-          file: 'dist/index.browser.esm.js',
-          format: 'es',
-          sourcemap: true,
-        },
-      ];
-
-      // Prevent dependencies from being bundled
-      config.external = [
-        '@solana/buffer-layout',
-        '@solana/spl-token',
-        '@solana/web3.js',
-        'bn.js',
-        'buffer',
-        'buffer-layout',
-      ];
-    }
-
-    // TODO: Find a workaround to avoid resolving the following JSON file:
-    // `node_modules/secp256k1/node_modules/elliptic/package.json`
-    config.plugins.push(json());
-  } else {
-    config.output = [
-      {
-        file: 'dist/index.cjs.js',
-        format: 'cjs',
-        sourcemap: true,
-      },
-      {
-        file: 'dist/index.esm.js',
-        format: 'es',
-        sourcemap: true,
-      },
-    ];
-
-    // Prevent dependencies from being bundled
-    config.external = [
-      '@solana/buffer-layout',
-      '@solana/spl-token',
-      '@solana/web3.js',
-      'bn.js',
-      'buffer',
-      'buffer-layout',
-    ];
-  }
-
-  return config;
-}
-
-export default [
-  generateConfig('node'),
-  generateConfig('browser'),
-  generateConfig('browser', 'iife'),
-];
diff --git a/stake-pool/js/src/codecs.ts b/stake-pool/js/src/codecs.ts
deleted file mode 100644
index 0dbbde55ac8..00000000000
--- a/stake-pool/js/src/codecs.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { blob, Layout as LayoutCls, offset, seq, struct, u32, u8 } from 'buffer-layout';
-import { PublicKey } from '@solana/web3.js';
-import BN from 'bn.js';
-
-export interface Layout<T> {
-  span: number;
-  property?: string;
-
-  decode(b: Buffer, offset?: number): T;
-
-  encode(src: T, b: Buffer, offset?: number): number;
-
-  getSpan(b: Buffer, offset?: number): number;
-
-  replicate(name: string): this;
-}
-
-class BNLayout extends LayoutCls<BN> {
-  blob: Layout<Buffer>;
-  signed: boolean;
-
-  constructor(span: number, signed: boolean, property?: string) {
-    super(span, property);
-    this.blob = blob(span);
-    this.signed = signed;
-  }
-
-  decode(b: Buffer, offset = 0) {
-    const num = new BN(this.blob.decode(b, offset), 10, 'le');
-    if (this.signed) {
-      return num.fromTwos(this.span * 8).clone();
-    }
-    return num;
-  }
-
-  encode(src: BN, b: Buffer, offset = 0) {
-    if (this.signed) {
-      src = src.toTwos(this.span * 8);
-    }
-    return this.blob.encode(src.toArrayLike(Buffer, 'le', this.span), b, offset);
-  }
-}
-
-export function u64(property?: string): Layout<BN> {
-  return new BNLayout(8, false, property);
-}
-
-class WrappedLayout<T, U> extends LayoutCls<U> {
-  layout: Layout<T>;
-  decoder: (data: T) => U;
-  encoder: (src: U) => T;
-
-  constructor(
-    layout: Layout<T>,
-    decoder: (data: T) => U,
-    encoder: (src: U) => T,
-    property?: string,
-  ) {
-    super(layout.span, property);
-    this.layout = layout;
-    this.decoder = decoder;
-    this.encoder = encoder;
-  }
-
-  decode(b: Buffer, offset?: number): U {
-    return this.decoder(this.layout.decode(b, offset));
-  }
-
-  encode(src: U, b: Buffer, offset?: number): number {
-    return this.layout.encode(this.encoder(src), b, offset);
-  }
-
-  getSpan(b: Buffer, offset?: number): number {
-    return this.layout.getSpan(b, offset);
-  }
-}
-
-export function publicKey(property?: string): Layout<PublicKey> {
-  return new WrappedLayout(
-    blob(32),
-    (b: Buffer) => new PublicKey(b),
-    (key: PublicKey) => key.toBuffer(),
-    property,
-  );
-}
-
-class OptionLayout<T> extends LayoutCls<T | null> {
-  layout: Layout<T>;
-  discriminator: Layout<number>;
-
-  constructor(layout: Layout<T>, property?: string) {
-    super(-1, property);
-    this.layout = layout;
-    this.discriminator = u8();
-  }
-
-  encode(src: T | null, b: Buffer, offset = 0): number {
-    if (src === null || src === undefined) {
-      return this.discriminator.encode(0, b, offset);
-    }
-    this.discriminator.encode(1, b, offset);
-    return this.layout.encode(src, b, offset + 1) + 1;
-  }
-
-  decode(b: Buffer, offset = 0): T | null {
-    const discriminator = this.discriminator.decode(b, offset);
-    if (discriminator === 0) {
-      return null;
-    } else if (discriminator === 1) {
-      return this.layout.decode(b, offset + 1);
-    }
-    throw new Error('Invalid option ' + this.property);
-  }
-
-  getSpan(b: Buffer, offset = 0): number {
-    const discriminator = this.discriminator.decode(b, offset);
-    if (discriminator === 0) {
-      return 1;
-    } else if (discriminator === 1) {
-      return this.layout.getSpan(b, offset + 1) + 1;
-    }
-    throw new Error('Invalid option ' + this.property);
-  }
-}
-
-export function option<T>(layout: Layout<T>, property?: string): Layout<T | null> {
-  return new OptionLayout<T>(layout, property);
-}
-
-export function bool(property?: string): Layout<boolean> {
-  return new WrappedLayout(u8(), decodeBool, encodeBool, property);
-}
-
-function decodeBool(value: number): boolean {
-  if (value === 0) {
-    return false;
-  } else if (value === 1) {
-    return true;
-  }
-  throw new Error('Invalid bool: ' + value);
-}
-
-function encodeBool(value: boolean): number {
-  return value ? 1 : 0;
-}
-
-export function vec<T>(elementLayout: Layout<T>, property?: string): Layout<T[]> {
-  const length = u32('length');
-  const layout: Layout<{ values: T[] }> = struct([
-    length,
-    seq(elementLayout, offset(length, -length.span), 'values'),
-  ]);
-  return new WrappedLayout(
-    layout,
-    ({ values }) => values,
-    (values) => ({ values }),
-    property,
-  );
-}
diff --git a/stake-pool/js/src/constants.ts b/stake-pool/js/src/constants.ts
deleted file mode 100644
index d0f24ffa078..00000000000
--- a/stake-pool/js/src/constants.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { Buffer } from 'buffer';
-import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
-
-// Public key that identifies the metadata program.
-export const METADATA_PROGRAM_ID = new PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
-export const METADATA_MAX_NAME_LENGTH = 32;
-export const METADATA_MAX_SYMBOL_LENGTH = 10;
-export const METADATA_MAX_URI_LENGTH = 200;
-
-// Public key that identifies the SPL Stake Pool program.
-export const STAKE_POOL_PROGRAM_ID = new PublicKey('SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy');
-
-// Maximum number of validators to update during UpdateValidatorListBalance.
-export const MAX_VALIDATORS_TO_UPDATE = 5;
-
-// Seed for ephemeral stake account
-export const EPHEMERAL_STAKE_SEED_PREFIX = Buffer.from('ephemeral');
-
-// Seed used to derive transient stake accounts.
-export const TRANSIENT_STAKE_SEED_PREFIX = Buffer.from('transient');
-
-// Minimum amount of staked SOL required in a validator stake account to allow
-// for merges without a mismatch on credits observed
-export const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL;
diff --git a/stake-pool/js/src/index.ts b/stake-pool/js/src/index.ts
deleted file mode 100644
index 27b75f2fd0c..00000000000
--- a/stake-pool/js/src/index.ts
+++ /dev/null
@@ -1,1318 +0,0 @@
-import {
-  AccountInfo,
-  Connection,
-  Keypair,
-  PublicKey,
-  Signer,
-  StakeAuthorizationLayout,
-  StakeProgram,
-  SystemProgram,
-  TransactionInstruction,
-} from '@solana/web3.js';
-import {
-  createApproveInstruction,
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAccount,
-  getAssociatedTokenAddressSync,
-} from '@solana/spl-token';
-import {
-  ValidatorAccount,
-  arrayChunk,
-  calcLamportsWithdrawAmount,
-  findStakeProgramAddress,
-  findTransientStakeProgramAddress,
-  findWithdrawAuthorityProgramAddress,
-  getValidatorListAccount,
-  newStakeAccount,
-  prepareWithdrawAccounts,
-  lamportsToSol,
-  solToLamports,
-  findEphemeralStakeProgramAddress,
-  findMetadataAddress,
-} from './utils';
-import { StakePoolInstruction } from './instructions';
-import {
-  StakeAccount,
-  StakePool,
-  StakePoolLayout,
-  ValidatorList,
-  ValidatorListLayout,
-  ValidatorStakeInfo,
-} from './layouts';
-import { MAX_VALIDATORS_TO_UPDATE, MINIMUM_ACTIVE_STAKE, STAKE_POOL_PROGRAM_ID } from './constants';
-import { create } from 'superstruct';
-import BN from 'bn.js';
-
-export type { StakePool, AccountType, ValidatorList, ValidatorStakeInfo } from './layouts';
-export { STAKE_POOL_PROGRAM_ID } from './constants';
-export * from './instructions';
-
-export interface ValidatorListAccount {
-  pubkey: PublicKey;
-  account: AccountInfo<ValidatorList>;
-}
-
-export interface StakePoolAccount {
-  pubkey: PublicKey;
-  account: AccountInfo<StakePool>;
-}
-
-export interface WithdrawAccount {
-  stakeAddress: PublicKey;
-  voteAddress?: PublicKey;
-  poolAmount: BN;
-}
-
-/**
- * Wrapper class for a stake pool.
- * Each stake pool has a stake pool account and a validator list account.
- */
-export interface StakePoolAccounts {
-  stakePool: StakePoolAccount | undefined;
-  validatorList: ValidatorListAccount | undefined;
-}
-
-interface RedelegateProps {
-  connection: Connection;
-  stakePoolAddress: PublicKey;
-  sourceVoteAccount: PublicKey;
-  destinationVoteAccount: PublicKey;
-  sourceTransientStakeSeed: number | BN;
-  destinationTransientStakeSeed: number | BN;
-  ephemeralStakeSeed: number | BN;
-  lamports: number | BN;
-}
-
-/**
- * Retrieves and deserializes a StakePool account using a web3js connection and the stake pool address.
- * @param connection: An active web3js connection.
- * @param stakePoolAddress: The public key (address) of the stake pool account.
- */
-export async function getStakePoolAccount(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-): Promise<StakePoolAccount> {
-  const account = await connection.getAccountInfo(stakePoolAddress);
-
-  if (!account) {
-    throw new Error('Invalid stake pool account');
-  }
-
-  return {
-    pubkey: stakePoolAddress,
-    account: {
-      data: StakePoolLayout.decode(account.data),
-      executable: account.executable,
-      lamports: account.lamports,
-      owner: account.owner,
-    },
-  };
-}
-
-/**
- * Retrieves and deserializes a Stake account using a web3js connection and the stake address.
- * @param connection: An active web3js connection.
- * @param stakeAccount: The public key (address) of the stake account.
- */
-export async function getStakeAccount(
-  connection: Connection,
-  stakeAccount: PublicKey,
-): Promise<StakeAccount> {
-  const result = (await connection.getParsedAccountInfo(stakeAccount)).value;
-  if (!result || !('parsed' in result.data)) {
-    throw new Error('Invalid stake account');
-  }
-  const program = result.data.program;
-  if (program != 'stake') {
-    throw new Error('Not a stake account');
-  }
-  const parsed = create(result.data.parsed, StakeAccount);
-
-  return parsed;
-}
-
-/**
- * Retrieves all StakePool and ValidatorList accounts that are running a particular StakePool program.
- * @param connection: An active web3js connection.
- * @param stakePoolProgramAddress: The public key (address) of the StakePool program.
- */
-export async function getStakePoolAccounts(
-  connection: Connection,
-  stakePoolProgramAddress: PublicKey,
-): Promise<(StakePoolAccount | ValidatorListAccount | undefined)[] | undefined> {
-  const response = await connection.getProgramAccounts(stakePoolProgramAddress);
-
-  return response
-    .map((a) => {
-      try {
-        if (a.account.data.readUInt8() === 1) {
-          const data = StakePoolLayout.decode(a.account.data);
-          return {
-            pubkey: a.pubkey,
-            account: {
-              data,
-              executable: a.account.executable,
-              lamports: a.account.lamports,
-              owner: a.account.owner,
-            },
-          };
-        } else if (a.account.data.readUInt8() === 2) {
-          const data = ValidatorListLayout.decode(a.account.data);
-          return {
-            pubkey: a.pubkey,
-            account: {
-              data,
-              executable: a.account.executable,
-              lamports: a.account.lamports,
-              owner: a.account.owner,
-            },
-          };
-        } else {
-          console.error(
-            `Could not decode. StakePoolAccount Enum is ${a.account.data.readUInt8()}, expected 1 or 2!`,
-          );
-          return undefined;
-        }
-      } catch (error) {
-        console.error('Could not decode account. Error:', error);
-        return undefined;
-      }
-    })
-    .filter((a) => a !== undefined);
-}
-
-/**
- * Creates instructions required to deposit stake to stake pool.
- */
-export async function depositStake(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  authorizedPubkey: PublicKey,
-  validatorVote: PublicKey,
-  depositStake: PublicKey,
-  poolTokenReceiverAccount?: PublicKey,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const validatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorVote,
-    stakePoolAddress,
-  );
-
-  const instructions: TransactionInstruction[] = [];
-  const signers: Signer[] = [];
-
-  const poolMint = stakePool.account.data.poolMint;
-
-  // Create token account if not specified
-  if (!poolTokenReceiverAccount) {
-    const associatedAddress = getAssociatedTokenAddressSync(poolMint, authorizedPubkey);
-    instructions.push(
-      createAssociatedTokenAccountIdempotentInstruction(
-        authorizedPubkey,
-        associatedAddress,
-        authorizedPubkey,
-        poolMint,
-      ),
-    );
-    poolTokenReceiverAccount = associatedAddress;
-  }
-
-  instructions.push(
-    ...StakeProgram.authorize({
-      stakePubkey: depositStake,
-      authorizedPubkey,
-      newAuthorizedPubkey: stakePool.account.data.stakeDepositAuthority,
-      stakeAuthorizationType: StakeAuthorizationLayout.Staker,
-    }).instructions,
-  );
-
-  instructions.push(
-    ...StakeProgram.authorize({
-      stakePubkey: depositStake,
-      authorizedPubkey,
-      newAuthorizedPubkey: stakePool.account.data.stakeDepositAuthority,
-      stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer,
-    }).instructions,
-  );
-
-  instructions.push(
-    StakePoolInstruction.depositStake({
-      stakePool: stakePoolAddress,
-      validatorList: stakePool.account.data.validatorList,
-      depositAuthority: stakePool.account.data.stakeDepositAuthority,
-      reserveStake: stakePool.account.data.reserveStake,
-      managerFeeAccount: stakePool.account.data.managerFeeAccount,
-      referralPoolAccount: poolTokenReceiverAccount,
-      destinationPoolAccount: poolTokenReceiverAccount,
-      withdrawAuthority,
-      depositStake,
-      validatorStake,
-      poolMint,
-    }),
-  );
-
-  return {
-    instructions,
-    signers,
-  };
-}
-
-/**
- * Creates instructions required to deposit sol to stake pool.
- */
-export async function depositSol(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  from: PublicKey,
-  lamports: number,
-  destinationTokenAccount?: PublicKey,
-  referrerTokenAccount?: PublicKey,
-  depositAuthority?: PublicKey,
-) {
-  const fromBalance = await connection.getBalance(from, 'confirmed');
-  if (fromBalance < lamports) {
-    throw new Error(
-      `Not enough SOL to deposit into pool. Maximum deposit amount is ${lamportsToSol(
-        fromBalance,
-      )} SOL.`,
-    );
-  }
-
-  const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
-  const stakePool = stakePoolAccount.account.data;
-
-  // Ephemeral SOL account just to do the transfer
-  const userSolTransfer = new Keypair();
-  const signers: Signer[] = [userSolTransfer];
-  const instructions: TransactionInstruction[] = [];
-
-  // Create the ephemeral SOL account
-  instructions.push(
-    SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: userSolTransfer.publicKey,
-      lamports,
-    }),
-  );
-
-  // Create token account if not specified
-  if (!destinationTokenAccount) {
-    const associatedAddress = getAssociatedTokenAddressSync(stakePool.poolMint, from);
-    instructions.push(
-      createAssociatedTokenAccountIdempotentInstruction(
-        from,
-        associatedAddress,
-        from,
-        stakePool.poolMint,
-      ),
-    );
-    destinationTokenAccount = associatedAddress;
-  }
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  instructions.push(
-    StakePoolInstruction.depositSol({
-      stakePool: stakePoolAddress,
-      reserveStake: stakePool.reserveStake,
-      fundingAccount: userSolTransfer.publicKey,
-      destinationPoolAccount: destinationTokenAccount,
-      managerFeeAccount: stakePool.managerFeeAccount,
-      referralPoolAccount: referrerTokenAccount ?? destinationTokenAccount,
-      poolMint: stakePool.poolMint,
-      lamports,
-      withdrawAuthority,
-      depositAuthority,
-    }),
-  );
-
-  return {
-    instructions,
-    signers,
-  };
-}
-
-/**
- * Creates instructions required to withdraw stake from a stake pool.
- */
-export async function withdrawStake(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  tokenOwner: PublicKey,
-  amount: number,
-  useReserve = false,
-  voteAccountAddress?: PublicKey,
-  stakeReceiver?: PublicKey,
-  poolTokenAccount?: PublicKey,
-  validatorComparator?: (_a: ValidatorAccount, _b: ValidatorAccount) => number,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-  const poolAmount = new BN(solToLamports(amount));
-
-  if (!poolTokenAccount) {
-    poolTokenAccount = getAssociatedTokenAddressSync(stakePool.account.data.poolMint, tokenOwner);
-  }
-
-  const tokenAccount = await getAccount(connection, poolTokenAccount);
-
-  // Check withdrawFrom balance
-  if (tokenAccount.amount < poolAmount.toNumber()) {
-    throw new Error(
-      `Not enough token balance to withdraw ${lamportsToSol(poolAmount)} pool tokens.
-        Maximum withdraw amount is ${lamportsToSol(tokenAccount.amount)} pool tokens.`,
-    );
-  }
-
-  const stakeAccountRentExemption = await connection.getMinimumBalanceForRentExemption(
-    StakeProgram.space,
-  );
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  let stakeReceiverAccount = null;
-  if (stakeReceiver) {
-    stakeReceiverAccount = await getStakeAccount(connection, stakeReceiver);
-  }
-
-  const withdrawAccounts: WithdrawAccount[] = [];
-
-  if (useReserve) {
-    withdrawAccounts.push({
-      stakeAddress: stakePool.account.data.reserveStake,
-      voteAddress: undefined,
-      poolAmount,
-    });
-  } else if (stakeReceiverAccount && stakeReceiverAccount?.type == 'delegated') {
-    const voteAccount = stakeReceiverAccount.info?.stake?.delegation.voter;
-    if (!voteAccount) throw new Error(`Invalid stake receiver ${stakeReceiver} delegation`);
-    const validatorListAccount = await connection.getAccountInfo(
-      stakePool.account.data.validatorList,
-    );
-    const validatorList = ValidatorListLayout.decode(validatorListAccount?.data) as ValidatorList;
-    const isValidVoter = validatorList.validators.find((val) =>
-      val.voteAccountAddress.equals(voteAccount),
-    );
-    if (voteAccountAddress && voteAccountAddress !== voteAccount) {
-      throw new Error(`Provided withdrawal vote account ${voteAccountAddress} does not match delegation on stake receiver account ${voteAccount},
-      remove this flag or provide a different stake account delegated to ${voteAccountAddress}`);
-    }
-    if (isValidVoter) {
-      const stakeAccountAddress = await findStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        voteAccount,
-        stakePoolAddress,
-      );
-
-      const stakeAccount = await connection.getAccountInfo(stakeAccountAddress);
-      if (!stakeAccount) {
-        throw new Error(`Preferred withdraw valdator's stake account is invalid`);
-      }
-
-      const availableForWithdrawal = calcLamportsWithdrawAmount(
-        stakePool.account.data,
-        new BN(stakeAccount.lamports - MINIMUM_ACTIVE_STAKE - stakeAccountRentExemption),
-      );
-
-      if (availableForWithdrawal.lt(poolAmount)) {
-        throw new Error(
-          `Not enough lamports available for withdrawal from ${stakeAccountAddress},
-            ${poolAmount} asked, ${availableForWithdrawal} available.`,
-        );
-      }
-      withdrawAccounts.push({
-        stakeAddress: stakeAccountAddress,
-        voteAddress: voteAccount,
-        poolAmount,
-      });
-    } else {
-      throw new Error(
-        `Provided stake account is delegated to a vote account ${voteAccount} which does not exist in the stake pool`,
-      );
-    }
-  } else if (voteAccountAddress) {
-    const stakeAccountAddress = await findStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      voteAccountAddress,
-      stakePoolAddress,
-    );
-    const stakeAccount = await connection.getAccountInfo(stakeAccountAddress);
-    if (!stakeAccount) {
-      throw new Error('Invalid Stake Account');
-    }
-
-    const availableLamports = new BN(
-      stakeAccount.lamports - MINIMUM_ACTIVE_STAKE - stakeAccountRentExemption,
-    );
-    if (availableLamports.lt(new BN(0))) {
-      throw new Error('Invalid Stake Account');
-    }
-    const availableForWithdrawal = calcLamportsWithdrawAmount(
-      stakePool.account.data,
-      availableLamports,
-    );
-
-    if (availableForWithdrawal.lt(poolAmount)) {
-      // noinspection ExceptionCaughtLocallyJS
-      throw new Error(
-        `Not enough lamports available for withdrawal from ${stakeAccountAddress},
-          ${poolAmount} asked, ${availableForWithdrawal} available.`,
-      );
-    }
-    withdrawAccounts.push({
-      stakeAddress: stakeAccountAddress,
-      voteAddress: voteAccountAddress,
-      poolAmount,
-    });
-  } else {
-    // Get the list of accounts to withdraw from
-    withdrawAccounts.push(
-      ...(await prepareWithdrawAccounts(
-        connection,
-        stakePool.account.data,
-        stakePoolAddress,
-        poolAmount,
-        validatorComparator,
-        poolTokenAccount.equals(stakePool.account.data.managerFeeAccount),
-      )),
-    );
-  }
-
-  // Construct transaction to withdraw from withdrawAccounts account list
-  const instructions: TransactionInstruction[] = [];
-  const userTransferAuthority = Keypair.generate();
-
-  const signers: Signer[] = [userTransferAuthority];
-
-  instructions.push(
-    createApproveInstruction(
-      poolTokenAccount,
-      userTransferAuthority.publicKey,
-      tokenOwner,
-      poolAmount.toNumber(),
-    ),
-  );
-
-  let totalRentFreeBalances = 0;
-
-  // Max 5 accounts to prevent an error: "Transaction too large"
-  const maxWithdrawAccounts = 5;
-  let i = 0;
-
-  // Go through prepared accounts and withdraw/claim them
-  for (const withdrawAccount of withdrawAccounts) {
-    if (i > maxWithdrawAccounts) {
-      break;
-    }
-    // Convert pool tokens amount to lamports
-    const solWithdrawAmount = calcLamportsWithdrawAmount(
-      stakePool.account.data,
-      withdrawAccount.poolAmount,
-    );
-
-    let infoMsg = `Withdrawing ◎${solWithdrawAmount},
-      from stake account ${withdrawAccount.stakeAddress?.toBase58()}`;
-
-    if (withdrawAccount.voteAddress) {
-      infoMsg = `${infoMsg}, delegated to ${withdrawAccount.voteAddress?.toBase58()}`;
-    }
-
-    console.info(infoMsg);
-    let stakeToReceive;
-
-    if (!stakeReceiver || (stakeReceiverAccount && stakeReceiverAccount.type === 'delegated')) {
-      const stakeKeypair = newStakeAccount(tokenOwner, instructions, stakeAccountRentExemption);
-      signers.push(stakeKeypair);
-      totalRentFreeBalances += stakeAccountRentExemption;
-      stakeToReceive = stakeKeypair.publicKey;
-    } else {
-      stakeToReceive = stakeReceiver;
-    }
-
-    instructions.push(
-      StakePoolInstruction.withdrawStake({
-        stakePool: stakePoolAddress,
-        validatorList: stakePool.account.data.validatorList,
-        validatorStake: withdrawAccount.stakeAddress,
-        destinationStake: stakeToReceive,
-        destinationStakeAuthority: tokenOwner,
-        sourceTransferAuthority: userTransferAuthority.publicKey,
-        sourcePoolAccount: poolTokenAccount,
-        managerFeeAccount: stakePool.account.data.managerFeeAccount,
-        poolMint: stakePool.account.data.poolMint,
-        poolTokens: withdrawAccount.poolAmount.toNumber(),
-        withdrawAuthority,
-      }),
-    );
-    i++;
-  }
-  if (stakeReceiver && stakeReceiverAccount && stakeReceiverAccount.type === 'delegated') {
-    signers.forEach((newStakeKeypair) => {
-      instructions.concat(
-        StakeProgram.merge({
-          stakePubkey: stakeReceiver,
-          sourceStakePubKey: newStakeKeypair.publicKey,
-          authorizedPubkey: tokenOwner,
-        }).instructions,
-      );
-    });
-  }
-
-  return {
-    instructions,
-    signers,
-    stakeReceiver,
-    totalRentFreeBalances,
-  };
-}
-
-/**
- * Creates instructions required to withdraw SOL directly from a stake pool.
- */
-export async function withdrawSol(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  tokenOwner: PublicKey,
-  solReceiver: PublicKey,
-  amount: number,
-  solWithdrawAuthority?: PublicKey,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-  const poolAmount = solToLamports(amount);
-
-  const poolTokenAccount = getAssociatedTokenAddressSync(
-    stakePool.account.data.poolMint,
-    tokenOwner,
-  );
-
-  const tokenAccount = await getAccount(connection, poolTokenAccount);
-
-  // Check withdrawFrom balance
-  if (tokenAccount.amount < poolAmount) {
-    throw new Error(
-      `Not enough token balance to withdraw ${lamportsToSol(poolAmount)} pool tokens.
-          Maximum withdraw amount is ${lamportsToSol(tokenAccount.amount)} pool tokens.`,
-    );
-  }
-
-  // Construct transaction to withdraw from withdrawAccounts account list
-  const instructions: TransactionInstruction[] = [];
-  const userTransferAuthority = Keypair.generate();
-  const signers: Signer[] = [userTransferAuthority];
-
-  instructions.push(
-    createApproveInstruction(
-      poolTokenAccount,
-      userTransferAuthority.publicKey,
-      tokenOwner,
-      poolAmount,
-    ),
-  );
-
-  const poolWithdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  if (solWithdrawAuthority) {
-    const expectedSolWithdrawAuthority = stakePool.account.data.solWithdrawAuthority;
-    if (!expectedSolWithdrawAuthority) {
-      throw new Error('SOL withdraw authority specified in arguments but stake pool has none');
-    }
-    if (solWithdrawAuthority.toBase58() != expectedSolWithdrawAuthority.toBase58()) {
-      throw new Error(
-        `Invalid deposit withdraw specified, expected ${expectedSolWithdrawAuthority.toBase58()}, received ${solWithdrawAuthority.toBase58()}`,
-      );
-    }
-  }
-
-  const withdrawTransaction = StakePoolInstruction.withdrawSol({
-    stakePool: stakePoolAddress,
-    withdrawAuthority: poolWithdrawAuthority,
-    reserveStake: stakePool.account.data.reserveStake,
-    sourcePoolAccount: poolTokenAccount,
-    sourceTransferAuthority: userTransferAuthority.publicKey,
-    destinationSystemAccount: solReceiver,
-    managerFeeAccount: stakePool.account.data.managerFeeAccount,
-    poolMint: stakePool.account.data.poolMint,
-    poolTokens: poolAmount,
-    solWithdrawAuthority,
-  });
-
-  instructions.push(withdrawTransaction);
-
-  return {
-    instructions,
-    signers,
-  };
-}
-
-export async function addValidatorToPool(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  validatorVote: PublicKey,
-  seed?: number,
-) {
-  const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
-  const stakePool = stakePoolAccount.account.data;
-  const { reserveStake, staker, validatorList } = stakePool;
-
-  const validatorListAccount = await getValidatorListAccount(connection, validatorList);
-
-  const validatorInfo = validatorListAccount.account.data.validators.find(
-    (v) => v.voteAccountAddress.toBase58() == validatorVote.toBase58(),
-  );
-
-  if (validatorInfo) {
-    throw new Error('Vote account is already in validator list');
-  }
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const validatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorVote,
-    stakePoolAddress,
-    seed,
-  );
-
-  const instructions: TransactionInstruction[] = [
-    StakePoolInstruction.addValidatorToPool({
-      stakePool: stakePoolAddress,
-      staker: staker,
-      reserveStake: reserveStake,
-      withdrawAuthority: withdrawAuthority,
-      validatorList: validatorList,
-      validatorStake: validatorStake,
-      validatorVote: validatorVote,
-    }),
-  ];
-
-  return {
-    instructions,
-  };
-}
-
-export async function removeValidatorFromPool(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  validatorVote: PublicKey,
-  seed?: number,
-) {
-  const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
-  const stakePool = stakePoolAccount.account.data;
-  const { staker, validatorList } = stakePool;
-
-  const validatorListAccount = await getValidatorListAccount(connection, validatorList);
-
-  const validatorInfo = validatorListAccount.account.data.validators.find(
-    (v) => v.voteAccountAddress.toBase58() == validatorVote.toBase58(),
-  );
-
-  if (!validatorInfo) {
-    throw new Error('Vote account is not already in validator list');
-  }
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const validatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorVote,
-    stakePoolAddress,
-    seed,
-  );
-
-  const transientStakeSeed = validatorInfo.transientSeedSuffixStart;
-
-  const transientStake = await findTransientStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorInfo.voteAccountAddress,
-    stakePoolAddress,
-    transientStakeSeed,
-  );
-
-  const instructions: TransactionInstruction[] = [
-    StakePoolInstruction.removeValidatorFromPool({
-      stakePool: stakePoolAddress,
-      staker: staker,
-      withdrawAuthority,
-      validatorList,
-      validatorStake,
-      transientStake,
-    }),
-  ];
-
-  return {
-    instructions,
-  };
-}
-
-/**
- * Creates instructions required to increase validator stake.
- */
-export async function increaseValidatorStake(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  validatorVote: PublicKey,
-  lamports: number,
-  ephemeralStakeSeed?: number,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-
-  const validatorList = await getValidatorListAccount(
-    connection,
-    stakePool.account.data.validatorList,
-  );
-
-  const validatorInfo = validatorList.account.data.validators.find(
-    (v) => v.voteAccountAddress.toBase58() == validatorVote.toBase58(),
-  );
-
-  if (!validatorInfo) {
-    throw new Error('Vote account not found in validator list');
-  }
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  // Bump transient seed suffix by one to avoid reuse when not using the increaseAdditionalStake instruction
-  const transientStakeSeed =
-    ephemeralStakeSeed == undefined
-      ? validatorInfo.transientSeedSuffixStart.addn(1)
-      : validatorInfo.transientSeedSuffixStart;
-
-  const transientStake = await findTransientStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorInfo.voteAccountAddress,
-    stakePoolAddress,
-    transientStakeSeed,
-  );
-
-  const validatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorInfo.voteAccountAddress,
-    stakePoolAddress,
-  );
-
-  const instructions: TransactionInstruction[] = [];
-
-  if (ephemeralStakeSeed != undefined) {
-    const ephemeralStake = await findEphemeralStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      stakePoolAddress,
-      new BN(ephemeralStakeSeed),
-    );
-    instructions.push(
-      StakePoolInstruction.increaseAdditionalValidatorStake({
-        stakePool: stakePoolAddress,
-        staker: stakePool.account.data.staker,
-        validatorList: stakePool.account.data.validatorList,
-        reserveStake: stakePool.account.data.reserveStake,
-        transientStakeSeed: transientStakeSeed.toNumber(),
-        withdrawAuthority,
-        transientStake,
-        validatorStake,
-        validatorVote,
-        lamports,
-        ephemeralStake,
-        ephemeralStakeSeed,
-      }),
-    );
-  } else {
-    instructions.push(
-      StakePoolInstruction.increaseValidatorStake({
-        stakePool: stakePoolAddress,
-        staker: stakePool.account.data.staker,
-        validatorList: stakePool.account.data.validatorList,
-        reserveStake: stakePool.account.data.reserveStake,
-        transientStakeSeed: transientStakeSeed.toNumber(),
-        withdrawAuthority,
-        transientStake,
-        validatorStake,
-        validatorVote,
-        lamports,
-      }),
-    );
-  }
-
-  return {
-    instructions,
-  };
-}
-
-/**
- * Creates instructions required to decrease validator stake.
- */
-export async function decreaseValidatorStake(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  validatorVote: PublicKey,
-  lamports: number,
-  ephemeralStakeSeed?: number,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-  const validatorList = await getValidatorListAccount(
-    connection,
-    stakePool.account.data.validatorList,
-  );
-
-  const validatorInfo = validatorList.account.data.validators.find(
-    (v) => v.voteAccountAddress.toBase58() == validatorVote.toBase58(),
-  );
-
-  if (!validatorInfo) {
-    throw new Error('Vote account not found in validator list');
-  }
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const validatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorInfo.voteAccountAddress,
-    stakePoolAddress,
-  );
-
-  // Bump transient seed suffix by one to avoid reuse when not using the decreaseAdditionalStake instruction
-  const transientStakeSeed =
-    ephemeralStakeSeed == undefined
-      ? validatorInfo.transientSeedSuffixStart.addn(1)
-      : validatorInfo.transientSeedSuffixStart;
-
-  const transientStake = await findTransientStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    validatorInfo.voteAccountAddress,
-    stakePoolAddress,
-    transientStakeSeed,
-  );
-
-  const instructions: TransactionInstruction[] = [];
-
-  if (ephemeralStakeSeed != undefined) {
-    const ephemeralStake = await findEphemeralStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      stakePoolAddress,
-      new BN(ephemeralStakeSeed),
-    );
-    instructions.push(
-      StakePoolInstruction.decreaseAdditionalValidatorStake({
-        stakePool: stakePoolAddress,
-        staker: stakePool.account.data.staker,
-        validatorList: stakePool.account.data.validatorList,
-        reserveStake: stakePool.account.data.reserveStake,
-        transientStakeSeed: transientStakeSeed.toNumber(),
-        withdrawAuthority,
-        validatorStake,
-        transientStake,
-        lamports,
-        ephemeralStake,
-        ephemeralStakeSeed,
-      }),
-    );
-  } else {
-    instructions.push(
-      StakePoolInstruction.decreaseValidatorStakeWithReserve({
-        stakePool: stakePoolAddress,
-        staker: stakePool.account.data.staker,
-        validatorList: stakePool.account.data.validatorList,
-        reserveStake: stakePool.account.data.reserveStake,
-        transientStakeSeed: transientStakeSeed.toNumber(),
-        withdrawAuthority,
-        validatorStake,
-        transientStake,
-        lamports,
-      }),
-    );
-  }
-
-  return {
-    instructions,
-  };
-}
-
-/**
- * Creates instructions required to completely update a stake pool after epoch change.
- */
-export async function updateStakePool(
-  connection: Connection,
-  stakePool: StakePoolAccount,
-  noMerge = false,
-) {
-  const stakePoolAddress = stakePool.pubkey;
-
-  const validatorList = await getValidatorListAccount(
-    connection,
-    stakePool.account.data.validatorList,
-  );
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const updateListInstructions: TransactionInstruction[] = [];
-  const instructions: TransactionInstruction[] = [];
-
-  let startIndex = 0;
-  const validatorChunks: Array<ValidatorStakeInfo[]> = arrayChunk(
-    validatorList.account.data.validators,
-    MAX_VALIDATORS_TO_UPDATE,
-  );
-
-  for (const validatorChunk of validatorChunks) {
-    const validatorAndTransientStakePairs: PublicKey[] = [];
-
-    for (const validator of validatorChunk) {
-      const validatorStake = await findStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validator.voteAccountAddress,
-        stakePoolAddress,
-      );
-      validatorAndTransientStakePairs.push(validatorStake);
-
-      const transientStake = await findTransientStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validator.voteAccountAddress,
-        stakePoolAddress,
-        validator.transientSeedSuffixStart,
-      );
-      validatorAndTransientStakePairs.push(transientStake);
-    }
-
-    updateListInstructions.push(
-      StakePoolInstruction.updateValidatorListBalance({
-        stakePool: stakePoolAddress,
-        validatorList: stakePool.account.data.validatorList,
-        reserveStake: stakePool.account.data.reserveStake,
-        validatorAndTransientStakePairs,
-        withdrawAuthority,
-        startIndex,
-        noMerge,
-      }),
-    );
-    startIndex += MAX_VALIDATORS_TO_UPDATE;
-  }
-
-  instructions.push(
-    StakePoolInstruction.updateStakePoolBalance({
-      stakePool: stakePoolAddress,
-      validatorList: stakePool.account.data.validatorList,
-      reserveStake: stakePool.account.data.reserveStake,
-      managerFeeAccount: stakePool.account.data.managerFeeAccount,
-      poolMint: stakePool.account.data.poolMint,
-      withdrawAuthority,
-    }),
-  );
-
-  instructions.push(
-    StakePoolInstruction.cleanupRemovedValidatorEntries({
-      stakePool: stakePoolAddress,
-      validatorList: stakePool.account.data.validatorList,
-    }),
-  );
-
-  return {
-    updateListInstructions,
-    finalInstructions: instructions,
-  };
-}
-
-/**
- * Retrieves detailed information about the StakePool.
- */
-export async function stakePoolInfo(connection: Connection, stakePoolAddress: PublicKey) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-  const reserveAccountStakeAddress = stakePool.account.data.reserveStake;
-  const totalLamports = stakePool.account.data.totalLamports;
-  const lastUpdateEpoch = stakePool.account.data.lastUpdateEpoch;
-
-  const validatorList = await getValidatorListAccount(
-    connection,
-    stakePool.account.data.validatorList,
-  );
-
-  const maxNumberOfValidators = validatorList.account.data.maxValidators;
-  const currentNumberOfValidators = validatorList.account.data.validators.length;
-
-  const epochInfo = await connection.getEpochInfo();
-  const reserveStake = await connection.getAccountInfo(reserveAccountStakeAddress);
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const minimumReserveStakeBalance = await connection.getMinimumBalanceForRentExemption(
-    StakeProgram.space,
-  );
-
-  const stakeAccounts = await Promise.all(
-    validatorList.account.data.validators.map(async (validator) => {
-      const stakeAccountAddress = await findStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validator.voteAccountAddress,
-        stakePoolAddress,
-      );
-      const transientStakeAccountAddress = await findTransientStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validator.voteAccountAddress,
-        stakePoolAddress,
-        validator.transientSeedSuffixStart,
-      );
-      const updateRequired = !validator.lastUpdateEpoch.eqn(epochInfo.epoch);
-      return {
-        voteAccountAddress: validator.voteAccountAddress.toBase58(),
-        stakeAccountAddress: stakeAccountAddress.toBase58(),
-        validatorActiveStakeLamports: validator.activeStakeLamports.toString(),
-        validatorLastUpdateEpoch: validator.lastUpdateEpoch.toString(),
-        validatorLamports: validator.activeStakeLamports
-          .add(validator.transientStakeLamports)
-          .toString(),
-        validatorTransientStakeAccountAddress: transientStakeAccountAddress.toBase58(),
-        validatorTransientStakeLamports: validator.transientStakeLamports.toString(),
-        updateRequired,
-      };
-    }),
-  );
-
-  const totalPoolTokens = lamportsToSol(stakePool.account.data.poolTokenSupply);
-  const updateRequired = !lastUpdateEpoch.eqn(epochInfo.epoch);
-
-  return {
-    address: stakePoolAddress.toBase58(),
-    poolWithdrawAuthority: withdrawAuthority.toBase58(),
-    manager: stakePool.account.data.manager.toBase58(),
-    staker: stakePool.account.data.staker.toBase58(),
-    stakeDepositAuthority: stakePool.account.data.stakeDepositAuthority.toBase58(),
-    stakeWithdrawBumpSeed: stakePool.account.data.stakeWithdrawBumpSeed,
-    maxValidators: maxNumberOfValidators,
-    validatorList: validatorList.account.data.validators.map((validator) => {
-      return {
-        activeStakeLamports: validator.activeStakeLamports.toString(),
-        transientStakeLamports: validator.transientStakeLamports.toString(),
-        lastUpdateEpoch: validator.lastUpdateEpoch.toString(),
-        transientSeedSuffixStart: validator.transientSeedSuffixStart.toString(),
-        transientSeedSuffixEnd: validator.transientSeedSuffixEnd.toString(),
-        status: validator.status.toString(),
-        voteAccountAddress: validator.voteAccountAddress.toString(),
-      };
-    }), // CliStakePoolValidator
-    validatorListStorageAccount: stakePool.account.data.validatorList.toBase58(),
-    reserveStake: stakePool.account.data.reserveStake.toBase58(),
-    poolMint: stakePool.account.data.poolMint.toBase58(),
-    managerFeeAccount: stakePool.account.data.managerFeeAccount.toBase58(),
-    tokenProgramId: stakePool.account.data.tokenProgramId.toBase58(),
-    totalLamports: stakePool.account.data.totalLamports.toString(),
-    poolTokenSupply: stakePool.account.data.poolTokenSupply.toString(),
-    lastUpdateEpoch: stakePool.account.data.lastUpdateEpoch.toString(),
-    lockup: stakePool.account.data.lockup, // pub lockup: CliStakePoolLockup
-    epochFee: stakePool.account.data.epochFee,
-    nextEpochFee: stakePool.account.data.nextEpochFee,
-    preferredDepositValidatorVoteAddress:
-      stakePool.account.data.preferredDepositValidatorVoteAddress,
-    preferredWithdrawValidatorVoteAddress:
-      stakePool.account.data.preferredWithdrawValidatorVoteAddress,
-    stakeDepositFee: stakePool.account.data.stakeDepositFee,
-    stakeWithdrawalFee: stakePool.account.data.stakeWithdrawalFee,
-    // CliStakePool the same
-    nextStakeWithdrawalFee: stakePool.account.data.nextStakeWithdrawalFee,
-    stakeReferralFee: stakePool.account.data.stakeReferralFee,
-    solDepositAuthority: stakePool.account.data.solDepositAuthority?.toBase58(),
-    solDepositFee: stakePool.account.data.solDepositFee,
-    solReferralFee: stakePool.account.data.solReferralFee,
-    solWithdrawAuthority: stakePool.account.data.solWithdrawAuthority?.toBase58(),
-    solWithdrawalFee: stakePool.account.data.solWithdrawalFee,
-    nextSolWithdrawalFee: stakePool.account.data.nextSolWithdrawalFee,
-    lastEpochPoolTokenSupply: stakePool.account.data.lastEpochPoolTokenSupply.toString(),
-    lastEpochTotalLamports: stakePool.account.data.lastEpochTotalLamports.toString(),
-    details: {
-      reserveStakeLamports: reserveStake?.lamports,
-      reserveAccountStakeAddress: reserveAccountStakeAddress.toBase58(),
-      minimumReserveStakeBalance,
-      stakeAccounts,
-      totalLamports,
-      totalPoolTokens,
-      currentNumberOfValidators,
-      maxNumberOfValidators,
-      updateRequired,
-    }, // CliStakePoolDetails
-  };
-}
-
-/**
- * Creates instructions required to redelegate stake.
- */
-export async function redelegate(props: RedelegateProps) {
-  const {
-    connection,
-    stakePoolAddress,
-    sourceVoteAccount,
-    sourceTransientStakeSeed,
-    destinationVoteAccount,
-    destinationTransientStakeSeed,
-    ephemeralStakeSeed,
-    lamports,
-  } = props;
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-
-  const stakePoolWithdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const sourceValidatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    sourceVoteAccount,
-    stakePoolAddress,
-  );
-
-  const sourceTransientStake = await findTransientStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    sourceVoteAccount,
-    stakePoolAddress,
-    new BN(sourceTransientStakeSeed),
-  );
-
-  const destinationValidatorStake = await findStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    destinationVoteAccount,
-    stakePoolAddress,
-  );
-
-  const destinationTransientStake = await findTransientStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    destinationVoteAccount,
-    stakePoolAddress,
-    new BN(destinationTransientStakeSeed),
-  );
-
-  const ephemeralStake = await findEphemeralStakeProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-    new BN(ephemeralStakeSeed),
-  );
-
-  const instructions: TransactionInstruction[] = [];
-
-  instructions.push(
-    StakePoolInstruction.redelegate({
-      stakePool: stakePool.pubkey,
-      staker: stakePool.account.data.staker,
-      validatorList: stakePool.account.data.validatorList,
-      reserveStake: stakePool.account.data.reserveStake,
-      stakePoolWithdrawAuthority,
-      ephemeralStake,
-      ephemeralStakeSeed,
-      sourceValidatorStake,
-      sourceTransientStake,
-      sourceTransientStakeSeed,
-      destinationValidatorStake,
-      destinationTransientStake,
-      destinationTransientStakeSeed,
-      validator: destinationVoteAccount,
-      lamports,
-    }),
-  );
-
-  return {
-    instructions,
-  };
-}
-
-/**
- * Creates instructions required to create pool token metadata.
- */
-export async function createPoolTokenMetadata(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  payer: PublicKey,
-  name: string,
-  symbol: string,
-  uri: string,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-  const tokenMetadata = findMetadataAddress(stakePool.account.data.poolMint);
-  const manager = stakePool.account.data.manager;
-
-  const instructions: TransactionInstruction[] = [];
-  instructions.push(
-    StakePoolInstruction.createTokenMetadata({
-      stakePool: stakePoolAddress,
-      poolMint: stakePool.account.data.poolMint,
-      payer,
-      manager,
-      tokenMetadata,
-      withdrawAuthority,
-      name,
-      symbol,
-      uri,
-    }),
-  );
-
-  return {
-    instructions,
-  };
-}
-
-/**
- * Creates instructions required to update pool token metadata.
- */
-export async function updatePoolTokenMetadata(
-  connection: Connection,
-  stakePoolAddress: PublicKey,
-  name: string,
-  symbol: string,
-  uri: string,
-) {
-  const stakePool = await getStakePoolAccount(connection, stakePoolAddress);
-
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(
-    STAKE_POOL_PROGRAM_ID,
-    stakePoolAddress,
-  );
-
-  const tokenMetadata = findMetadataAddress(stakePool.account.data.poolMint);
-
-  const instructions: TransactionInstruction[] = [];
-  instructions.push(
-    StakePoolInstruction.updateTokenMetadata({
-      stakePool: stakePoolAddress,
-      manager: stakePool.account.data.manager,
-      tokenMetadata,
-      withdrawAuthority,
-      name,
-      symbol,
-      uri,
-    }),
-  );
-
-  return {
-    instructions,
-  };
-}
diff --git a/stake-pool/js/src/instructions.ts b/stake-pool/js/src/instructions.ts
deleted file mode 100644
index 970d673635d..00000000000
--- a/stake-pool/js/src/instructions.ts
+++ /dev/null
@@ -1,1187 +0,0 @@
-import {
-  PublicKey,
-  STAKE_CONFIG_ID,
-  SYSVAR_CLOCK_PUBKEY,
-  SYSVAR_RENT_PUBKEY,
-  SYSVAR_STAKE_HISTORY_PUBKEY,
-  StakeProgram,
-  SystemProgram,
-  TransactionInstruction,
-} from '@solana/web3.js';
-import * as BufferLayout from '@solana/buffer-layout';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
-import { InstructionType, encodeData, decodeData } from './utils';
-import BN from 'bn.js';
-import {
-  METADATA_MAX_NAME_LENGTH,
-  METADATA_MAX_SYMBOL_LENGTH,
-  METADATA_MAX_URI_LENGTH,
-  METADATA_PROGRAM_ID,
-  STAKE_POOL_PROGRAM_ID,
-} from './constants';
-
-/**
- * An enumeration of valid StakePoolInstructionType's
- */
-export type StakePoolInstructionType =
-  | 'IncreaseValidatorStake'
-  | 'DecreaseValidatorStake'
-  | 'UpdateValidatorListBalance'
-  | 'UpdateStakePoolBalance'
-  | 'CleanupRemovedValidatorEntries'
-  | 'DepositStake'
-  | 'DepositSol'
-  | 'WithdrawStake'
-  | 'WithdrawSol'
-  | 'IncreaseAdditionalValidatorStake'
-  | 'DecreaseAdditionalValidatorStake'
-  | 'DecreaseValidatorStakeWithReserve'
-  | 'Redelegate'
-  | 'AddValidatorToPool'
-  | 'RemoveValidatorFromPool';
-
-// 'UpdateTokenMetadata' and 'CreateTokenMetadata' have dynamic layouts
-
-const MOVE_STAKE_LAYOUT = BufferLayout.struct<any>([
-  BufferLayout.u8('instruction'),
-  BufferLayout.ns64('lamports'),
-  BufferLayout.ns64('transientStakeSeed'),
-]);
-
-const UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT = BufferLayout.struct<any>([
-  BufferLayout.u8('instruction'),
-  BufferLayout.u32('startIndex'),
-  BufferLayout.u8('noMerge'),
-]);
-
-export function tokenMetadataLayout(
-  instruction: number,
-  nameLength: number,
-  symbolLength: number,
-  uriLength: number,
-) {
-  if (nameLength > METADATA_MAX_NAME_LENGTH) {
-    throw 'maximum token name length is 32 characters';
-  }
-
-  if (symbolLength > METADATA_MAX_SYMBOL_LENGTH) {
-    throw 'maximum token symbol length is 10 characters';
-  }
-
-  if (uriLength > METADATA_MAX_URI_LENGTH) {
-    throw 'maximum token uri length is 200 characters';
-  }
-
-  return {
-    index: instruction,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.u32('nameLen'),
-      BufferLayout.blob(nameLength, 'name'),
-      BufferLayout.u32('symbolLen'),
-      BufferLayout.blob(symbolLength, 'symbol'),
-      BufferLayout.u32('uriLen'),
-      BufferLayout.blob(uriLength, 'uri'),
-    ]),
-  };
-}
-
-/**
- * An enumeration of valid stake InstructionType's
- * @internal
- */
-export const STAKE_POOL_INSTRUCTION_LAYOUTS: {
-  [type in StakePoolInstructionType]: InstructionType;
-} = Object.freeze({
-  AddValidatorToPool: {
-    index: 1,
-    layout: BufferLayout.struct<any>([BufferLayout.u8('instruction'), BufferLayout.u32('seed')]),
-  },
-  RemoveValidatorFromPool: {
-    index: 2,
-    layout: BufferLayout.struct<any>([BufferLayout.u8('instruction')]),
-  },
-  DecreaseValidatorStake: {
-    index: 3,
-    layout: MOVE_STAKE_LAYOUT,
-  },
-  IncreaseValidatorStake: {
-    index: 4,
-    layout: MOVE_STAKE_LAYOUT,
-  },
-  UpdateValidatorListBalance: {
-    index: 6,
-    layout: UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT,
-  },
-  UpdateStakePoolBalance: {
-    index: 7,
-    layout: BufferLayout.struct<any>([BufferLayout.u8('instruction')]),
-  },
-  CleanupRemovedValidatorEntries: {
-    index: 8,
-    layout: BufferLayout.struct<any>([BufferLayout.u8('instruction')]),
-  },
-  DepositStake: {
-    index: 9,
-    layout: BufferLayout.struct<any>([BufferLayout.u8('instruction')]),
-  },
-  /// Withdraw the token from the pool at the current ratio.
-  WithdrawStake: {
-    index: 10,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.ns64('poolTokens'),
-    ]),
-  },
-  /// Deposit SOL directly into the pool's reserve account. The output is a "pool" token
-  /// representing ownership into the pool. Inputs are converted to the current ratio.
-  DepositSol: {
-    index: 14,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.ns64('lamports'),
-    ]),
-  },
-  /// Withdraw SOL directly from the pool's reserve account. Fails if the
-  /// reserve does not have enough SOL.
-  WithdrawSol: {
-    index: 16,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.ns64('poolTokens'),
-    ]),
-  },
-  IncreaseAdditionalValidatorStake: {
-    index: 19,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.ns64('lamports'),
-      BufferLayout.ns64('transientStakeSeed'),
-      BufferLayout.ns64('ephemeralStakeSeed'),
-    ]),
-  },
-  DecreaseAdditionalValidatorStake: {
-    index: 20,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      BufferLayout.ns64('lamports'),
-      BufferLayout.ns64('transientStakeSeed'),
-      BufferLayout.ns64('ephemeralStakeSeed'),
-    ]),
-  },
-  DecreaseValidatorStakeWithReserve: {
-    index: 21,
-    layout: MOVE_STAKE_LAYOUT,
-  },
-  Redelegate: {
-    index: 22,
-    layout: BufferLayout.struct<any>([
-      BufferLayout.u8('instruction'),
-      /// Amount of lamports to redelegate
-      BufferLayout.ns64('lamports'),
-      /// Seed used to create source transient stake account
-      BufferLayout.ns64('sourceTransientStakeSeed'),
-      /// Seed used to create destination ephemeral account.
-      BufferLayout.ns64('ephemeralStakeSeed'),
-      /// Seed used to create destination transient stake account. If there is
-      /// already transient stake, this must match the current seed, otherwise
-      /// it can be anything
-      BufferLayout.ns64('destinationTransientStakeSeed'),
-    ]),
-  },
-});
-
-/**
- * Cleans up validator stake account entries marked as `ReadyForRemoval`
- */
-export type CleanupRemovedValidatorEntriesParams = {
-  stakePool: PublicKey;
-  validatorList: PublicKey;
-};
-
-/**
- * Updates balances of validator and transient stake accounts in the pool.
- */
-export type UpdateValidatorListBalanceParams = {
-  stakePool: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  reserveStake: PublicKey;
-  validatorAndTransientStakePairs: PublicKey[];
-  startIndex: number;
-  noMerge: boolean;
-};
-
-/**
- * Updates total pool balance based on balances in the reserve and validator list.
- */
-export type UpdateStakePoolBalanceParams = {
-  stakePool: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  reserveStake: PublicKey;
-  managerFeeAccount: PublicKey;
-  poolMint: PublicKey;
-};
-
-/**
- * (Staker only) Decrease active stake on a validator, eventually moving it to the reserve
- */
-export type DecreaseValidatorStakeParams = {
-  stakePool: PublicKey;
-  staker: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  validatorStake: PublicKey;
-  transientStake: PublicKey;
-  // Amount of lamports to split into the transient stake account
-  lamports: number;
-  // Seed to used to create the transient stake account
-  transientStakeSeed: number;
-};
-
-export interface DecreaseValidatorStakeWithReserveParams extends DecreaseValidatorStakeParams {
-  reserveStake: PublicKey;
-}
-
-export interface DecreaseAdditionalValidatorStakeParams extends DecreaseValidatorStakeParams {
-  reserveStake: PublicKey;
-  ephemeralStake: PublicKey;
-  ephemeralStakeSeed: number;
-}
-
-/**
- * (Staker only) Increase stake on a validator from the reserve account.
- */
-export type IncreaseValidatorStakeParams = {
-  stakePool: PublicKey;
-  staker: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  reserveStake: PublicKey;
-  transientStake: PublicKey;
-  validatorStake: PublicKey;
-  validatorVote: PublicKey;
-  // Amount of lamports to split into the transient stake account
-  lamports: number;
-  // Seed to used to create the transient stake account
-  transientStakeSeed: number;
-};
-
-export interface IncreaseAdditionalValidatorStakeParams extends IncreaseValidatorStakeParams {
-  ephemeralStake: PublicKey;
-  ephemeralStakeSeed: number;
-}
-
-/**
- * Deposits a stake account into the pool in exchange for pool tokens
- */
-export type DepositStakeParams = {
-  stakePool: PublicKey;
-  validatorList: PublicKey;
-  depositAuthority: PublicKey;
-  withdrawAuthority: PublicKey;
-  depositStake: PublicKey;
-  validatorStake: PublicKey;
-  reserveStake: PublicKey;
-  destinationPoolAccount: PublicKey;
-  managerFeeAccount: PublicKey;
-  referralPoolAccount: PublicKey;
-  poolMint: PublicKey;
-};
-
-/**
- * Withdraws a stake account from the pool in exchange for pool tokens
- */
-export type WithdrawStakeParams = {
-  stakePool: PublicKey;
-  validatorList: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorStake: PublicKey;
-  destinationStake: PublicKey;
-  destinationStakeAuthority: PublicKey;
-  sourceTransferAuthority: PublicKey;
-  sourcePoolAccount: PublicKey;
-  managerFeeAccount: PublicKey;
-  poolMint: PublicKey;
-  poolTokens: number;
-};
-
-/**
- * Withdraw sol instruction params
- */
-export type WithdrawSolParams = {
-  stakePool: PublicKey;
-  sourcePoolAccount: PublicKey;
-  withdrawAuthority: PublicKey;
-  reserveStake: PublicKey;
-  destinationSystemAccount: PublicKey;
-  sourceTransferAuthority: PublicKey;
-  solWithdrawAuthority?: PublicKey | undefined;
-  managerFeeAccount: PublicKey;
-  poolMint: PublicKey;
-  poolTokens: number;
-};
-
-/**
- * Deposit SOL directly into the pool's reserve account. The output is a "pool" token
- * representing ownership into the pool. Inputs are converted to the current ratio.
- */
-export type DepositSolParams = {
-  stakePool: PublicKey;
-  depositAuthority?: PublicKey | undefined;
-  withdrawAuthority: PublicKey;
-  reserveStake: PublicKey;
-  fundingAccount: PublicKey;
-  destinationPoolAccount: PublicKey;
-  managerFeeAccount: PublicKey;
-  referralPoolAccount: PublicKey;
-  poolMint: PublicKey;
-  lamports: number;
-};
-
-export type RedelegateParams = {
-  stakePool: PublicKey;
-  staker: PublicKey;
-  stakePoolWithdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  reserveStake: PublicKey;
-  sourceValidatorStake: PublicKey;
-  sourceTransientStake: PublicKey;
-  ephemeralStake: PublicKey;
-  destinationTransientStake: PublicKey;
-  destinationValidatorStake: PublicKey;
-  validator: PublicKey;
-  // Amount of lamports to redelegate
-  lamports: number | BN;
-  // Seed used to create source transient stake account
-  sourceTransientStakeSeed: number | BN;
-  // Seed used to create destination ephemeral account
-  ephemeralStakeSeed: number | BN;
-  // Seed used to create destination transient stake account. If there is
-  // already transient stake, this must match the current seed, otherwise
-  // it can be anything
-  destinationTransientStakeSeed: number | BN;
-};
-
-export type CreateTokenMetadataParams = {
-  stakePool: PublicKey;
-  manager: PublicKey;
-  tokenMetadata: PublicKey;
-  withdrawAuthority: PublicKey;
-  poolMint: PublicKey;
-  payer: PublicKey;
-  name: string;
-  symbol: string;
-  uri: string;
-};
-
-export type UpdateTokenMetadataParams = {
-  stakePool: PublicKey;
-  manager: PublicKey;
-  tokenMetadata: PublicKey;
-  withdrawAuthority: PublicKey;
-  name: string;
-  symbol: string;
-  uri: string;
-};
-
-export type AddValidatorToPoolParams = {
-  stakePool: PublicKey;
-  staker: PublicKey;
-  reserveStake: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  validatorStake: PublicKey;
-  validatorVote: PublicKey;
-  seed?: number;
-};
-
-export type RemoveValidatorFromPoolParams = {
-  stakePool: PublicKey;
-  staker: PublicKey;
-  withdrawAuthority: PublicKey;
-  validatorList: PublicKey;
-  validatorStake: PublicKey;
-  transientStake: PublicKey;
-};
-
-/**
- * Stake Pool Instruction class
- */
-export class StakePoolInstruction {
-  /**
-   * Creates instruction to add a validator into the stake pool.
-   */
-  static addValidatorToPool(params: AddValidatorToPoolParams): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      reserveStake,
-      withdrawAuthority,
-      validatorList,
-      validatorStake,
-      validatorVote,
-      seed,
-    } = params;
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.AddValidatorToPool;
-    const data = encodeData(type, { seed: seed == undefined ? 0 : seed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: validatorVote, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: STAKE_CONFIG_ID, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates instruction to remove a validator from the stake pool.
-   */
-  static removeValidatorFromPool(params: RemoveValidatorFromPoolParams): TransactionInstruction {
-    const { stakePool, staker, withdrawAuthority, validatorList, validatorStake, transientStake } =
-      params;
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.RemoveValidatorFromPool;
-    const data = encodeData(type);
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates instruction to update a set of validators in the stake pool.
-   */
-  static updateValidatorListBalance(
-    params: UpdateValidatorListBalanceParams,
-  ): TransactionInstruction {
-    const {
-      stakePool,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      startIndex,
-      noMerge,
-      validatorAndTransientStakePairs,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.UpdateValidatorListBalance;
-    const data = encodeData(type, { startIndex, noMerge: noMerge ? 1 : 0 });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-      ...validatorAndTransientStakePairs.map((pubkey) => ({
-        pubkey,
-        isSigner: false,
-        isWritable: true,
-      })),
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates instruction to update the overall stake pool balance.
-   */
-  static updateStakePoolBalance(params: UpdateStakePoolBalanceParams): TransactionInstruction {
-    const {
-      stakePool,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      managerFeeAccount,
-      poolMint,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.UpdateStakePoolBalance;
-    const data = encodeData(type);
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: false },
-      { pubkey: managerFeeAccount, isSigner: false, isWritable: true },
-      { pubkey: poolMint, isSigner: false, isWritable: true },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates instruction to cleanup removed validator entries.
-   */
-  static cleanupRemovedValidatorEntries(
-    params: CleanupRemovedValidatorEntriesParams,
-  ): TransactionInstruction {
-    const { stakePool, validatorList } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.CleanupRemovedValidatorEntries;
-    const data = encodeData(type);
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `IncreaseValidatorStake` instruction (rebalance from reserve account to
-   * transient account)
-   */
-  static increaseValidatorStake(params: IncreaseValidatorStakeParams): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      transientStake,
-      validatorStake,
-      validatorVote,
-      lamports,
-      transientStakeSeed,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.IncreaseValidatorStake;
-    const data = encodeData(type, { lamports, transientStakeSeed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: false },
-      { pubkey: validatorVote, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: STAKE_CONFIG_ID, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `IncreaseAdditionalValidatorStake` instruction (rebalance from reserve account to
-   * transient account)
-   */
-  static increaseAdditionalValidatorStake(
-    params: IncreaseAdditionalValidatorStakeParams,
-  ): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      transientStake,
-      validatorStake,
-      validatorVote,
-      lamports,
-      transientStakeSeed,
-      ephemeralStake,
-      ephemeralStakeSeed,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.IncreaseAdditionalValidatorStake;
-    const data = encodeData(type, { lamports, transientStakeSeed, ephemeralStakeSeed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: ephemeralStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: false },
-      { pubkey: validatorVote, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: STAKE_CONFIG_ID, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `DecreaseValidatorStake` instruction (rebalance from validator account to
-   * transient account)
-   */
-  static decreaseValidatorStake(params: DecreaseValidatorStakeParams): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      withdrawAuthority,
-      validatorList,
-      validatorStake,
-      transientStake,
-      lamports,
-      transientStakeSeed,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseValidatorStake;
-    const data = encodeData(type, { lamports, transientStakeSeed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `DecreaseValidatorStakeWithReserve` instruction (rebalance from
-   * validator account to transient account)
-   */
-  static decreaseValidatorStakeWithReserve(
-    params: DecreaseValidatorStakeWithReserveParams,
-  ): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      validatorStake,
-      transientStake,
-      lamports,
-      transientStakeSeed,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseValidatorStakeWithReserve;
-    const data = encodeData(type, { lamports, transientStakeSeed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `DecreaseAdditionalValidatorStake` instruction (rebalance from
-   * validator account to transient account)
-   */
-  static decreaseAdditionalValidatorStake(
-    params: DecreaseAdditionalValidatorStakeParams,
-  ): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      withdrawAuthority,
-      validatorList,
-      reserveStake,
-      validatorStake,
-      transientStake,
-      lamports,
-      transientStakeSeed,
-      ephemeralStakeSeed,
-      ephemeralStake,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseAdditionalValidatorStake;
-    const data = encodeData(type, { lamports, transientStakeSeed, ephemeralStakeSeed });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: ephemeralStake, isSigner: false, isWritable: true },
-      { pubkey: transientStake, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates a transaction instruction to deposit a stake account into a stake pool.
-   */
-  static depositStake(params: DepositStakeParams): TransactionInstruction {
-    const {
-      stakePool,
-      validatorList,
-      depositAuthority,
-      withdrawAuthority,
-      depositStake,
-      validatorStake,
-      reserveStake,
-      destinationPoolAccount,
-      managerFeeAccount,
-      referralPoolAccount,
-      poolMint,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DepositStake;
-    const data = encodeData(type);
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: depositAuthority, isSigner: false, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: depositStake, isSigner: false, isWritable: true },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: destinationPoolAccount, isSigner: false, isWritable: true },
-      { pubkey: managerFeeAccount, isSigner: false, isWritable: true },
-      { pubkey: referralPoolAccount, isSigner: false, isWritable: true },
-      { pubkey: poolMint, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates a transaction instruction to deposit SOL into a stake pool.
-   */
-  static depositSol(params: DepositSolParams): TransactionInstruction {
-    const {
-      stakePool,
-      withdrawAuthority,
-      depositAuthority,
-      reserveStake,
-      fundingAccount,
-      destinationPoolAccount,
-      managerFeeAccount,
-      referralPoolAccount,
-      poolMint,
-      lamports,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DepositSol;
-    const data = encodeData(type, { lamports });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: fundingAccount, isSigner: true, isWritable: true },
-      { pubkey: destinationPoolAccount, isSigner: false, isWritable: true },
-      { pubkey: managerFeeAccount, isSigner: false, isWritable: true },
-      { pubkey: referralPoolAccount, isSigner: false, isWritable: true },
-      { pubkey: poolMint, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    ];
-
-    if (depositAuthority) {
-      keys.push({
-        pubkey: depositAuthority,
-        isSigner: true,
-        isWritable: false,
-      });
-    }
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates a transaction instruction to withdraw active stake from a stake pool.
-   */
-  static withdrawStake(params: WithdrawStakeParams): TransactionInstruction {
-    const {
-      stakePool,
-      validatorList,
-      withdrawAuthority,
-      validatorStake,
-      destinationStake,
-      destinationStakeAuthority,
-      sourceTransferAuthority,
-      sourcePoolAccount,
-      managerFeeAccount,
-      poolMint,
-      poolTokens,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStake;
-    const data = encodeData(type, { poolTokens });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorStake, isSigner: false, isWritable: true },
-      { pubkey: destinationStake, isSigner: false, isWritable: true },
-      { pubkey: destinationStakeAuthority, isSigner: false, isWritable: false },
-      { pubkey: sourceTransferAuthority, isSigner: true, isWritable: false },
-      { pubkey: sourcePoolAccount, isSigner: false, isWritable: true },
-      { pubkey: managerFeeAccount, isSigner: false, isWritable: true },
-      { pubkey: poolMint, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates a transaction instruction to withdraw SOL from a stake pool.
-   */
-  static withdrawSol(params: WithdrawSolParams): TransactionInstruction {
-    const {
-      stakePool,
-      withdrawAuthority,
-      sourceTransferAuthority,
-      sourcePoolAccount,
-      reserveStake,
-      destinationSystemAccount,
-      managerFeeAccount,
-      solWithdrawAuthority,
-      poolMint,
-      poolTokens,
-    } = params;
-
-    const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawSol;
-    const data = encodeData(type, { poolTokens });
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: true },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: sourceTransferAuthority, isSigner: true, isWritable: false },
-      { pubkey: sourcePoolAccount, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: destinationSystemAccount, isSigner: false, isWritable: true },
-      { pubkey: managerFeeAccount, isSigner: false, isWritable: true },
-      { pubkey: poolMint, isSigner: false, isWritable: true },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-    ];
-
-    if (solWithdrawAuthority) {
-      keys.push({
-        pubkey: solWithdrawAuthority,
-        isSigner: true,
-        isWritable: false,
-      });
-    }
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates `Redelegate` instruction (rebalance from one validator account to another)
-   * @param params
-   */
-  static redelegate(params: RedelegateParams): TransactionInstruction {
-    const {
-      stakePool,
-      staker,
-      stakePoolWithdrawAuthority,
-      validatorList,
-      reserveStake,
-      sourceValidatorStake,
-      sourceTransientStake,
-      ephemeralStake,
-      destinationTransientStake,
-      destinationValidatorStake,
-      validator,
-      lamports,
-      sourceTransientStakeSeed,
-      ephemeralStakeSeed,
-      destinationTransientStakeSeed,
-    } = params;
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: staker, isSigner: true, isWritable: false },
-      { pubkey: stakePoolWithdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: validatorList, isSigner: false, isWritable: true },
-      { pubkey: reserveStake, isSigner: false, isWritable: true },
-      { pubkey: sourceValidatorStake, isSigner: false, isWritable: true },
-      { pubkey: sourceTransientStake, isSigner: false, isWritable: true },
-      { pubkey: ephemeralStake, isSigner: false, isWritable: true },
-      { pubkey: destinationTransientStake, isSigner: false, isWritable: true },
-      { pubkey: destinationValidatorStake, isSigner: false, isWritable: false },
-      { pubkey: validator, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
-      { pubkey: STAKE_CONFIG_ID, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    const data = encodeData(STAKE_POOL_INSTRUCTION_LAYOUTS.Redelegate, {
-      lamports,
-      sourceTransientStakeSeed,
-      ephemeralStakeSeed,
-      destinationTransientStakeSeed,
-    });
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates an instruction to create metadata
-   * using the mpl token metadata program for the pool token
-   */
-  static createTokenMetadata(params: CreateTokenMetadataParams): TransactionInstruction {
-    const {
-      stakePool,
-      withdrawAuthority,
-      tokenMetadata,
-      manager,
-      payer,
-      poolMint,
-      name,
-      symbol,
-      uri,
-    } = params;
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: manager, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: poolMint, isSigner: false, isWritable: false },
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: tokenMetadata, isSigner: false, isWritable: true },
-      { pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-    ];
-
-    const type = tokenMetadataLayout(17, name.length, symbol.length, uri.length);
-    const data = encodeData(type, {
-      nameLen: name.length,
-      name: Buffer.from(name),
-      symbolLen: symbol.length,
-      symbol: Buffer.from(symbol),
-      uriLen: uri.length,
-      uri: Buffer.from(uri),
-    });
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Creates an instruction to update metadata
-   * in the mpl token metadata program account for the pool token
-   */
-  static updateTokenMetadata(params: UpdateTokenMetadataParams): TransactionInstruction {
-    const { stakePool, withdrawAuthority, tokenMetadata, manager, name, symbol, uri } = params;
-
-    const keys = [
-      { pubkey: stakePool, isSigner: false, isWritable: false },
-      { pubkey: manager, isSigner: true, isWritable: false },
-      { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
-      { pubkey: tokenMetadata, isSigner: false, isWritable: true },
-      { pubkey: METADATA_PROGRAM_ID, isSigner: false, isWritable: false },
-    ];
-
-    const type = tokenMetadataLayout(18, name.length, symbol.length, uri.length);
-    const data = encodeData(type, {
-      nameLen: name.length,
-      name: Buffer.from(name),
-      symbolLen: symbol.length,
-      symbol: Buffer.from(symbol),
-      uriLen: uri.length,
-      uri: Buffer.from(uri),
-    });
-
-    return new TransactionInstruction({
-      programId: STAKE_POOL_PROGRAM_ID,
-      keys,
-      data,
-    });
-  }
-
-  /**
-   * Decode a deposit stake pool instruction and retrieve the instruction params.
-   */
-  static decodeDepositStake(instruction: TransactionInstruction): DepositStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 11);
-
-    decodeData(STAKE_POOL_INSTRUCTION_LAYOUTS.DepositStake, instruction.data);
-
-    return {
-      stakePool: instruction.keys[0].pubkey,
-      validatorList: instruction.keys[1].pubkey,
-      depositAuthority: instruction.keys[2].pubkey,
-      withdrawAuthority: instruction.keys[3].pubkey,
-      depositStake: instruction.keys[4].pubkey,
-      validatorStake: instruction.keys[5].pubkey,
-      reserveStake: instruction.keys[6].pubkey,
-      destinationPoolAccount: instruction.keys[7].pubkey,
-      managerFeeAccount: instruction.keys[8].pubkey,
-      referralPoolAccount: instruction.keys[9].pubkey,
-      poolMint: instruction.keys[10].pubkey,
-    };
-  }
-
-  /**
-   * Decode a deposit sol instruction and retrieve the instruction params.
-   */
-  static decodeDepositSol(instruction: TransactionInstruction): DepositSolParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 9);
-
-    const { amount } = decodeData(STAKE_POOL_INSTRUCTION_LAYOUTS.DepositSol, instruction.data);
-
-    return {
-      stakePool: instruction.keys[0].pubkey,
-      depositAuthority: instruction.keys[1].pubkey,
-      withdrawAuthority: instruction.keys[2].pubkey,
-      reserveStake: instruction.keys[3].pubkey,
-      fundingAccount: instruction.keys[4].pubkey,
-      destinationPoolAccount: instruction.keys[5].pubkey,
-      managerFeeAccount: instruction.keys[6].pubkey,
-      referralPoolAccount: instruction.keys[7].pubkey,
-      poolMint: instruction.keys[8].pubkey,
-      lamports: amount,
-    };
-  }
-
-  /**
-   * @internal
-   */
-  private static checkProgramId(programId: PublicKey) {
-    if (!programId.equals(StakeProgram.programId)) {
-      throw new Error('Invalid instruction; programId is not StakeProgram');
-    }
-  }
-
-  /**
-   * @internal
-   */
-  private static checkKeyLength(keys: Array<any>, expectedLength: number) {
-    if (keys.length < expectedLength) {
-      throw new Error(
-        `Invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`,
-      );
-    }
-  }
-}
diff --git a/stake-pool/js/src/layouts.ts b/stake-pool/js/src/layouts.ts
deleted file mode 100644
index bc6c3cd3138..00000000000
--- a/stake-pool/js/src/layouts.ts
+++ /dev/null
@@ -1,246 +0,0 @@
-import { Layout, publicKey, u64, option, vec } from './codecs';
-import { struct, Layout as LayoutCls, u8, u32 } from 'buffer-layout';
-import { PublicKey } from '@solana/web3.js';
-import BN from 'bn.js';
-import {
-  Infer,
-  number,
-  nullable,
-  enums,
-  type,
-  coerce,
-  instance,
-  string,
-  optional,
-} from 'superstruct';
-
-export interface Fee {
-  denominator: BN;
-  numerator: BN;
-}
-
-const feeFields = [u64('denominator'), u64('numerator')];
-
-export enum AccountType {
-  Uninitialized,
-  StakePool,
-  ValidatorList,
-}
-
-export const BigNumFromString = coerce(instance(BN), string(), (value) => {
-  if (typeof value === 'string') return new BN(value, 10);
-  throw new Error('invalid big num');
-});
-
-export const PublicKeyFromString = coerce(
-  instance(PublicKey),
-  string(),
-  (value) => new PublicKey(value),
-);
-
-export class FutureEpochLayout<T> extends LayoutCls<T | null> {
-  layout: Layout<T>;
-  discriminator: Layout<number>;
-
-  constructor(layout: Layout<T>, property?: string) {
-    super(-1, property);
-    this.layout = layout;
-    this.discriminator = u8();
-  }
-
-  encode(src: T | null, b: Buffer, offset = 0): number {
-    if (src === null || src === undefined) {
-      return this.discriminator.encode(0, b, offset);
-    }
-    // This isn't right, but we don't typically encode outside of tests
-    this.discriminator.encode(2, b, offset);
-    return this.layout.encode(src, b, offset + 1) + 1;
-  }
-
-  decode(b: Buffer, offset = 0): T | null {
-    const discriminator = this.discriminator.decode(b, offset);
-    if (discriminator === 0) {
-      return null;
-    } else if (discriminator === 1 || discriminator === 2) {
-      return this.layout.decode(b, offset + 1);
-    }
-    throw new Error('Invalid future epoch ' + this.property);
-  }
-
-  getSpan(b: Buffer, offset = 0): number {
-    const discriminator = this.discriminator.decode(b, offset);
-    if (discriminator === 0) {
-      return 1;
-    } else if (discriminator === 1 || discriminator === 2) {
-      return this.layout.getSpan(b, offset + 1) + 1;
-    }
-    throw new Error('Invalid future epoch ' + this.property);
-  }
-}
-
-export function futureEpoch<T>(layout: Layout<T>, property?: string): LayoutCls<T | null> {
-  return new FutureEpochLayout<T>(layout, property);
-}
-
-export type StakeAccountType = Infer<typeof StakeAccountType>;
-export const StakeAccountType = enums(['uninitialized', 'initialized', 'delegated', 'rewardsPool']);
-
-export type StakeMeta = Infer<typeof StakeMeta>;
-export const StakeMeta = type({
-  rentExemptReserve: BigNumFromString,
-  authorized: type({
-    staker: PublicKeyFromString,
-    withdrawer: PublicKeyFromString,
-  }),
-  lockup: type({
-    unixTimestamp: number(),
-    epoch: number(),
-    custodian: PublicKeyFromString,
-  }),
-});
-
-export type StakeAccountInfo = Infer<typeof StakeAccountInfo>;
-export const StakeAccountInfo = type({
-  meta: StakeMeta,
-  stake: nullable(
-    type({
-      delegation: type({
-        voter: PublicKeyFromString,
-        stake: BigNumFromString,
-        activationEpoch: BigNumFromString,
-        deactivationEpoch: BigNumFromString,
-        warmupCooldownRate: number(),
-      }),
-      creditsObserved: number(),
-    }),
-  ),
-});
-
-export type StakeAccount = Infer<typeof StakeAccount>;
-export const StakeAccount = type({
-  type: StakeAccountType,
-  info: optional(StakeAccountInfo),
-});
-export interface Lockup {
-  unixTimestamp: BN;
-  epoch: BN;
-  custodian: PublicKey;
-}
-
-export interface StakePool {
-  accountType: AccountType;
-  manager: PublicKey;
-  staker: PublicKey;
-  stakeDepositAuthority: PublicKey;
-  stakeWithdrawBumpSeed: number;
-  validatorList: PublicKey;
-  reserveStake: PublicKey;
-  poolMint: PublicKey;
-  managerFeeAccount: PublicKey;
-  tokenProgramId: PublicKey;
-  totalLamports: BN;
-  poolTokenSupply: BN;
-  lastUpdateEpoch: BN;
-  lockup: Lockup;
-  epochFee: Fee;
-  nextEpochFee?: Fee | undefined;
-  preferredDepositValidatorVoteAddress?: PublicKey | undefined;
-  preferredWithdrawValidatorVoteAddress?: PublicKey | undefined;
-  stakeDepositFee: Fee;
-  stakeWithdrawalFee: Fee;
-  nextStakeWithdrawalFee?: Fee | undefined;
-  stakeReferralFee: number;
-  solDepositAuthority?: PublicKey | undefined;
-  solDepositFee: Fee;
-  solReferralFee: number;
-  solWithdrawAuthority?: PublicKey | undefined;
-  solWithdrawalFee: Fee;
-  nextSolWithdrawalFee?: Fee | undefined;
-  lastEpochPoolTokenSupply: BN;
-  lastEpochTotalLamports: BN;
-}
-
-export const StakePoolLayout = struct<StakePool>([
-  u8('accountType'),
-  publicKey('manager'),
-  publicKey('staker'),
-  publicKey('stakeDepositAuthority'),
-  u8('stakeWithdrawBumpSeed'),
-  publicKey('validatorList'),
-  publicKey('reserveStake'),
-  publicKey('poolMint'),
-  publicKey('managerFeeAccount'),
-  publicKey('tokenProgramId'),
-  u64('totalLamports'),
-  u64('poolTokenSupply'),
-  u64('lastUpdateEpoch'),
-  struct([u64('unixTimestamp'), u64('epoch'), publicKey('custodian')], 'lockup'),
-  struct(feeFields, 'epochFee'),
-  futureEpoch(struct(feeFields), 'nextEpochFee'),
-  option(publicKey(), 'preferredDepositValidatorVoteAddress'),
-  option(publicKey(), 'preferredWithdrawValidatorVoteAddress'),
-  struct(feeFields, 'stakeDepositFee'),
-  struct(feeFields, 'stakeWithdrawalFee'),
-  futureEpoch(struct(feeFields), 'nextStakeWithdrawalFee'),
-  u8('stakeReferralFee'),
-  option(publicKey(), 'solDepositAuthority'),
-  struct(feeFields, 'solDepositFee'),
-  u8('solReferralFee'),
-  option(publicKey(), 'solWithdrawAuthority'),
-  struct(feeFields, 'solWithdrawalFee'),
-  futureEpoch(struct(feeFields), 'nextSolWithdrawalFee'),
-  u64('lastEpochPoolTokenSupply'),
-  u64('lastEpochTotalLamports'),
-]);
-
-export enum ValidatorStakeInfoStatus {
-  Active,
-  DeactivatingTransient,
-  ReadyForRemoval,
-}
-
-export interface ValidatorStakeInfo {
-  status: ValidatorStakeInfoStatus;
-  voteAccountAddress: PublicKey;
-  activeStakeLamports: BN;
-  transientStakeLamports: BN;
-  transientSeedSuffixStart: BN;
-  transientSeedSuffixEnd: BN;
-  lastUpdateEpoch: BN;
-}
-
-export const ValidatorStakeInfoLayout = struct<ValidatorStakeInfo>([
-  /// Amount of active stake delegated to this validator
-  /// Note that if `last_update_epoch` does not match the current epoch then
-  /// this field may not be accurate
-  u64('activeStakeLamports'),
-  /// Amount of transient stake delegated to this validator
-  /// Note that if `last_update_epoch` does not match the current epoch then
-  /// this field may not be accurate
-  u64('transientStakeLamports'),
-  /// Last epoch the active and transient stake lamports fields were updated
-  u64('lastUpdateEpoch'),
-  /// Start of the validator transient account seed suffixes
-  u64('transientSeedSuffixStart'),
-  /// End of the validator transient account seed suffixes
-  u64('transientSeedSuffixEnd'),
-  /// Status of the validator stake account
-  u8('status'),
-  /// Validator vote account address
-  publicKey('voteAccountAddress'),
-]);
-
-export interface ValidatorList {
-  /// Account type, must be ValidatorList currently
-  accountType: number;
-  /// Maximum allowable number of validators
-  maxValidators: number;
-  /// List of stake info for each validator in the pool
-  validators: ValidatorStakeInfo[];
-}
-
-export const ValidatorListLayout = struct<ValidatorList>([
-  u8('accountType'),
-  u32('maxValidators'),
-  vec(ValidatorStakeInfoLayout, 'validators'),
-]);
diff --git a/stake-pool/js/src/types/buffer-layout.d.ts b/stake-pool/js/src/types/buffer-layout.d.ts
deleted file mode 100644
index 5ef8ba4c87e..00000000000
--- a/stake-pool/js/src/types/buffer-layout.d.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-declare module 'buffer-layout' {
-  export class Layout<T = any> {
-    span: number;
-    property?: string;
-    constructor(span: number, property?: string);
-    decode(b: Buffer | undefined, offset?: number): T;
-    encode(src: T, b: Buffer, offset?: number): number;
-    getSpan(b: Buffer, offset?: number): number;
-    replicate(name: string): this;
-  }
-  export function struct<T>(
-    fields: Layout<any>[],
-    property?: string,
-    decodePrefixes?: boolean,
-  ): Layout<T>;
-  export function seq<T>(
-    elementLayout: Layout<T>,
-    count: number | Layout<number>,
-    property?: string,
-  ): Layout<T[]>;
-  export function offset<T>(layout: Layout<T>, offset?: number, property?: string): Layout<T>;
-  export function blob(length: number | Layout<number>, property?: string): Layout<Buffer>;
-  export function s32(property?: string): Layout<number>;
-  export function u32(property?: string): Layout<number>;
-  export function s16(property?: string): Layout<number>;
-  export function u16(property?: string): Layout<number>;
-  export function s8(property?: string): Layout<number>;
-  export function u8(property?: string): Layout<number>;
-}
diff --git a/stake-pool/js/src/utils/index.ts b/stake-pool/js/src/utils/index.ts
deleted file mode 100644
index e93c2cded11..00000000000
--- a/stake-pool/js/src/utils/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-export * from './math';
-export * from './program-address';
-export * from './stake';
-export * from './instruction';
-
-export function arrayChunk(array: any[], size: number): any[] {
-  const result = [];
-  for (let i = 0; i < array.length; i += size) {
-    result.push(array.slice(i, i + size));
-  }
-  return result;
-}
diff --git a/stake-pool/js/src/utils/instruction.ts b/stake-pool/js/src/utils/instruction.ts
deleted file mode 100644
index 24ccad8ab00..00000000000
--- a/stake-pool/js/src/utils/instruction.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import * as BufferLayout from '@solana/buffer-layout';
-import { Buffer } from 'buffer';
-
-/**
- * @internal
- */
-export type InstructionType = {
-  /** The Instruction index (from solana upstream program) */
-  index: number;
-  /** The BufferLayout to use to build data */
-  layout: BufferLayout.Layout<any>;
-};
-
-/**
- * Populate a buffer of instruction data using an InstructionType
- * @internal
- */
-export function encodeData(type: InstructionType, fields?: any): Buffer {
-  const allocLength = type.layout.span;
-  const data = Buffer.alloc(allocLength);
-  const layoutFields = Object.assign({ instruction: type.index }, fields);
-  type.layout.encode(layoutFields, data);
-
-  return data;
-}
-
-/**
- * Decode instruction data buffer using an InstructionType
- * @internal
- */
-export function decodeData(type: InstructionType, buffer: Buffer): any {
-  let data;
-  try {
-    data = type.layout.decode(buffer);
-  } catch (err) {
-    throw new Error('invalid instruction; ' + err);
-  }
-
-  if (data.instruction !== type.index) {
-    throw new Error(
-      `invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`,
-    );
-  }
-
-  return data;
-}
diff --git a/stake-pool/js/src/utils/math.ts b/stake-pool/js/src/utils/math.ts
deleted file mode 100644
index 5f939bc8611..00000000000
--- a/stake-pool/js/src/utils/math.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import BN from 'bn.js';
-import { LAMPORTS_PER_SOL } from '@solana/web3.js';
-
-export function solToLamports(amount: number): number {
-  if (isNaN(amount)) return Number(0);
-  return Number(amount * LAMPORTS_PER_SOL);
-}
-
-export function lamportsToSol(lamports: number | BN | bigint): number {
-  if (typeof lamports === 'number') {
-    return Math.abs(lamports) / LAMPORTS_PER_SOL;
-  }
-  if (typeof lamports === 'bigint') {
-    return Math.abs(Number(lamports)) / LAMPORTS_PER_SOL;
-  }
-
-  let signMultiplier = 1;
-  if (lamports.isNeg()) {
-    signMultiplier = -1;
-  }
-
-  const absLamports = lamports.abs();
-  const lamportsString = absLamports.toString(10).padStart(10, '0');
-  const splitIndex = lamportsString.length - 9;
-  const solString = lamportsString.slice(0, splitIndex) + '.' + lamportsString.slice(splitIndex);
-  return signMultiplier * parseFloat(solString);
-}
diff --git a/stake-pool/js/src/utils/program-address.ts b/stake-pool/js/src/utils/program-address.ts
deleted file mode 100644
index 827f402113d..00000000000
--- a/stake-pool/js/src/utils/program-address.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import BN from 'bn.js';
-import { Buffer } from 'buffer';
-import {
-  METADATA_PROGRAM_ID,
-  EPHEMERAL_STAKE_SEED_PREFIX,
-  TRANSIENT_STAKE_SEED_PREFIX,
-} from '../constants';
-
-/**
- * Generates the withdraw authority program address for the stake pool
- */
-export async function findWithdrawAuthorityProgramAddress(
-  programId: PublicKey,
-  stakePoolAddress: PublicKey,
-) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [stakePoolAddress.toBuffer(), Buffer.from('withdraw')],
-    programId,
-  );
-  return publicKey;
-}
-
-/**
- * Generates the stake program address for a validator's vote account
- */
-export async function findStakeProgramAddress(
-  programId: PublicKey,
-  voteAccountAddress: PublicKey,
-  stakePoolAddress: PublicKey,
-  seed?: number,
-) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [
-      voteAccountAddress.toBuffer(),
-      stakePoolAddress.toBuffer(),
-      seed ? new BN(seed).toArrayLike(Buffer, 'le', 4) : Buffer.alloc(0),
-    ],
-    programId,
-  );
-  return publicKey;
-}
-
-/**
- * Generates the stake program address for a validator's vote account
- */
-export async function findTransientStakeProgramAddress(
-  programId: PublicKey,
-  voteAccountAddress: PublicKey,
-  stakePoolAddress: PublicKey,
-  seed: BN,
-) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [
-      TRANSIENT_STAKE_SEED_PREFIX,
-      voteAccountAddress.toBuffer(),
-      stakePoolAddress.toBuffer(),
-      seed.toArrayLike(Buffer, 'le', 8),
-    ],
-    programId,
-  );
-  return publicKey;
-}
-
-/**
- * Generates the ephemeral program address for stake pool redelegation
- */
-export async function findEphemeralStakeProgramAddress(
-  programId: PublicKey,
-  stakePoolAddress: PublicKey,
-  seed: BN,
-) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [EPHEMERAL_STAKE_SEED_PREFIX, stakePoolAddress.toBuffer(), seed.toArrayLike(Buffer, 'le', 8)],
-    programId,
-  );
-  return publicKey;
-}
-
-/**
- * Generates the metadata program address for the stake pool
- */
-export function findMetadataAddress(stakePoolMintAddress: PublicKey) {
-  const [publicKey] = PublicKey.findProgramAddressSync(
-    [Buffer.from('metadata'), METADATA_PROGRAM_ID.toBuffer(), stakePoolMintAddress.toBuffer()],
-    METADATA_PROGRAM_ID,
-  );
-  return publicKey;
-}
diff --git a/stake-pool/js/src/utils/stake.ts b/stake-pool/js/src/utils/stake.ts
deleted file mode 100644
index ed4fc1e8b0c..00000000000
--- a/stake-pool/js/src/utils/stake.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-import {
-  Connection,
-  Keypair,
-  PublicKey,
-  StakeProgram,
-  SystemProgram,
-  TransactionInstruction,
-} from '@solana/web3.js';
-import { findStakeProgramAddress, findTransientStakeProgramAddress } from './program-address';
-import BN from 'bn.js';
-
-import { lamportsToSol } from './math';
-import { WithdrawAccount } from '../index';
-import {
-  Fee,
-  StakePool,
-  ValidatorList,
-  ValidatorListLayout,
-  ValidatorStakeInfoStatus,
-} from '../layouts';
-import { MINIMUM_ACTIVE_STAKE, STAKE_POOL_PROGRAM_ID } from '../constants';
-
-export async function getValidatorListAccount(connection: Connection, pubkey: PublicKey) {
-  const account = await connection.getAccountInfo(pubkey);
-  if (!account) {
-    throw new Error('Invalid validator list account');
-  }
-
-  return {
-    pubkey,
-    account: {
-      data: ValidatorListLayout.decode(account?.data) as ValidatorList,
-      executable: account.executable,
-      lamports: account.lamports,
-      owner: account.owner,
-    },
-  };
-}
-
-export interface ValidatorAccount {
-  type: 'preferred' | 'active' | 'transient' | 'reserve';
-  voteAddress?: PublicKey | undefined;
-  stakeAddress: PublicKey;
-  lamports: BN;
-}
-
-export async function prepareWithdrawAccounts(
-  connection: Connection,
-  stakePool: StakePool,
-  stakePoolAddress: PublicKey,
-  amount: BN,
-  compareFn?: (a: ValidatorAccount, b: ValidatorAccount) => number,
-  skipFee?: boolean,
-): Promise<WithdrawAccount[]> {
-  const validatorListAcc = await connection.getAccountInfo(stakePool.validatorList);
-  const validatorList = ValidatorListLayout.decode(validatorListAcc?.data) as ValidatorList;
-
-  if (!validatorList?.validators || validatorList?.validators.length == 0) {
-    throw new Error('No accounts found');
-  }
-
-  const minBalanceForRentExemption = await connection.getMinimumBalanceForRentExemption(
-    StakeProgram.space,
-  );
-  const minBalance = new BN(minBalanceForRentExemption + MINIMUM_ACTIVE_STAKE);
-
-  let accounts = [] as Array<{
-    type: 'preferred' | 'active' | 'transient' | 'reserve';
-    voteAddress?: PublicKey | undefined;
-    stakeAddress: PublicKey;
-    lamports: BN;
-  }>;
-
-  // Prepare accounts
-  for (const validator of validatorList.validators) {
-    if (validator.status !== ValidatorStakeInfoStatus.Active) {
-      continue;
-    }
-
-    const stakeAccountAddress = await findStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      validator.voteAccountAddress,
-      stakePoolAddress,
-    );
-
-    if (!validator.activeStakeLamports.isZero()) {
-      const isPreferred = stakePool?.preferredWithdrawValidatorVoteAddress?.equals(
-        validator.voteAccountAddress,
-      );
-      accounts.push({
-        type: isPreferred ? 'preferred' : 'active',
-        voteAddress: validator.voteAccountAddress,
-        stakeAddress: stakeAccountAddress,
-        lamports: validator.activeStakeLamports,
-      });
-    }
-
-    const transientStakeLamports = validator.transientStakeLamports.sub(minBalance);
-    if (transientStakeLamports.gt(new BN(0))) {
-      const transientStakeAccountAddress = await findTransientStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validator.voteAccountAddress,
-        stakePoolAddress,
-        validator.transientSeedSuffixStart,
-      );
-      accounts.push({
-        type: 'transient',
-        voteAddress: validator.voteAccountAddress,
-        stakeAddress: transientStakeAccountAddress,
-        lamports: transientStakeLamports,
-      });
-    }
-  }
-
-  // Sort from highest to lowest balance
-  accounts = accounts.sort(compareFn ? compareFn : (a, b) => b.lamports.sub(a.lamports).toNumber());
-
-  const reserveStake = await connection.getAccountInfo(stakePool.reserveStake);
-  const reserveStakeBalance = new BN((reserveStake?.lamports ?? 0) - minBalanceForRentExemption);
-  if (reserveStakeBalance.gt(new BN(0))) {
-    accounts.push({
-      type: 'reserve',
-      stakeAddress: stakePool.reserveStake,
-      lamports: reserveStakeBalance,
-    });
-  }
-
-  // Prepare the list of accounts to withdraw from
-  const withdrawFrom: WithdrawAccount[] = [];
-  let remainingAmount = new BN(amount);
-
-  const fee = stakePool.stakeWithdrawalFee;
-  const inverseFee: Fee = {
-    numerator: fee.denominator.sub(fee.numerator),
-    denominator: fee.denominator,
-  };
-
-  for (const type of ['preferred', 'active', 'transient', 'reserve']) {
-    const filteredAccounts = accounts.filter((a) => a.type == type);
-
-    for (const { stakeAddress, voteAddress, lamports } of filteredAccounts) {
-      if (lamports.lte(minBalance) && type == 'transient') {
-        continue;
-      }
-
-      let availableForWithdrawal = calcPoolTokensForDeposit(stakePool, lamports);
-
-      if (!skipFee && !inverseFee.numerator.isZero()) {
-        availableForWithdrawal = availableForWithdrawal
-          .mul(inverseFee.denominator)
-          .div(inverseFee.numerator);
-      }
-
-      const poolAmount = BN.min(availableForWithdrawal, remainingAmount);
-      if (poolAmount.lte(new BN(0))) {
-        continue;
-      }
-
-      // Those accounts will be withdrawn completely with `claim` instruction
-      withdrawFrom.push({ stakeAddress, voteAddress, poolAmount });
-      remainingAmount = remainingAmount.sub(poolAmount);
-
-      if (remainingAmount.isZero()) {
-        break;
-      }
-    }
-
-    if (remainingAmount.isZero()) {
-      break;
-    }
-  }
-
-  // Not enough stake to withdraw the specified amount
-  if (remainingAmount.gt(new BN(0))) {
-    throw new Error(
-      `No stake accounts found in this pool with enough balance to withdraw ${lamportsToSol(
-        amount,
-      )} pool tokens.`,
-    );
-  }
-
-  return withdrawFrom;
-}
-
-/**
- * Calculate the pool tokens that should be minted for a deposit of `stakeLamports`
- */
-export function calcPoolTokensForDeposit(stakePool: StakePool, stakeLamports: BN): BN {
-  if (stakePool.poolTokenSupply.isZero() || stakePool.totalLamports.isZero()) {
-    return stakeLamports;
-  }
-  const numerator = stakeLamports.mul(stakePool.poolTokenSupply);
-  return numerator.div(stakePool.totalLamports);
-}
-
-/**
- * Calculate lamports amount on withdrawal
- */
-export function calcLamportsWithdrawAmount(stakePool: StakePool, poolTokens: BN): BN {
-  const numerator = poolTokens.mul(stakePool.totalLamports);
-  const denominator = stakePool.poolTokenSupply;
-  if (numerator.lt(denominator)) {
-    return new BN(0);
-  }
-  return numerator.div(denominator);
-}
-
-export function newStakeAccount(
-  feePayer: PublicKey,
-  instructions: TransactionInstruction[],
-  lamports: number,
-): Keypair {
-  // Account for tokens not specified, creating one
-  const stakeReceiverKeypair = Keypair.generate();
-  console.log(`Creating account to receive stake ${stakeReceiverKeypair.publicKey}`);
-
-  instructions.push(
-    // Creating new account
-    SystemProgram.createAccount({
-      fromPubkey: feePayer,
-      newAccountPubkey: stakeReceiverKeypair.publicKey,
-      lamports,
-      space: StakeProgram.space,
-      programId: StakeProgram.programId,
-    }),
-  );
-
-  return stakeReceiverKeypair;
-}
diff --git a/stake-pool/js/test/calculation.test.ts b/stake-pool/js/test/calculation.test.ts
deleted file mode 100644
index dd6083ece24..00000000000
--- a/stake-pool/js/test/calculation.test.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { stakePoolMock } from './mocks';
-import { calcPoolTokensForDeposit } from '../src/utils/stake';
-import BN from 'bn.js';
-
-describe('calculations', () => {
-  it('should successfully calculate pool tokens for a pool with a lot of stake', () => {
-    const lamports = new BN(LAMPORTS_PER_SOL * 100);
-    const bigStakePoolMock = stakePoolMock;
-    bigStakePoolMock.totalLamports = new BN('11000000000000000'); // 11 million SOL
-    bigStakePoolMock.poolTokenSupply = new BN('10000000000000000'); // 10 million tokens
-    const availableForWithdrawal = calcPoolTokensForDeposit(bigStakePoolMock, lamports);
-    expect(availableForWithdrawal.toNumber()).toEqual(90909090909);
-  });
-});
diff --git a/stake-pool/js/test/equal.ts b/stake-pool/js/test/equal.ts
deleted file mode 100644
index b86e417bc9b..00000000000
--- a/stake-pool/js/test/equal.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import BN from 'bn.js';
-
-/**
- * Helper function to do deep equality check because BNs are not equal.
- * TODO: write this function recursively. For now, sufficient.
- */
-export function deepStrictEqualBN(a: any, b: any) {
-  for (const key in a) {
-    if (b[key] instanceof BN) {
-      expect(b[key].toString()).toEqual(a[key].toString());
-    } else {
-      if (a[key] instanceof Object) {
-        for (const subkey in a[key]) {
-          if (a[key][subkey] instanceof Object) {
-            if (a[key][subkey] instanceof BN) {
-              expect(b[key][subkey].toString()).toEqual(a[key][subkey].toString());
-            } else {
-              for (const subsubkey in a[key][subkey]) {
-                if (a[key][subkey][subsubkey] instanceof BN) {
-                  expect(b[key][subkey][subsubkey].toString()).toEqual(
-                    a[key][subkey][subsubkey].toString(),
-                  );
-                } else {
-                  expect(b[key][subkey][subsubkey]).toStrictEqual(a[key][subkey][subsubkey]);
-                }
-              }
-            }
-          } else {
-            expect(b[key][subkey]).toStrictEqual(a[key][subkey]);
-          }
-        }
-      } else {
-        expect(b[key]).toStrictEqual(a[key]);
-      }
-    }
-  }
-}
diff --git a/stake-pool/js/test/instructions.test.ts b/stake-pool/js/test/instructions.test.ts
deleted file mode 100644
index 490e777fb87..00000000000
--- a/stake-pool/js/test/instructions.test.ts
+++ /dev/null
@@ -1,567 +0,0 @@
-// Very important! We need to do this polyfill before any of the imports because
-// some web3.js dependencies store `crypto` elsewhere.
-import { randomBytes } from 'crypto';
-Object.defineProperty(globalThis, 'crypto', {
-  value: {
-    getRandomValues: (arr: any) => randomBytes(arr.length),
-  },
-});
-
-import {
-  PublicKey,
-  Connection,
-  Keypair,
-  SystemProgram,
-  StakeProgram,
-  AccountInfo,
-  LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID, TokenAccountNotFoundError } from '@solana/spl-token';
-import { StakePoolLayout, ValidatorListLayout } from '../src/layouts';
-import {
-  STAKE_POOL_INSTRUCTION_LAYOUTS,
-  DepositSolParams,
-  AddValidatorToPoolParams,
-  RemoveValidatorFromPoolParams,
-  StakePoolInstruction,
-  depositSol,
-  withdrawSol,
-  withdrawStake,
-  redelegate,
-  getStakeAccount,
-  createPoolTokenMetadata,
-  updatePoolTokenMetadata,
-  tokenMetadataLayout,
-  addValidatorToPool,
-  removeValidatorFromPool,
-} from '../src';
-import { STAKE_POOL_PROGRAM_ID } from '../src/constants';
-
-import { decodeData, findStakeProgramAddress } from '../src/utils';
-
-import {
-  mockRpc,
-  mockTokenAccount,
-  mockValidatorList,
-  mockValidatorsStakeAccount,
-  stakePoolMock,
-  CONSTANTS,
-  stakeAccountData,
-  uninitializedStakeAccount,
-  validatorListMock,
-} from './mocks';
-
-describe('StakePoolProgram', () => {
-  const connection = new Connection('http://127.0.0.1:8899');
-
-  connection.getMinimumBalanceForRentExemption = jest.fn(async () => 10000);
-
-  const stakePoolAddress = new PublicKey('SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy');
-
-  const data = Buffer.alloc(1024);
-  StakePoolLayout.encode(stakePoolMock, data);
-
-  const stakePoolAccount = <AccountInfo<any>>{
-    executable: true,
-    owner: stakePoolAddress,
-    lamports: 99999,
-    data,
-  };
-
-  it('StakePoolInstruction.addValidatorToPool', () => {
-    const payload: AddValidatorToPoolParams = {
-      stakePool: stakePoolAddress,
-      staker: Keypair.generate().publicKey,
-      reserveStake: Keypair.generate().publicKey,
-      withdrawAuthority: Keypair.generate().publicKey,
-      validatorList: Keypair.generate().publicKey,
-      validatorStake: Keypair.generate().publicKey,
-      validatorVote: PublicKey.default,
-      seed: 0,
-    };
-
-    const instruction = StakePoolInstruction.addValidatorToPool(payload);
-    expect(instruction.keys).toHaveLength(13);
-    expect(instruction.keys[0].pubkey).toEqual(payload.stakePool);
-    expect(instruction.keys[1].pubkey).toEqual(payload.staker);
-    expect(instruction.keys[2].pubkey).toEqual(payload.reserveStake);
-    expect(instruction.keys[3].pubkey).toEqual(payload.withdrawAuthority);
-    expect(instruction.keys[4].pubkey).toEqual(payload.validatorList);
-    expect(instruction.keys[5].pubkey).toEqual(payload.validatorStake);
-    expect(instruction.keys[6].pubkey).toEqual(payload.validatorVote);
-    expect(instruction.keys[11].pubkey).toEqual(SystemProgram.programId);
-    expect(instruction.keys[12].pubkey).toEqual(StakeProgram.programId);
-
-    const decodedData = decodeData(
-      STAKE_POOL_INSTRUCTION_LAYOUTS.AddValidatorToPool,
-      instruction.data,
-    );
-    expect(decodedData.instruction).toEqual(
-      STAKE_POOL_INSTRUCTION_LAYOUTS.AddValidatorToPool.index,
-    );
-    expect(decodedData.seed).toEqual(payload.seed);
-  });
-
-  it('StakePoolInstruction.removeValidatorFromPool', () => {
-    const payload: RemoveValidatorFromPoolParams = {
-      stakePool: stakePoolAddress,
-      staker: Keypair.generate().publicKey,
-      withdrawAuthority: Keypair.generate().publicKey,
-      validatorList: Keypair.generate().publicKey,
-      validatorStake: Keypair.generate().publicKey,
-      transientStake: Keypair.generate().publicKey,
-    };
-
-    const instruction = StakePoolInstruction.removeValidatorFromPool(payload);
-    expect(instruction.keys).toHaveLength(8);
-    expect(instruction.keys[0].pubkey).toEqual(payload.stakePool);
-    expect(instruction.keys[1].pubkey).toEqual(payload.staker);
-    expect(instruction.keys[2].pubkey).toEqual(payload.withdrawAuthority);
-    expect(instruction.keys[3].pubkey).toEqual(payload.validatorList);
-    expect(instruction.keys[4].pubkey).toEqual(payload.validatorStake);
-    expect(instruction.keys[5].pubkey).toEqual(payload.transientStake);
-    expect(instruction.keys[7].pubkey).toEqual(StakeProgram.programId);
-
-    const decodedData = decodeData(
-      STAKE_POOL_INSTRUCTION_LAYOUTS.RemoveValidatorFromPool,
-      instruction.data,
-    );
-    expect(decodedData.instruction).toEqual(
-      STAKE_POOL_INSTRUCTION_LAYOUTS.RemoveValidatorFromPool.index,
-    );
-  });
-
-  it('StakePoolInstruction.depositSol', () => {
-    const payload: DepositSolParams = {
-      stakePool: stakePoolAddress,
-      withdrawAuthority: Keypair.generate().publicKey,
-      reserveStake: Keypair.generate().publicKey,
-      fundingAccount: Keypair.generate().publicKey,
-      destinationPoolAccount: Keypair.generate().publicKey,
-      managerFeeAccount: Keypair.generate().publicKey,
-      referralPoolAccount: Keypair.generate().publicKey,
-      poolMint: Keypair.generate().publicKey,
-      lamports: 99999,
-    };
-
-    const instruction = StakePoolInstruction.depositSol(payload);
-
-    expect(instruction.keys).toHaveLength(10);
-    expect(instruction.keys[0].pubkey).toEqual(payload.stakePool);
-    expect(instruction.keys[1].pubkey).toEqual(payload.withdrawAuthority);
-    expect(instruction.keys[3].pubkey).toEqual(payload.fundingAccount);
-    expect(instruction.keys[4].pubkey).toEqual(payload.destinationPoolAccount);
-    expect(instruction.keys[5].pubkey).toEqual(payload.managerFeeAccount);
-    expect(instruction.keys[6].pubkey).toEqual(payload.referralPoolAccount);
-    expect(instruction.keys[8].pubkey).toEqual(SystemProgram.programId);
-    expect(instruction.keys[9].pubkey).toEqual(TOKEN_PROGRAM_ID);
-
-    const decodedData = decodeData(STAKE_POOL_INSTRUCTION_LAYOUTS.DepositSol, instruction.data);
-
-    expect(decodedData.instruction).toEqual(STAKE_POOL_INSTRUCTION_LAYOUTS.DepositSol.index);
-    expect(decodedData.lamports).toEqual(payload.lamports);
-
-    payload.depositAuthority = Keypair.generate().publicKey;
-
-    const instruction2 = StakePoolInstruction.depositSol(payload);
-
-    expect(instruction2.keys).toHaveLength(11);
-    expect(instruction2.keys[10].pubkey).toEqual(payload.depositAuthority);
-  });
-
-  describe('addValidatorToPool', () => {
-    const validatorList = mockValidatorList();
-    const decodedValidatorList = ValidatorListLayout.decode(validatorList.data);
-    const voteAccount = decodedValidatorList.validators[0].voteAccountAddress;
-
-    it('should throw an error when trying to add an existing validator', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        return mockValidatorList();
-      });
-      await expect(addValidatorToPool(connection, stakePoolAddress, voteAccount)).rejects.toThrow(
-        Error('Vote account is already in validator list'),
-      );
-    });
-
-    it('should successfully add a validator', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        return <AccountInfo<any>>{
-          executable: true,
-          owner: new PublicKey(0),
-          lamports: 0,
-          data,
-        };
-      });
-      const res = await addValidatorToPool(
-        connection,
-        stakePoolAddress,
-        validatorListMock.validators[0].voteAccountAddress,
-      );
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(2);
-      expect(res.instructions).toHaveLength(1);
-      // Make sure that the validator vote account being added is the one we passed
-      expect(res.instructions[0].keys[6].pubkey).toEqual(
-        validatorListMock.validators[0].voteAccountAddress,
-      );
-    });
-  });
-
-  describe('removeValidatorFromPool', () => {
-    const voteAccount = Keypair.generate().publicKey;
-
-    it('should throw an error when trying to remove a non-existing validator', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(stakePoolMock.validatorList)) {
-          return mockValidatorList();
-        }
-        return <AccountInfo<any>>{
-          executable: true,
-          owner: new PublicKey(0),
-          lamports: 0,
-          data,
-        };
-      });
-      await expect(
-        removeValidatorFromPool(connection, stakePoolAddress, voteAccount),
-      ).rejects.toThrow(Error('Vote account is not already in validator list'));
-    });
-
-    it('should successfully remove a validator', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(stakePoolMock.validatorList)) {
-          return mockValidatorList();
-        }
-        return <AccountInfo<any>>{
-          executable: true,
-          owner: new PublicKey(0),
-          lamports: 0,
-          data,
-        };
-      });
-      const res = await removeValidatorFromPool(
-        connection,
-        stakePoolAddress,
-        validatorListMock.validators[0].voteAccountAddress,
-      );
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(2);
-      expect(res.instructions).toHaveLength(1);
-      // Make sure that the validator stake account being removed is the one we passed
-      const validatorStake = await findStakeProgramAddress(
-        STAKE_POOL_PROGRAM_ID,
-        validatorListMock.validators[0].voteAccountAddress,
-        stakePoolAddress,
-        0,
-      );
-      expect(res.instructions[0].keys[4].pubkey).toEqual(validatorStake);
-    });
-  });
-
-  describe('depositSol', () => {
-    const from = Keypair.generate().publicKey;
-    const balance = 10000;
-
-    connection.getBalance = jest.fn(async () => balance);
-
-    connection.getAccountInfo = jest.fn(async (pubKey) => {
-      if (pubKey == stakePoolAddress) {
-        return stakePoolAccount;
-      }
-      return <AccountInfo<any>>{
-        executable: true,
-        owner: from,
-        lamports: balance,
-        data: null,
-      };
-    });
-
-    it('should throw an error with invalid balance', async () => {
-      await expect(depositSol(connection, stakePoolAddress, from, balance + 1)).rejects.toThrow(
-        Error('Not enough SOL to deposit into pool. Maximum deposit amount is 0.00001 SOL.'),
-      );
-    });
-
-    it('should throw an error with invalid account', async () => {
-      connection.getAccountInfo = jest.fn(async () => null);
-      await expect(depositSol(connection, stakePoolAddress, from, balance)).rejects.toThrow(
-        Error('Invalid stake pool account'),
-      );
-    });
-
-    it('should call successfully', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        return <AccountInfo<any>>{
-          executable: true,
-          owner: from,
-          lamports: balance,
-          data: null,
-        };
-      });
-
-      const res = await depositSol(connection, stakePoolAddress, from, balance);
-
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(1);
-      expect(res.instructions).toHaveLength(3);
-      expect(res.signers).toHaveLength(1);
-    });
-  });
-
-  describe('withdrawSol', () => {
-    const tokenOwner = new PublicKey(0);
-    const solReceiver = new PublicKey(1);
-
-    it('should throw an error with invalid stake pool account', async () => {
-      connection.getAccountInfo = jest.fn(async () => null);
-      await expect(
-        withdrawSol(connection, stakePoolAddress, tokenOwner, solReceiver, 1),
-      ).rejects.toThrowError('Invalid stake pool account');
-    });
-
-    it('should throw an error with invalid token account', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return null;
-        }
-        return null;
-      });
-
-      await expect(
-        withdrawSol(connection, stakePoolAddress, tokenOwner, solReceiver, 1),
-      ).rejects.toThrow(TokenAccountNotFoundError);
-    });
-
-    it('should throw an error with invalid token account balance', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey === stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return mockTokenAccount(0);
-        }
-        return null;
-      });
-
-      await expect(
-        withdrawSol(connection, stakePoolAddress, tokenOwner, solReceiver, 1),
-      ).rejects.toThrow(
-        Error(
-          'Not enough token balance to withdraw 1 pool tokens.\n          Maximum withdraw amount is 0 pool tokens.',
-        ),
-      );
-    });
-
-    it('should call successfully', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return mockTokenAccount(LAMPORTS_PER_SOL);
-        }
-        return null;
-      });
-      const res = await withdrawSol(connection, stakePoolAddress, tokenOwner, solReceiver, 1);
-
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(2);
-      expect(res.instructions).toHaveLength(2);
-      expect(res.signers).toHaveLength(1);
-    });
-  });
-
-  describe('withdrawStake', () => {
-    const tokenOwner = new PublicKey(0);
-
-    it('should throw an error with invalid token account', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        return null;
-      });
-
-      await expect(withdrawStake(connection, stakePoolAddress, tokenOwner, 1)).rejects.toThrow(
-        TokenAccountNotFoundError,
-      );
-    });
-
-    it('should throw an error with invalid token account balance', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return mockTokenAccount(0);
-        }
-        return null;
-      });
-
-      await expect(withdrawStake(connection, stakePoolAddress, tokenOwner, 1)).rejects.toThrow(
-        Error(
-          'Not enough token balance to withdraw 1 pool tokens.\n' +
-            '        Maximum withdraw amount is 0 pool tokens.',
-        ),
-      );
-    });
-
-    it('should call successfully', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return mockTokenAccount(LAMPORTS_PER_SOL * 2);
-        }
-        if (pubKey.equals(stakePoolMock.validatorList)) {
-          return mockValidatorList();
-        }
-        return null;
-      });
-      const res = await withdrawStake(connection, stakePoolAddress, tokenOwner, 1);
-
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(4);
-      expect(res.instructions).toHaveLength(3);
-      expect(res.signers).toHaveLength(2);
-      expect(res.stakeReceiver).toEqual(undefined);
-      expect(res.totalRentFreeBalances).toEqual(10000);
-    });
-
-    it('withdraw to a stake account provided', async () => {
-      const stakeReceiver = new PublicKey(20);
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        if (pubKey.equals(CONSTANTS.poolTokenAccount)) {
-          return mockTokenAccount(LAMPORTS_PER_SOL * 2);
-        }
-        if (pubKey.equals(stakePoolMock.validatorList)) {
-          return mockValidatorList();
-        }
-        if (pubKey.equals(CONSTANTS.validatorStakeAccountAddress))
-          return mockValidatorsStakeAccount();
-        return null;
-      });
-      connection.getParsedAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey.equals(stakeReceiver)) {
-          return mockRpc(stakeAccountData);
-        }
-        return null;
-      });
-
-      const res = await withdrawStake(
-        connection,
-        stakePoolAddress,
-        tokenOwner,
-        1,
-        undefined,
-        undefined,
-        stakeReceiver,
-      );
-
-      expect((connection.getAccountInfo as jest.Mock).mock.calls.length).toBe(4);
-      expect((connection.getParsedAccountInfo as jest.Mock).mock.calls.length).toBe(1);
-      expect(res.instructions).toHaveLength(3);
-      expect(res.signers).toHaveLength(2);
-      expect(res.stakeReceiver).toEqual(stakeReceiver);
-      expect(res.totalRentFreeBalances).toEqual(10000);
-    });
-  });
-  describe('getStakeAccount', () => {
-    it('returns an uninitialized parsed stake account', async () => {
-      const stakeAccount = new PublicKey(20);
-      connection.getParsedAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey.equals(stakeAccount)) {
-          return mockRpc(uninitializedStakeAccount);
-        }
-        return null;
-      });
-      const parsedStakeAccount = await getStakeAccount(connection, stakeAccount);
-      expect((connection.getParsedAccountInfo as jest.Mock).mock.calls.length).toBe(1);
-      expect(parsedStakeAccount).toEqual(uninitializedStakeAccount.parsed);
-    });
-  });
-
-  describe('redelegation', () => {
-    it('should call successfully', async () => {
-      const data = {
-        connection,
-        stakePoolAddress,
-        sourceVoteAccount: PublicKey.default,
-        sourceTransientStakeSeed: 10,
-        destinationVoteAccount: PublicKey.default,
-        destinationTransientStakeSeed: 20,
-        ephemeralStakeSeed: 100,
-        lamports: 100,
-      };
-      const res = await redelegate(data);
-
-      const decodedData = STAKE_POOL_INSTRUCTION_LAYOUTS.Redelegate.layout.decode(
-        res.instructions[0].data,
-      );
-
-      expect(decodedData.instruction).toBe(22);
-      expect(decodedData.lamports).toBe(data.lamports);
-      expect(decodedData.sourceTransientStakeSeed).toBe(data.sourceTransientStakeSeed);
-      expect(decodedData.destinationTransientStakeSeed).toBe(data.destinationTransientStakeSeed);
-      expect(decodedData.ephemeralStakeSeed).toBe(data.ephemeralStakeSeed);
-    });
-  });
-  describe('createPoolTokenMetadata', () => {
-    it('should create pool token metadata', async () => {
-      connection.getAccountInfo = jest.fn(async (pubKey: PublicKey) => {
-        if (pubKey == stakePoolAddress) {
-          return stakePoolAccount;
-        }
-        return null;
-      });
-      const name = 'test';
-      const symbol = 'TEST';
-      const uri = 'https://example.com';
-
-      const payer = new PublicKey(0);
-      const res = await createPoolTokenMetadata(
-        connection,
-        stakePoolAddress,
-        payer,
-        name,
-        symbol,
-        uri,
-      );
-
-      const type = tokenMetadataLayout(17, name.length, symbol.length, uri.length);
-      const data = decodeData(type, res.instructions[0].data);
-      expect(Buffer.from(data.name).toString()).toBe(name);
-      expect(Buffer.from(data.symbol).toString()).toBe(symbol);
-      expect(Buffer.from(data.uri).toString()).toBe(uri);
-    });
-
-    it('should update pool token metadata', async () => {
-      const name = 'test';
-      const symbol = 'TEST';
-      const uri = 'https://example.com';
-      const res = await updatePoolTokenMetadata(connection, stakePoolAddress, name, symbol, uri);
-      const type = tokenMetadataLayout(18, name.length, symbol.length, uri.length);
-      const data = decodeData(type, res.instructions[0].data);
-      expect(Buffer.from(data.name).toString()).toBe(name);
-      expect(Buffer.from(data.symbol).toString()).toBe(symbol);
-      expect(Buffer.from(data.uri).toString()).toBe(uri);
-    });
-  });
-});
diff --git a/stake-pool/js/test/layouts.test.ts b/stake-pool/js/test/layouts.test.ts
deleted file mode 100644
index 053f43e1c7d..00000000000
--- a/stake-pool/js/test/layouts.test.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { StakePoolLayout, ValidatorListLayout, ValidatorList } from '../src/layouts';
-import { deepStrictEqualBN } from './equal';
-import { stakePoolMock, validatorListMock } from './mocks';
-
-describe('layouts', () => {
-  describe('StakePoolAccount', () => {
-    it('should successfully decode StakePoolAccount data', () => {
-      const encodedData = Buffer.alloc(1024);
-      StakePoolLayout.encode(stakePoolMock, encodedData);
-      const decodedData = StakePoolLayout.decode(encodedData);
-      deepStrictEqualBN(decodedData, stakePoolMock);
-    });
-  });
-
-  describe('ValidatorListAccount', () => {
-    it('should successfully decode ValidatorListAccount account data', () => {
-      const expectedData: ValidatorList = {
-        accountType: 0,
-        maxValidators: 10,
-        validators: [],
-      };
-      const encodedData = Buffer.alloc(64);
-      ValidatorListLayout.encode(expectedData, encodedData);
-      const decodedData = ValidatorListLayout.decode(encodedData);
-      expect(decodedData).toEqual(expectedData);
-    });
-
-    it('should successfully decode ValidatorListAccount with nonempty ValidatorInfo', () => {
-      const encodedData = Buffer.alloc(1024);
-      ValidatorListLayout.encode(validatorListMock, encodedData);
-      const decodedData = ValidatorListLayout.decode(encodedData);
-      deepStrictEqualBN(decodedData, validatorListMock);
-    });
-  });
-});
diff --git a/stake-pool/js/test/mocks.ts b/stake-pool/js/test/mocks.ts
deleted file mode 100644
index c9c10839f7c..00000000000
--- a/stake-pool/js/test/mocks.ts
+++ /dev/null
@@ -1,217 +0,0 @@
-import { AccountInfo, LAMPORTS_PER_SOL, PublicKey, StakeProgram } from '@solana/web3.js';
-import BN from 'bn.js';
-import { ValidatorStakeInfo } from '../src';
-import { AccountLayout, TOKEN_PROGRAM_ID } from '@solana/spl-token';
-import { ValidatorListLayout, ValidatorStakeInfoStatus } from '../src/layouts';
-
-export const CONSTANTS = {
-  poolTokenAccount: new PublicKey('GQkqTamwqjaNDfsbNm7r3aXPJ4oTSqKC3d5t2PF9Smqd'),
-  validatorStakeAccountAddress: new PublicKey(
-    new BN('69184b7f1bc836271c4ac0e29e53eb38a38ea0e7bcde693c45b30d1592a5a678', 'hex'),
-  ),
-};
-
-export const stakePoolMock = {
-  accountType: 1,
-  manager: new PublicKey(11),
-  staker: new PublicKey(12),
-  stakeDepositAuthority: new PublicKey(13),
-  stakeWithdrawBumpSeed: 255,
-  validatorList: new PublicKey(14),
-  reserveStake: new PublicKey(15),
-  poolMint: new PublicKey(16),
-  managerFeeAccount: new PublicKey(17),
-  tokenProgramId: new PublicKey(18),
-  totalLamports: new BN(LAMPORTS_PER_SOL * 999),
-  poolTokenSupply: new BN(LAMPORTS_PER_SOL * 100),
-  lastUpdateEpoch: new BN('7c', 'hex'),
-  lockup: {
-    unixTimestamp: new BN(Date.now()),
-    epoch: new BN(1),
-    custodian: new PublicKey(0),
-  },
-  epochFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  nextEpochFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  preferredDepositValidatorVoteAddress: new PublicKey(1),
-  preferredWithdrawValidatorVoteAddress: new PublicKey(2),
-  stakeDepositFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  stakeWithdrawalFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  nextStakeWithdrawalFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  stakeReferralFee: 0,
-  solDepositAuthority: new PublicKey(0),
-  solDepositFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  solReferralFee: 0,
-  solWithdrawAuthority: new PublicKey(0),
-  solWithdrawalFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  nextSolWithdrawalFee: {
-    denominator: new BN(0),
-    numerator: new BN(0),
-  },
-  lastEpochPoolTokenSupply: new BN(0),
-  lastEpochTotalLamports: new BN(0),
-};
-
-export const validatorListMock = {
-  accountType: 0,
-  maxValidators: 100,
-  validators: <ValidatorStakeInfo[]>[
-    {
-      status: ValidatorStakeInfoStatus.ReadyForRemoval,
-      voteAccountAddress: new PublicKey(
-        new BN('a9946a889af14fd3c9b33d5df309489d9699271a6b09ff3190fcb41cf21a2f8c', 'hex'),
-      ),
-      lastUpdateEpoch: new BN('c3', 'hex'),
-      activeStakeLamports: new BN(123),
-      transientStakeLamports: new BN(999),
-      transientSeedSuffixStart: new BN(999),
-      transientSeedSuffixEnd: new BN(999),
-    },
-    {
-      status: ValidatorStakeInfoStatus.Active,
-      voteAccountAddress: new PublicKey(
-        new BN('3796d40645ee07e3c64117e3f73430471d4c40465f696ebc9b034c1fc06a9f7d', 'hex'),
-      ),
-      lastUpdateEpoch: new BN('c3', 'hex'),
-      activeStakeLamports: new BN(LAMPORTS_PER_SOL * 100),
-      transientStakeLamports: new BN(22),
-      transientSeedSuffixStart: new BN(0),
-      transientSeedSuffixEnd: new BN(0),
-    },
-    {
-      status: ValidatorStakeInfoStatus.Active,
-      voteAccountAddress: new PublicKey(
-        new BN('e4e37d6f2e80c0bb0f3da8a06304e57be5cda6efa2825b86780aa320d9784cf8', 'hex'),
-      ),
-      lastUpdateEpoch: new BN('c3', 'hex'),
-      activeStakeLamports: new BN(0),
-      transientStakeLamports: new BN(0),
-      transientSeedSuffixStart: new BN('a', 'hex'),
-      transientSeedSuffixEnd: new BN('a', 'hex'),
-    },
-  ],
-};
-
-export function mockTokenAccount(amount = 0) {
-  const data = Buffer.alloc(165);
-  AccountLayout.encode(
-    {
-      mint: stakePoolMock.poolMint,
-      owner: new PublicKey(0),
-      amount: BigInt(amount),
-      delegateOption: 0,
-      delegate: new PublicKey(0),
-      delegatedAmount: BigInt(0),
-      state: 1,
-      isNativeOption: 0,
-      isNative: BigInt(0),
-      closeAuthorityOption: 0,
-      closeAuthority: new PublicKey(0),
-    },
-    data,
-  );
-
-  return <AccountInfo<any>>{
-    executable: true,
-    owner: TOKEN_PROGRAM_ID,
-    lamports: amount,
-    data,
-  };
-}
-
-export const mockRpc = (data: any): any => {
-  const value = {
-    owner: StakeProgram.programId,
-    lamports: LAMPORTS_PER_SOL,
-    data: data,
-    executable: false,
-    rentEpoch: 0,
-  };
-  return {
-    context: {
-      slot: 11,
-    },
-    value: value,
-  };
-};
-
-export const stakeAccountData = {
-  program: 'stake',
-  parsed: {
-    type: 'delegated',
-    info: {
-      meta: {
-        rentExemptReserve: new BN(1),
-        lockup: {
-          epoch: 32,
-          unixTimestamp: 2,
-          custodian: new PublicKey(12),
-        },
-        authorized: {
-          staker: new PublicKey(12),
-          withdrawer: new PublicKey(12),
-        },
-      },
-      stake: {
-        delegation: {
-          voter: new PublicKey(
-            new BN('e4e37d6f2e80c0bb0f3da8a06304e57be5cda6efa2825b86780aa320d9784cf8', 'hex'),
-          ),
-          stake: new BN(0),
-          activationEpoch: new BN(1),
-          deactivationEpoch: new BN(1),
-          warmupCooldownRate: 1.2,
-        },
-        creditsObserved: 1,
-      },
-    },
-  },
-};
-
-export const uninitializedStakeAccount = {
-  program: 'stake',
-  parsed: {
-    type: 'uninitialized',
-  },
-};
-
-export function mockValidatorsStakeAccount() {
-  const data = Buffer.alloc(1024);
-  return <AccountInfo<any>>{
-    executable: false,
-    owner: StakeProgram.programId,
-    lamports: 3000000000,
-    data,
-  };
-}
-
-export function mockValidatorList() {
-  const data = Buffer.alloc(1024);
-  ValidatorListLayout.encode(validatorListMock, data);
-  return <AccountInfo<any>>{
-    executable: true,
-    owner: new PublicKey(0),
-    lamports: 0,
-    data,
-  };
-}
diff --git a/stake-pool/js/tsconfig.json b/stake-pool/js/tsconfig.json
deleted file mode 100644
index 2ae40abe0c8..00000000000
--- a/stake-pool/js/tsconfig.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "esnext",
-    "target": "es2019",
-    "baseUrl": "./src",
-    "outDir": "dist",
-    "declaration": true,
-    "declarationDir": "dist",
-    "emitDeclarationOnly": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitReturns": true,
-    "skipLibCheck": true // needed to avoid re-export errors from borsh
-  },
-  "include": ["src/**/*.ts"]
-}
diff --git a/stake-pool/program/Cargo.toml b/stake-pool/program/Cargo.toml
deleted file mode 100644
index eb6aa4ab148..00000000000
--- a/stake-pool/program/Cargo.toml
+++ /dev/null
@@ -1,49 +0,0 @@
-[package]
-name = "spl-stake-pool"
-version = "1.0.0"
-description = "Solana Program Library Stake Pool"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-arrayref = "0.3.7"
-borsh = "1.5.1"
-bytemuck = "1.16"
-num-derive = "0.4"
-num-traits = "0.2"
-num_enum = "0.7.2"
-serde = "1.0.203"
-serde_derive = "1.0.103"
-solana-program = ">=1.18.11,<=2"
-solana-security-txt = "1.1.1"
-spl-math = { version = "0.2", path = "../../libraries/math", features = [
-  "no-entrypoint",
-] }
-spl-pod = { version = "0.2.2", path = "../../libraries/pod", features = [
-  "borsh",
-] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = [
-  "no-entrypoint",
-] }
-thiserror = "1.0"
-bincode = "1.3.1"
-
-[dev-dependencies]
-assert_matches = "1.5.0"
-proptest = "1.4"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-solana-vote-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
-  "no-entrypoint",
-] }
-test-case = "3.3"
-
-[lib]
-crate-type = ["cdylib", "lib"]
diff --git a/stake-pool/program/Xargo.toml b/stake-pool/program/Xargo.toml
deleted file mode 100644
index 475fb71ed15..00000000000
--- a/stake-pool/program/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
diff --git a/stake-pool/program/program-id.md b/stake-pool/program/program-id.md
deleted file mode 100644
index 7b5157e41d3..00000000000
--- a/stake-pool/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy
diff --git a/stake-pool/program/proptest-regressions/state.txt b/stake-pool/program/proptest-regressions/state.txt
deleted file mode 100644
index 769e8a16890..00000000000
--- a/stake-pool/program/proptest-regressions/state.txt
+++ /dev/null
@@ -1 +0,0 @@
-cc 41ce1c46341336993e5e5d5aa94c30865e63f9e00d31d397aef88ec79fc312ca
diff --git a/stake-pool/program/src/big_vec.rs b/stake-pool/program/src/big_vec.rs
deleted file mode 100644
index 8cf99f8070f..00000000000
--- a/stake-pool/program/src/big_vec.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-//! Big vector type, used with vectors that can't be serde'd
-#![allow(clippy::arithmetic_side_effects)] // checked math involves too many compute units
-
-use {
-    arrayref::array_ref,
-    borsh::BorshDeserialize,
-    bytemuck::Pod,
-    solana_program::{program_error::ProgramError, program_memory::sol_memmove},
-    std::mem,
-};
-
-/// Contains easy to use utilities for a big vector of Borsh-compatible types,
-/// to avoid managing the entire struct on-chain and blow through stack limits.
-pub struct BigVec<'data> {
-    /// Underlying data buffer, pieces of which are serialized
-    pub data: &'data mut [u8],
-}
-
-const VEC_SIZE_BYTES: usize = 4;
-
-impl<'data> BigVec<'data> {
-    /// Get the length of the vector
-    pub fn len(&self) -> u32 {
-        let vec_len = array_ref![self.data, 0, VEC_SIZE_BYTES];
-        u32::from_le_bytes(*vec_len)
-    }
-
-    /// Find out if the vector has no contents (as demanded by clippy)
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Retain all elements that match the provided function, discard all others
-    pub fn retain<T: Pod, F: Fn(&[u8]) -> bool>(
-        &mut self,
-        predicate: F,
-    ) -> Result<(), ProgramError> {
-        let mut vec_len = self.len();
-        let mut removals_found = 0;
-        let mut dst_start_index = 0;
-
-        let data_start_index = VEC_SIZE_BYTES;
-        let data_end_index =
-            data_start_index.saturating_add((vec_len as usize).saturating_mul(mem::size_of::<T>()));
-        for start_index in (data_start_index..data_end_index).step_by(mem::size_of::<T>()) {
-            let end_index = start_index + mem::size_of::<T>();
-            let slice = &self.data[start_index..end_index];
-            if !predicate(slice) {
-                let gap = removals_found * mem::size_of::<T>();
-                if removals_found > 0 {
-                    // In case the compute budget is ever bumped up, allowing us
-                    // to use this safe code instead:
-                    // self.data.copy_within(dst_start_index + gap..start_index, dst_start_index);
-                    unsafe {
-                        sol_memmove(
-                            self.data[dst_start_index..start_index - gap].as_mut_ptr(),
-                            self.data[dst_start_index + gap..start_index].as_mut_ptr(),
-                            start_index - gap - dst_start_index,
-                        );
-                    }
-                }
-                dst_start_index = start_index - gap;
-                removals_found += 1;
-                vec_len -= 1;
-            }
-        }
-
-        // final memmove
-        if removals_found > 0 {
-            let gap = removals_found * mem::size_of::<T>();
-            // In case the compute budget is ever bumped up, allowing us
-            // to use this safe code instead:
-            //    self.data.copy_within(
-            //        dst_start_index + gap..data_end_index,
-            //        dst_start_index,
-            //    );
-            unsafe {
-                sol_memmove(
-                    self.data[dst_start_index..data_end_index - gap].as_mut_ptr(),
-                    self.data[dst_start_index + gap..data_end_index].as_mut_ptr(),
-                    data_end_index - gap - dst_start_index,
-                );
-            }
-        }
-
-        let mut vec_len_ref = &mut self.data[0..VEC_SIZE_BYTES];
-        borsh::to_writer(&mut vec_len_ref, &vec_len)?;
-
-        Ok(())
-    }
-
-    /// Extracts a slice of the data types
-    pub fn deserialize_mut_slice<T: Pod>(
-        &mut self,
-        skip: usize,
-        len: usize,
-    ) -> Result<&mut [T], ProgramError> {
-        let vec_len = self.len();
-        let last_item_index = skip
-            .checked_add(len)
-            .ok_or(ProgramError::AccountDataTooSmall)?;
-        if last_item_index > vec_len as usize {
-            return Err(ProgramError::AccountDataTooSmall);
-        }
-
-        let start_index = VEC_SIZE_BYTES.saturating_add(skip.saturating_mul(mem::size_of::<T>()));
-        let end_index = start_index.saturating_add(len.saturating_mul(mem::size_of::<T>()));
-        bytemuck::try_cast_slice_mut(&mut self.data[start_index..end_index])
-            .map_err(|_| ProgramError::InvalidAccountData)
-    }
-
-    /// Extracts a slice of the data types
-    pub fn deserialize_slice<T: Pod>(&self, skip: usize, len: usize) -> Result<&[T], ProgramError> {
-        let vec_len = self.len();
-        let last_item_index = skip
-            .checked_add(len)
-            .ok_or(ProgramError::AccountDataTooSmall)?;
-        if last_item_index > vec_len as usize {
-            return Err(ProgramError::AccountDataTooSmall);
-        }
-
-        let start_index = VEC_SIZE_BYTES.saturating_add(skip.saturating_mul(mem::size_of::<T>()));
-        let end_index = start_index.saturating_add(len.saturating_mul(mem::size_of::<T>()));
-        bytemuck::try_cast_slice(&self.data[start_index..end_index])
-            .map_err(|_| ProgramError::InvalidAccountData)
-    }
-
-    /// Add new element to the end
-    pub fn push<T: Pod>(&mut self, element: T) -> Result<(), ProgramError> {
-        let mut vec_len_ref = &mut self.data[0..VEC_SIZE_BYTES];
-        let mut vec_len = u32::try_from_slice(vec_len_ref)?;
-
-        let start_index = VEC_SIZE_BYTES + vec_len as usize * mem::size_of::<T>();
-        let end_index = start_index + mem::size_of::<T>();
-
-        vec_len += 1;
-        borsh::to_writer(&mut vec_len_ref, &vec_len)?;
-
-        if self.data.len() < end_index {
-            return Err(ProgramError::AccountDataTooSmall);
-        }
-        let element_ref = bytemuck::try_from_bytes_mut(
-            &mut self.data[start_index..start_index + mem::size_of::<T>()],
-        )
-        .map_err(|_| ProgramError::InvalidAccountData)?;
-        *element_ref = element;
-        Ok(())
-    }
-
-    /// Find matching data in the array
-    pub fn find<T: Pod, F: Fn(&[u8]) -> bool>(&self, predicate: F) -> Option<&T> {
-        let len = self.len() as usize;
-        let mut current = 0;
-        let mut current_index = VEC_SIZE_BYTES;
-        while current != len {
-            let end_index = current_index + mem::size_of::<T>();
-            let current_slice = &self.data[current_index..end_index];
-            if predicate(current_slice) {
-                return Some(bytemuck::from_bytes(current_slice));
-            }
-            current_index = end_index;
-            current += 1;
-        }
-        None
-    }
-
-    /// Find matching data in the array
-    pub fn find_mut<T: Pod, F: Fn(&[u8]) -> bool>(&mut self, predicate: F) -> Option<&mut T> {
-        let len = self.len() as usize;
-        let mut current = 0;
-        let mut current_index = VEC_SIZE_BYTES;
-        while current != len {
-            let end_index = current_index + mem::size_of::<T>();
-            let current_slice = &self.data[current_index..end_index];
-            if predicate(current_slice) {
-                return Some(bytemuck::from_bytes_mut(
-                    &mut self.data[current_index..end_index],
-                ));
-            }
-            current_index = end_index;
-            current += 1;
-        }
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, bytemuck::Zeroable};
-
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone, PartialEq, Pod, Zeroable)]
-    struct TestStruct {
-        value: [u8; 8],
-    }
-
-    impl TestStruct {
-        fn new(value: u8) -> Self {
-            let value = [value, 0, 0, 0, 0, 0, 0, 0];
-            Self { value }
-        }
-    }
-
-    fn from_slice<'data>(data: &'data mut [u8], vec: &[u8]) -> BigVec<'data> {
-        let mut big_vec = BigVec { data };
-        for element in vec {
-            big_vec.push(TestStruct::new(*element)).unwrap();
-        }
-        big_vec
-    }
-
-    fn check_big_vec_eq(big_vec: &BigVec, slice: &[u8]) {
-        assert!(big_vec
-            .deserialize_slice::<TestStruct>(0, big_vec.len() as usize)
-            .unwrap()
-            .iter()
-            .map(|x| &x.value[0])
-            .zip(slice.iter())
-            .all(|(a, b)| a == b));
-    }
-
-    #[test]
-    fn push() {
-        let mut data = [0u8; 4 + 8 * 3];
-        let mut v = BigVec { data: &mut data };
-        v.push(TestStruct::new(1)).unwrap();
-        check_big_vec_eq(&v, &[1]);
-        v.push(TestStruct::new(2)).unwrap();
-        check_big_vec_eq(&v, &[1, 2]);
-        v.push(TestStruct::new(3)).unwrap();
-        check_big_vec_eq(&v, &[1, 2, 3]);
-        assert_eq!(
-            v.push(TestStruct::new(4)).unwrap_err(),
-            ProgramError::AccountDataTooSmall
-        );
-    }
-
-    #[test]
-    fn retain() {
-        fn mod_2_predicate(data: &[u8]) -> bool {
-            u64::try_from_slice(data).unwrap() % 2 == 0
-        }
-
-        let mut data = [0u8; 4 + 8 * 4];
-        let mut v = from_slice(&mut data, &[1, 2, 3, 4]);
-        v.retain::<TestStruct, _>(mod_2_predicate).unwrap();
-        check_big_vec_eq(&v, &[2, 4]);
-    }
-
-    fn find_predicate(a: &[u8], b: u8) -> bool {
-        if a.len() != 8 {
-            false
-        } else {
-            a[0] == b
-        }
-    }
-
-    #[test]
-    fn find() {
-        let mut data = [0u8; 4 + 8 * 4];
-        let v = from_slice(&mut data, &[1, 2, 3, 4]);
-        assert_eq!(
-            v.find::<TestStruct, _>(|x| find_predicate(x, 1)),
-            Some(&TestStruct::new(1))
-        );
-        assert_eq!(
-            v.find::<TestStruct, _>(|x| find_predicate(x, 4)),
-            Some(&TestStruct::new(4))
-        );
-        assert_eq!(v.find::<TestStruct, _>(|x| find_predicate(x, 5)), None);
-    }
-
-    #[test]
-    fn find_mut() {
-        let mut data = [0u8; 4 + 8 * 4];
-        let mut v = from_slice(&mut data, &[1, 2, 3, 4]);
-        let test_struct = v
-            .find_mut::<TestStruct, _>(|x| find_predicate(x, 1))
-            .unwrap();
-        test_struct.value = [0; 8];
-        check_big_vec_eq(&v, &[0, 2, 3, 4]);
-        assert_eq!(v.find_mut::<TestStruct, _>(|x| find_predicate(x, 5)), None);
-    }
-
-    #[test]
-    fn deserialize_mut_slice() {
-        let mut data = [0u8; 4 + 8 * 4];
-        let mut v = from_slice(&mut data, &[1, 2, 3, 4]);
-        let slice = v.deserialize_mut_slice::<TestStruct>(1, 2).unwrap();
-        slice[0].value[0] = 10;
-        slice[1].value[0] = 11;
-        check_big_vec_eq(&v, &[1, 10, 11, 4]);
-        assert_eq!(
-            v.deserialize_mut_slice::<TestStruct>(1, 4).unwrap_err(),
-            ProgramError::AccountDataTooSmall
-        );
-        assert_eq!(
-            v.deserialize_mut_slice::<TestStruct>(4, 1).unwrap_err(),
-            ProgramError::AccountDataTooSmall
-        );
-    }
-}
diff --git a/stake-pool/program/src/entrypoint.rs b/stake-pool/program/src/entrypoint.rs
deleted file mode 100644
index b616b219857..00000000000
--- a/stake-pool/program/src/entrypoint.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Program entrypoint
-
-#![cfg(all(target_os = "solana", not(feature = "no-entrypoint")))]
-
-use {
-    crate::{error::StakePoolError, processor::Processor},
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    solana_security_txt::security_txt,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<StakePoolError>();
-        Err(error)
-    } else {
-        Ok(())
-    }
-}
-
-security_txt! {
-    // Required fields
-    name: "SPL Stake Pool",
-    project_url: "https://spl.solana.com/stake-pool",
-    contacts: "link:https://github.com/solana-labs/solana-program-library/security/advisories/new,mailto:security@solana.com,discord:https://solana.com/discord",
-    policy: "https://github.com/solana-labs/solana-program-library/blob/master/SECURITY.md",
-
-    // Optional Fields
-    preferred_languages: "en",
-    source_code: "https://github.com/solana-labs/solana-program-library/tree/master/stake-pool/program",
-    source_revision: "b7dd8fee93815b486fce98d3d43d1d0934980226",
-    source_release: "stake-pool-v1.0.0",
-    auditors: "https://github.com/solana-labs/security-audits#stake-pool"
-}
diff --git a/stake-pool/program/src/error.rs b/stake-pool/program/src/error.rs
deleted file mode 100644
index 74a7885fe6b..00000000000
--- a/stake-pool/program/src/error.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-//! Error types
-
-use {
-    num_derive::FromPrimitive,
-    solana_program::{decode_error::DecodeError, program_error::ProgramError},
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the StakePool program.
-#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
-pub enum StakePoolError {
-    // 0.
-    /// The account cannot be initialized because it is already being used.
-    #[error("AlreadyInUse")]
-    AlreadyInUse,
-    /// The program address provided doesn't match the value generated by the
-    /// program.
-    #[error("InvalidProgramAddress")]
-    InvalidProgramAddress,
-    /// The stake pool state is invalid.
-    #[error("InvalidState")]
-    InvalidState,
-    /// The calculation failed.
-    #[error("CalculationFailure")]
-    CalculationFailure,
-    /// Stake pool fee > 1.
-    #[error("FeeTooHigh")]
-    FeeTooHigh,
-
-    // 5.
-    /// Token account is associated with the wrong mint.
-    #[error("WrongAccountMint")]
-    WrongAccountMint,
-    /// Wrong pool manager account.
-    #[error("WrongManager")]
-    WrongManager,
-    /// Required signature is missing.
-    #[error("SignatureMissing")]
-    SignatureMissing,
-    /// Invalid validator stake list account.
-    #[error("InvalidValidatorStakeList")]
-    InvalidValidatorStakeList,
-    /// Invalid manager fee account.
-    #[error("InvalidFeeAccount")]
-    InvalidFeeAccount,
-
-    // 10.
-    /// Specified pool mint account is wrong.
-    #[error("WrongPoolMint")]
-    WrongPoolMint,
-    /// Stake account is not in the state expected by the program.
-    #[error("WrongStakeStake")]
-    WrongStakeStake,
-    /// User stake is not active
-    #[error("UserStakeNotActive")]
-    UserStakeNotActive,
-    /// Stake account voting for this validator already exists in the pool.
-    #[error("ValidatorAlreadyAdded")]
-    ValidatorAlreadyAdded,
-    /// Stake account for this validator not found in the pool.
-    #[error("ValidatorNotFound")]
-    ValidatorNotFound,
-
-    // 15.
-    /// Stake account address not properly derived from the validator address.
-    #[error("InvalidStakeAccountAddress")]
-    InvalidStakeAccountAddress,
-    /// Identify validator stake accounts with old balances and update them.
-    #[error("StakeListOutOfDate")]
-    StakeListOutOfDate,
-    /// First update old validator stake account balances and then pool stake
-    /// balance.
-    #[error("StakeListAndPoolOutOfDate")]
-    StakeListAndPoolOutOfDate,
-    /// Validator stake account is not found in the list storage.
-    #[error("UnknownValidatorStakeAccount")]
-    UnknownValidatorStakeAccount,
-    /// Wrong minting authority set for mint pool account
-    #[error("WrongMintingAuthority")]
-    WrongMintingAuthority,
-
-    // 20.
-    /// The size of the given validator stake list does match the expected
-    /// amount
-    #[error("UnexpectedValidatorListAccountSize")]
-    UnexpectedValidatorListAccountSize,
-    /// Wrong pool staker account.
-    #[error("WrongStaker")]
-    WrongStaker,
-    /// Pool token supply is not zero on initialization
-    #[error("NonZeroPoolTokenSupply")]
-    NonZeroPoolTokenSupply,
-    /// The lamports in the validator stake account is not equal to the minimum
-    #[error("StakeLamportsNotEqualToMinimum")]
-    StakeLamportsNotEqualToMinimum,
-    /// The provided deposit stake account is not delegated to the preferred
-    /// deposit vote account
-    #[error("IncorrectDepositVoteAddress")]
-    IncorrectDepositVoteAddress,
-
-    // 25.
-    /// The provided withdraw stake account is not the preferred deposit vote
-    /// account
-    #[error("IncorrectWithdrawVoteAddress")]
-    IncorrectWithdrawVoteAddress,
-    /// The mint has an invalid freeze authority
-    #[error("InvalidMintFreezeAuthority")]
-    InvalidMintFreezeAuthority,
-    /// Proposed fee increase exceeds stipulated ratio
-    #[error("FeeIncreaseTooHigh")]
-    FeeIncreaseTooHigh,
-    /// Not enough pool tokens provided to withdraw stake with one lamport
-    #[error("WithdrawalTooSmall")]
-    WithdrawalTooSmall,
-    /// Not enough lamports provided for deposit to result in one pool token
-    #[error("DepositTooSmall")]
-    DepositTooSmall,
-
-    // 30.
-    /// Provided stake deposit authority does not match the program's
-    #[error("InvalidStakeDepositAuthority")]
-    InvalidStakeDepositAuthority,
-    /// Provided sol deposit authority does not match the program's
-    #[error("InvalidSolDepositAuthority")]
-    InvalidSolDepositAuthority,
-    /// Provided preferred validator is invalid
-    #[error("InvalidPreferredValidator")]
-    InvalidPreferredValidator,
-    /// Provided validator stake account already has a transient stake account
-    /// in use
-    #[error("TransientAccountInUse")]
-    TransientAccountInUse,
-    /// Provided sol withdraw authority does not match the program's
-    #[error("InvalidSolWithdrawAuthority")]
-    InvalidSolWithdrawAuthority,
-
-    // 35.
-    /// Too much SOL withdrawn from the stake pool's reserve account
-    #[error("SolWithdrawalTooLarge")]
-    SolWithdrawalTooLarge,
-    /// Provided metadata account does not match metadata account derived for
-    /// pool mint
-    #[error("InvalidMetadataAccount")]
-    InvalidMetadataAccount,
-    /// The mint has an unsupported extension
-    #[error("UnsupportedMintExtension")]
-    UnsupportedMintExtension,
-    /// The fee account has an unsupported extension
-    #[error("UnsupportedFeeAccountExtension")]
-    UnsupportedFeeAccountExtension,
-    /// Instruction exceeds desired slippage limit
-    #[error("Instruction exceeds desired slippage limit")]
-    ExceededSlippage,
-
-    // 40.
-    /// Provided mint does not have 9 decimals to match SOL
-    #[error("IncorrectMintDecimals")]
-    IncorrectMintDecimals,
-    /// Pool reserve does not have enough lamports to fund rent-exempt reserve
-    /// in split destination. Deposit more SOL in reserve, or pre-fund split
-    /// destination with the rent-exempt reserve for a stake account.
-    #[error("ReserveDepleted")]
-    ReserveDepleted,
-    /// Missing required sysvar account
-    #[error("Missing required sysvar account")]
-    MissingRequiredSysvar,
-}
-impl From<StakePoolError> for ProgramError {
-    fn from(e: StakePoolError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for StakePoolError {
-    fn type_of() -> &'static str {
-        "Stake Pool Error"
-    }
-}
diff --git a/stake-pool/program/src/inline_mpl_token_metadata.rs b/stake-pool/program/src/inline_mpl_token_metadata.rs
deleted file mode 100644
index a5d0836b3dd..00000000000
--- a/stake-pool/program/src/inline_mpl_token_metadata.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-//! Inlined MPL metadata types to avoid a direct dependency on
-//! `mpl-token-metadata' NOTE: this file is sym-linked in `spl-single-pool`, so
-//! be careful with changes!
-
-solana_program::declare_id!("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-
-pub(crate) mod instruction {
-    use {
-        super::state::DataV2,
-        borsh::{BorshDeserialize, BorshSerialize},
-        solana_program::{
-            instruction::{AccountMeta, Instruction},
-            pubkey::Pubkey,
-        },
-    };
-
-    #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
-    struct CreateMetadataAccountArgsV3 {
-        /// Note that unique metadatas are disabled for now.
-        pub data: DataV2,
-        /// Whether you want your metadata to be updateable in the future.
-        pub is_mutable: bool,
-        /// UNUSED If this is a collection parent NFT.
-        pub collection_details: Option<u8>,
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn create_metadata_accounts_v3(
-        program_id: Pubkey,
-        metadata_account: Pubkey,
-        mint: Pubkey,
-        mint_authority: Pubkey,
-        payer: Pubkey,
-        update_authority: Pubkey,
-        name: String,
-        symbol: String,
-        uri: String,
-    ) -> Instruction {
-        let mut data = vec![33]; // CreateMetadataAccountV3
-        data.append(
-            &mut borsh::to_vec(&CreateMetadataAccountArgsV3 {
-                data: DataV2 {
-                    name,
-                    symbol,
-                    uri,
-                    seller_fee_basis_points: 0,
-                    creators: None,
-                    collection: None,
-                    uses: None,
-                },
-                is_mutable: true,
-                collection_details: None,
-            })
-            .unwrap(),
-        );
-        Instruction {
-            program_id,
-            accounts: vec![
-                AccountMeta::new(metadata_account, false),
-                AccountMeta::new_readonly(mint, false),
-                AccountMeta::new_readonly(mint_authority, true),
-                AccountMeta::new(payer, true),
-                AccountMeta::new_readonly(update_authority, true),
-                AccountMeta::new_readonly(solana_program::system_program::ID, false),
-            ],
-            data,
-        }
-    }
-
-    #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
-    struct UpdateMetadataAccountArgsV2 {
-        pub data: Option<DataV2>,
-        pub update_authority: Option<Pubkey>,
-        pub primary_sale_happened: Option<bool>,
-        pub is_mutable: Option<bool>,
-    }
-    pub(crate) fn update_metadata_accounts_v2(
-        program_id: Pubkey,
-        metadata_account: Pubkey,
-        update_authority: Pubkey,
-        new_update_authority: Option<Pubkey>,
-        metadata: Option<DataV2>,
-        primary_sale_happened: Option<bool>,
-        is_mutable: Option<bool>,
-    ) -> Instruction {
-        let mut data = vec![15]; // UpdateMetadataAccountV2
-        data.append(
-            &mut borsh::to_vec(&UpdateMetadataAccountArgsV2 {
-                data: metadata,
-                update_authority: new_update_authority,
-                primary_sale_happened,
-                is_mutable,
-            })
-            .unwrap(),
-        );
-        Instruction {
-            program_id,
-            accounts: vec![
-                AccountMeta::new(metadata_account, false),
-                AccountMeta::new_readonly(update_authority, true),
-            ],
-            data,
-        }
-    }
-}
-
-/// PDA creation helpers
-pub mod pda {
-    use {super::ID, solana_program::pubkey::Pubkey};
-    const PREFIX: &str = "metadata";
-    /// Helper to find a metadata account address
-    pub fn find_metadata_account(mint: &Pubkey) -> (Pubkey, u8) {
-        Pubkey::find_program_address(&[PREFIX.as_bytes(), ID.as_ref(), mint.as_ref()], &ID)
-    }
-}
-
-pub(crate) mod state {
-    use borsh::{BorshDeserialize, BorshSerialize};
-    #[repr(C)]
-    #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
-    pub(crate) struct DataV2 {
-        /// The name of the asset
-        pub name: String,
-        /// The symbol for the asset
-        pub symbol: String,
-        /// URI pointing to JSON representing the asset
-        pub uri: String,
-        /// Royalty basis points that goes to creators in secondary sales
-        /// (0-10000)
-        pub seller_fee_basis_points: u16,
-        /// UNUSED Array of creators, optional
-        pub creators: Option<u8>,
-        /// UNUSED Collection
-        pub collection: Option<u8>,
-        /// UNUSED Uses
-        pub uses: Option<u8>,
-    }
-}
diff --git a/stake-pool/program/src/instruction.rs b/stake-pool/program/src/instruction.rs
deleted file mode 100644
index 313afd93015..00000000000
--- a/stake-pool/program/src/instruction.rs
+++ /dev/null
@@ -1,2573 +0,0 @@
-//! Instruction types
-
-#![allow(clippy::too_many_arguments)]
-
-use {
-    crate::{
-        find_deposit_authority_program_address, find_ephemeral_stake_program_address,
-        find_stake_program_address, find_transient_stake_program_address,
-        find_withdraw_authority_program_address,
-        inline_mpl_token_metadata::{self, pda::find_metadata_account},
-        state::{Fee, FeeType, StakePool, ValidatorList, ValidatorStakeInfo},
-        MAX_VALIDATORS_TO_UPDATE,
-    },
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        stake,
-        stake_history::Epoch,
-        system_program, sysvar,
-    },
-    std::num::NonZeroU32,
-};
-
-/// Defines which validator vote account is set during the
-/// `SetPreferredValidator` instruction
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
-pub enum PreferredValidatorType {
-    /// Set preferred validator for deposits
-    Deposit,
-    /// Set preferred validator for withdraws
-    Withdraw,
-}
-
-/// Defines which authority to update in the `SetFundingAuthority`
-/// instruction
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
-pub enum FundingType {
-    /// Sets the stake deposit authority
-    StakeDeposit,
-    /// Sets the SOL deposit authority
-    SolDeposit,
-    /// Sets the SOL withdraw authority
-    SolWithdraw,
-}
-
-/// Instructions supported by the StakePool program.
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub enum StakePoolInstruction {
-    ///   Initializes a new StakePool.
-    ///
-    ///   0. `[w]` New StakePool to create.
-    ///   1. `[s]` Manager
-    ///   2. `[]` Staker
-    ///   3. `[]` Stake pool withdraw authority
-    ///   4. `[w]` Uninitialized validator stake list storage account
-    ///   5. `[]` Reserve stake account must be initialized, have zero balance,
-    ///      and staker / withdrawer authority set to pool withdraw authority.
-    ///   6. `[]` Pool token mint. Must have zero supply, owned by withdraw
-    ///      authority.
-    ///   7. `[]` Pool account to deposit the generated fee for manager.
-    ///   8. `[]` Token program id
-    ///   9. `[]` (Optional) Deposit authority that must sign all deposits.
-    ///      Defaults to the program address generated using
-    ///      `find_deposit_authority_program_address`, making deposits
-    ///      permissionless.
-    Initialize {
-        /// Fee assessed as percentage of perceived rewards
-        fee: Fee,
-        /// Fee charged per withdrawal as percentage of withdrawal
-        withdrawal_fee: Fee,
-        /// Fee charged per deposit as percentage of deposit
-        deposit_fee: Fee,
-        /// Percentage [0-100] of deposit_fee that goes to referrer
-        referral_fee: u8,
-        /// Maximum expected number of validators
-        max_validators: u32,
-    },
-
-    ///   (Staker only) Adds stake account delegated to validator to the pool's
-    ///   list of managed validators.
-    ///
-    ///   The stake account will have the rent-exempt amount plus
-    ///   `max(
-    ///     crate::MINIMUM_ACTIVE_STAKE,
-    ///     solana_program::stake::tools::get_minimum_delegation()
-    ///   )`.
-    ///   It is funded from the stake pool reserve.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[s]` Staker
-    ///   2. `[w]` Reserve stake account
-    ///   3. `[]` Stake pool withdraw authority
-    ///   4. `[w]` Validator stake list storage account
-    ///   5. `[w]` Stake account to add to the pool
-    ///   6. `[]` Validator this stake account will be delegated to
-    ///   7. `[]` Rent sysvar
-    ///   8. `[]` Clock sysvar
-    ///   9. '[]' Stake history sysvar
-    ///  10. '[]' Stake config sysvar
-    ///  11. `[]` System program
-    ///  12. `[]` Stake program
-    ///
-    ///  userdata: optional non-zero u32 seed used for generating the validator
-    ///  stake address
-    AddValidatorToPool(u32),
-
-    ///   (Staker only) Removes validator from the pool, deactivating its stake
-    ///
-    ///   Only succeeds if the validator stake account has the minimum of
-    ///   `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.   plus the
-    /// rent-exempt amount.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[s]` Staker
-    ///   2. `[]` Stake pool withdraw authority
-    ///   3. `[w]` Validator stake list storage account
-    ///   4. `[w]` Stake account to remove from the pool
-    ///   5. `[w]` Transient stake account, to deactivate if necessary
-    ///   6. `[]` Sysvar clock
-    ///   7. `[]` Stake program id,
-    RemoveValidatorFromPool,
-
-    /// NOTE: This instruction has been deprecated since version 0.7.0. Please
-    /// use `DecreaseValidatorStakeWithReserve` instead.
-    ///
-    /// (Staker only) Decrease active stake on a validator, eventually moving it
-    /// to the reserve
-    ///
-    /// Internally, this instruction splits a validator stake account into its
-    /// corresponding transient stake account and deactivates it.
-    ///
-    /// In order to rebalance the pool without taking custody, the staker needs
-    /// a way of reducing the stake on a stake account. This instruction splits
-    /// some amount of stake, up to the total activated stake, from the
-    /// canonical validator stake account, into its "transient" stake
-    /// account.
-    ///
-    /// The instruction only succeeds if the transient stake account does not
-    /// exist. The amount of lamports to move must be at least rent-exemption
-    /// plus `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Canonical stake account to split from
-    ///  5. `[w]` Transient stake account to receive split
-    ///  6. `[]` Clock sysvar
-    ///  7. `[]` Rent sysvar
-    ///  8. `[]` System program
-    ///  9. `[]` Stake program
-    DecreaseValidatorStake {
-        /// amount of lamports to split into the transient stake account
-        lamports: u64,
-        /// seed used to create transient stake account
-        transient_stake_seed: u64,
-    },
-
-    /// (Staker only) Increase stake on a validator from the reserve account
-    ///
-    /// Internally, this instruction splits reserve stake into a transient stake
-    /// account and delegate to the appropriate validator.
-    /// `UpdateValidatorListBalance` will do the work of merging once it's
-    /// ready.
-    ///
-    /// This instruction only succeeds if the transient stake account does not
-    /// exist. The minimum amount to move is rent-exemption plus
-    /// `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Stake pool reserve stake
-    ///  5. `[w]` Transient stake account
-    ///  6. `[]` Validator stake account
-    ///  7. `[]` Validator vote account to delegate to
-    ///  8. '[]' Clock sysvar
-    ///  9. '[]' Rent sysvar
-    /// 10. `[]` Stake History sysvar
-    /// 11. `[]` Stake Config sysvar
-    /// 12. `[]` System program
-    /// 13. `[]` Stake program
-    ///  userdata: amount of lamports to increase on the given validator.
-    ///  The actual amount split into the transient stake account is:
-    ///  `lamports + stake_rent_exemption`
-    ///  The rent-exemption of the stake account is withdrawn back to the
-    /// reserve  after it is merged.
-    IncreaseValidatorStake {
-        /// amount of lamports to increase on the given validator
-        lamports: u64,
-        /// seed used to create transient stake account
-        transient_stake_seed: u64,
-    },
-
-    /// (Staker only) Set the preferred deposit or withdraw stake account for
-    /// the stake pool
-    ///
-    /// In order to avoid users abusing the stake pool as a free conversion
-    /// between SOL staked on different validators, the staker can force all
-    /// deposits and/or withdraws to go to one chosen account, or unset that
-    /// account.
-    ///
-    /// 0. `[w]` Stake pool
-    /// 1. `[s]` Stake pool staker
-    /// 2. `[]` Validator list
-    ///
-    /// Fails if the validator is not part of the stake pool.
-    SetPreferredValidator {
-        /// Affected operation (deposit or withdraw)
-        validator_type: PreferredValidatorType,
-        /// Validator vote account that deposits or withdraws must go through,
-        /// unset with None
-        validator_vote_address: Option<Pubkey>,
-    },
-
-    ///  Updates balances of validator and transient stake accounts in the pool
-    ///
-    ///  While going through the pairs of validator and transient stake
-    ///  accounts, if the transient stake is inactive, it is merged into the
-    ///  reserve stake account. If the transient stake is active and has
-    ///  matching credits observed, it is merged into the canonical
-    ///  validator stake account. In all other states, nothing is done, and
-    ///  the balance is simply added to the canonical stake account balance.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[]` Stake pool withdraw authority
-    ///  2. `[w]` Validator stake list storage account
-    ///  3. `[w]` Reserve stake account
-    ///  4. `[]` Sysvar clock
-    ///  5. `[]` Sysvar stake history
-    ///  6. `[]` Stake program
-    ///  7. ..7+2N ` [] N pairs of validator and transient stake accounts
-    UpdateValidatorListBalance {
-        /// Index to start updating on the validator list
-        start_index: u32,
-        /// If true, don't try merging transient stake accounts into the reserve
-        /// or validator stake account.  Useful for testing or if a
-        /// particular stake account is in a bad state, but we still
-        /// want to update
-        no_merge: bool,
-    },
-
-    ///   Updates total pool balance based on balances in the reserve and
-    ///   validator list
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[]` Stake pool withdraw authority
-    ///   2. `[w]` Validator stake list storage account
-    ///   3. `[]` Reserve stake account
-    ///   4. `[w]` Account to receive pool fee tokens
-    ///   5. `[w]` Pool mint account
-    ///   6. `[]` Pool token program
-    UpdateStakePoolBalance,
-
-    ///   Cleans up validator stake account entries marked as `ReadyForRemoval`
-    ///
-    ///   0. `[]` Stake pool
-    ///   1. `[w]` Validator stake list storage account
-    CleanupRemovedValidatorEntries,
-
-    ///   Deposit some stake into the pool. The output is a "pool" token
-    ///   representing ownership into the pool. Inputs are converted to the
-    ///   current ratio.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[w]` Validator stake list storage account
-    ///   2. `[s]/[]` Stake pool deposit authority
-    ///   3. `[]` Stake pool withdraw authority
-    ///   4. `[w]` Stake account to join the pool (withdraw authority for the
-    ///      stake account should be first set to the stake pool deposit
-    ///      authority)
-    ///   5. `[w]` Validator stake account for the stake account to be merged
-    ///      with
-    ///   6. `[w]` Reserve stake account, to withdraw rent exempt reserve
-    ///   7. `[w]` User account to receive pool tokens
-    ///   8. `[w]` Account to receive pool fee tokens
-    ///   9. `[w]` Account to receive a portion of pool fee tokens as referral
-    ///      fees
-    ///   10. `[w]` Pool token mint account
-    ///   11. '[]' Sysvar clock account
-    ///   12. '[]' Sysvar stake history account
-    ///   13. `[]` Pool token program id,
-    ///   14. `[]` Stake program id,
-    DepositStake,
-
-    ///   Withdraw the token from the pool at the current ratio.
-    ///
-    ///   Succeeds if the stake account has enough SOL to cover the desired
-    ///   amount of pool tokens, and if the withdrawal keeps the total
-    ///   staked amount above the minimum of rent-exempt amount + `max(
-    ///     crate::MINIMUM_ACTIVE_STAKE,
-    ///     solana_program::stake::tools::get_minimum_delegation()
-    ///   )`.
-    ///
-    ///   When allowing withdrawals, the order of priority goes:
-    ///
-    ///   * preferred withdraw validator stake account (if set)
-    ///   * validator stake accounts
-    ///   * transient stake accounts
-    ///   * reserve stake account OR totally remove validator stake accounts
-    ///
-    ///   A user can freely withdraw from a validator stake account, and if they
-    ///   are all at the minimum, then they can withdraw from transient stake
-    ///   accounts, and if they are all at minimum, then they can withdraw from
-    ///   the reserve or remove any validator from the pool.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[w]` Validator stake list storage account
-    ///   2. `[]` Stake pool withdraw authority
-    ///   3. `[w]` Validator or reserve stake account to split
-    ///   4. `[w]` Unitialized stake account to receive withdrawal
-    ///   5. `[]` User account to set as a new withdraw authority
-    ///   6. `[s]` User transfer authority, for pool token account
-    ///   7. `[w]` User account with pool tokens to burn from
-    ///   8. `[w]` Account to receive pool fee tokens
-    ///   9. `[w]` Pool token mint account
-    ///  10. `[]` Sysvar clock account (required)
-    ///  11. `[]` Pool token program id
-    ///  12. `[]` Stake program id,
-    ///  userdata: amount of pool tokens to withdraw
-    WithdrawStake(u64),
-
-    ///  (Manager only) Update manager
-    ///
-    ///  0. `[w]` StakePool
-    ///  1. `[s]` Manager
-    ///  2. `[s]` New manager
-    ///  3. `[]` New manager fee account
-    SetManager,
-
-    ///  (Manager only) Update fee
-    ///
-    ///  0. `[w]` StakePool
-    ///  1. `[s]` Manager
-    SetFee {
-        /// Type of fee to update and value to update it to
-        fee: FeeType,
-    },
-
-    ///  (Manager or staker only) Update staker
-    ///
-    ///  0. `[w]` StakePool
-    ///  1. `[s]` Manager or current staker
-    ///  2. '[]` New staker pubkey
-    SetStaker,
-
-    ///   Deposit SOL directly into the pool's reserve account. The output is a
-    ///   "pool" token representing ownership into the pool. Inputs are
-    ///   converted to the current ratio.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[]` Stake pool withdraw authority
-    ///   2. `[w]` Reserve stake account, to deposit SOL
-    ///   3. `[s]` Account providing the lamports to be deposited into the pool
-    ///   4. `[w]` User account to receive pool tokens
-    ///   5. `[w]` Account to receive fee tokens
-    ///   6. `[w]` Account to receive a portion of fee as referral fees
-    ///   7. `[w]` Pool token mint account
-    ///   8. `[]` System program account
-    ///   9. `[]` Token program id
-    ///  10. `[s]` (Optional) Stake pool sol deposit authority.
-    DepositSol(u64),
-
-    ///  (Manager only) Update SOL deposit, stake deposit, or SOL withdrawal
-    /// authority.
-    ///
-    ///  0. `[w]` StakePool
-    ///  1. `[s]` Manager
-    ///  2. '[]` New authority pubkey or none
-    SetFundingAuthority(FundingType),
-
-    ///   Withdraw SOL directly from the pool's reserve account. Fails if the
-    ///   reserve does not have enough SOL.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[]` Stake pool withdraw authority
-    ///   2. `[s]` User transfer authority, for pool token account
-    ///   3. `[w]` User account to burn pool tokens
-    ///   4. `[w]` Reserve stake account, to withdraw SOL
-    ///   5. `[w]` Account receiving the lamports from the reserve, must be a
-    ///      system account
-    ///   6. `[w]` Account to receive pool fee tokens
-    ///   7. `[w]` Pool token mint account
-    ///   8. '[]' Clock sysvar
-    ///   9. '[]' Stake history sysvar
-    ///  10. `[]` Stake program account
-    ///  11. `[]` Token program id
-    ///  12. `[s]` (Optional) Stake pool sol withdraw authority
-    WithdrawSol(u64),
-
-    /// Create token metadata for the stake-pool token in the
-    /// metaplex-token program
-    /// 0. `[]` Stake pool
-    /// 1. `[s]` Manager
-    /// 2. `[]` Stake pool withdraw authority
-    /// 3. `[]` Pool token mint account
-    /// 4. `[s, w]` Payer for creation of token metadata account
-    /// 5. `[w]` Token metadata account
-    /// 6. `[]` Metadata program id
-    /// 7. `[]` System program id
-    CreateTokenMetadata {
-        /// Token name
-        name: String,
-        /// Token symbol e.g. stkSOL
-        symbol: String,
-        /// URI of the uploaded metadata of the spl-token
-        uri: String,
-    },
-    /// Update token metadata for the stake-pool token in the
-    /// metaplex-token program
-    ///
-    /// 0. `[]` Stake pool
-    /// 1. `[s]` Manager
-    /// 2. `[]` Stake pool withdraw authority
-    /// 3. `[w]` Token metadata account
-    /// 4. `[]` Metadata program id
-    UpdateTokenMetadata {
-        /// Token name
-        name: String,
-        /// Token symbol e.g. stkSOL
-        symbol: String,
-        /// URI of the uploaded metadata of the spl-token
-        uri: String,
-    },
-
-    /// (Staker only) Increase stake on a validator again in an epoch.
-    ///
-    /// Works regardless if the transient stake account exists.
-    ///
-    /// Internally, this instruction splits reserve stake into an ephemeral
-    /// stake account, activates it, then merges or splits it into the
-    /// transient stake account delegated to the appropriate validator.
-    /// `UpdateValidatorListBalance` will do the work of merging once it's
-    /// ready.
-    ///
-    /// The minimum amount to move is rent-exemption plus
-    /// `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Stake pool reserve stake
-    ///  5. `[w]` Uninitialized ephemeral stake account to receive stake
-    ///  6. `[w]` Transient stake account
-    ///  7. `[]` Validator stake account
-    ///  8. `[]` Validator vote account to delegate to
-    ///  9. '[]' Clock sysvar
-    /// 10. `[]` Stake History sysvar
-    /// 11. `[]` Stake Config sysvar
-    /// 12. `[]` System program
-    /// 13. `[]` Stake program
-    ///  userdata: amount of lamports to increase on the given validator.
-    ///  The actual amount split into the transient stake account is:
-    ///  `lamports + stake_rent_exemption`
-    ///  The rent-exemption of the stake account is withdrawn back to the
-    /// reserve  after it is merged.
-    IncreaseAdditionalValidatorStake {
-        /// amount of lamports to increase on the given validator
-        lamports: u64,
-        /// seed used to create transient stake account
-        transient_stake_seed: u64,
-        /// seed used to create ephemeral account.
-        ephemeral_stake_seed: u64,
-    },
-
-    /// (Staker only) Decrease active stake again from a validator, eventually
-    /// moving it to the reserve
-    ///
-    /// Works regardless if the transient stake account already exists.
-    ///
-    /// Internally, this instruction:
-    ///  * withdraws rent-exempt reserve lamports from the reserve into the
-    ///    ephemeral stake
-    ///  * splits a validator stake account into an ephemeral stake account
-    ///  * deactivates the ephemeral account
-    ///  * merges or splits the ephemeral account into the transient stake
-    ///    account delegated to the appropriate validator
-    ///
-    ///  The amount of lamports to move must be at least
-    /// `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Reserve stake account, to fund rent exempt reserve
-    ///  5. `[w]` Canonical stake account to split from
-    ///  6. `[w]` Uninitialized ephemeral stake account to receive stake
-    ///  7. `[w]` Transient stake account
-    ///  8. `[]` Clock sysvar
-    ///  9. '[]' Stake history sysvar
-    /// 10. `[]` System program
-    /// 11. `[]` Stake program
-    DecreaseAdditionalValidatorStake {
-        /// amount of lamports to split into the transient stake account
-        lamports: u64,
-        /// seed used to create transient stake account
-        transient_stake_seed: u64,
-        /// seed used to create ephemeral account.
-        ephemeral_stake_seed: u64,
-    },
-
-    /// (Staker only) Decrease active stake on a validator, eventually moving it
-    /// to the reserve
-    ///
-    /// Internally, this instruction:
-    /// * withdraws enough lamports to make the transient account rent-exempt
-    /// * splits from a validator stake account into a transient stake account
-    /// * deactivates the transient stake account
-    ///
-    /// In order to rebalance the pool without taking custody, the staker needs
-    /// a way of reducing the stake on a stake account. This instruction splits
-    /// some amount of stake, up to the total activated stake, from the
-    /// canonical validator stake account, into its "transient" stake
-    /// account.
-    ///
-    /// The instruction only succeeds if the transient stake account does not
-    /// exist. The amount of lamports to move must be at least rent-exemption
-    /// plus `max(crate::MINIMUM_ACTIVE_STAKE,
-    /// solana_program::stake::tools::get_minimum_delegation())`.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Reserve stake account, to fund rent exempt reserve
-    ///  5. `[w]` Canonical stake account to split from
-    ///  6. `[w]` Transient stake account to receive split
-    ///  7. `[]` Clock sysvar
-    ///  8. '[]' Stake history sysvar
-    ///  9. `[]` System program
-    /// 10. `[]` Stake program
-    DecreaseValidatorStakeWithReserve {
-        /// amount of lamports to split into the transient stake account
-        lamports: u64,
-        /// seed used to create transient stake account
-        transient_stake_seed: u64,
-    },
-
-    /// (Staker only) Redelegate active stake on a validator, eventually moving
-    /// it to another
-    ///
-    /// Internally, this instruction splits a validator stake account into its
-    /// corresponding transient stake account, redelegates it to an ephemeral
-    /// stake account, then merges that stake into the destination transient
-    /// stake account.
-    ///
-    /// In order to rebalance the pool without taking custody, the staker needs
-    /// a way of reducing the stake on a stake account. This instruction splits
-    /// some amount of stake, up to the total activated stake, from the
-    /// canonical validator stake account, into its "transient" stake
-    /// account.
-    ///
-    /// The instruction only succeeds if the source transient stake account and
-    /// ephemeral stake account do not exist.
-    ///
-    /// The amount of lamports to move must be at least rent-exemption plus the
-    /// minimum delegation amount. Rent-exemption plus minimum delegation
-    /// is required for the destination ephemeral stake account.
-    ///
-    /// The rent-exemption for the source transient account comes from the stake
-    /// pool reserve, if needed.
-    ///
-    /// The amount that arrives at the destination validator in the end is
-    /// `redelegate_lamports - rent_exemption` if the destination transient
-    /// account does *not* exist, and `redelegate_lamports` if the destination
-    /// transient account already exists. The `rent_exemption` is not activated
-    /// when creating the destination transient stake account, but if it already
-    /// exists, then the full amount is delegated.
-    ///
-    ///  0. `[]` Stake pool
-    ///  1. `[s]` Stake pool staker
-    ///  2. `[]` Stake pool withdraw authority
-    ///  3. `[w]` Validator list
-    ///  4. `[w]` Reserve stake account, to withdraw rent exempt reserve
-    ///  5. `[w]` Source canonical stake account to split from
-    ///  6. `[w]` Source transient stake account to receive split and be
-    ///     redelegated
-    ///  7. `[w]` Uninitialized ephemeral stake account to receive redelegation
-    ///  8. `[w]` Destination transient stake account to receive ephemeral stake
-    ///     by merge
-    ///  9. `[]` Destination stake account to receive transient stake after
-    ///     activation
-    /// 10. `[]` Destination validator vote account
-    /// 11. `[]` Clock sysvar
-    /// 12. `[]` Stake History sysvar
-    /// 13. `[]` Stake Config sysvar
-    /// 14. `[]` System program
-    /// 15. `[]` Stake program
-    Redelegate {
-        /// Amount of lamports to redelegate
-        #[allow(dead_code)] // but it's not
-        lamports: u64,
-        /// Seed used to create source transient stake account
-        #[allow(dead_code)] // but it's not
-        source_transient_stake_seed: u64,
-        /// Seed used to create destination ephemeral account.
-        #[allow(dead_code)] // but it's not
-        ephemeral_stake_seed: u64,
-        /// Seed used to create destination transient stake account. If there is
-        /// already transient stake, this must match the current seed, otherwise
-        /// it can be anything
-        #[allow(dead_code)] // but it's not
-        destination_transient_stake_seed: u64,
-    },
-
-    ///   Deposit some stake into the pool, with a specified slippage
-    ///   constraint. The output is a "pool" token representing ownership
-    ///   into the pool. Inputs are converted at the current ratio.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[w]` Validator stake list storage account
-    ///   2. `[s]/[]` Stake pool deposit authority
-    ///   3. `[]` Stake pool withdraw authority
-    ///   4. `[w]` Stake account to join the pool (withdraw authority for the
-    ///      stake account should be first set to the stake pool deposit
-    ///      authority)
-    ///   5. `[w]` Validator stake account for the stake account to be merged
-    ///      with
-    ///   6. `[w]` Reserve stake account, to withdraw rent exempt reserve
-    ///   7. `[w]` User account to receive pool tokens
-    ///   8. `[w]` Account to receive pool fee tokens
-    ///   9. `[w]` Account to receive a portion of pool fee tokens as referral
-    ///      fees
-    ///   10. `[w]` Pool token mint account
-    ///   11. '[]' Sysvar clock account
-    ///   12. '[]' Sysvar stake history account
-    ///   13. `[]` Pool token program id,
-    ///   14. `[]` Stake program id,
-    DepositStakeWithSlippage {
-        /// Minimum amount of pool tokens that must be received
-        minimum_pool_tokens_out: u64,
-    },
-
-    ///   Withdraw the token from the pool at the current ratio, specifying a
-    ///   minimum expected output lamport amount.
-    ///
-    ///   Succeeds if the stake account has enough SOL to cover the desired
-    ///   amount of pool tokens, and if the withdrawal keeps the total
-    ///   staked amount above the minimum of rent-exempt amount + `max(
-    ///     crate::MINIMUM_ACTIVE_STAKE,
-    ///     solana_program::stake::tools::get_minimum_delegation()
-    ///   )`.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[w]` Validator stake list storage account
-    ///   2. `[]` Stake pool withdraw authority
-    ///   3. `[w]` Validator or reserve stake account to split
-    ///   4. `[w]` Unitialized stake account to receive withdrawal
-    ///   5. `[]` User account to set as a new withdraw authority
-    ///   6. `[s]` User transfer authority, for pool token account
-    ///   7. `[w]` User account with pool tokens to burn from
-    ///   8. `[w]` Account to receive pool fee tokens
-    ///   9. `[w]` Pool token mint account
-    ///  10. `[]` Sysvar clock account (required)
-    ///  11. `[]` Pool token program id
-    ///  12. `[]` Stake program id,
-    ///  userdata: amount of pool tokens to withdraw
-    WithdrawStakeWithSlippage {
-        /// Pool tokens to burn in exchange for lamports
-        pool_tokens_in: u64,
-        /// Minimum amount of lamports that must be received
-        minimum_lamports_out: u64,
-    },
-
-    ///   Deposit SOL directly into the pool's reserve account, with a
-    ///   specified slippage constraint. The output is a "pool" token
-    ///   representing ownership into the pool. Inputs are converted at the
-    ///   current ratio.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[]` Stake pool withdraw authority
-    ///   2. `[w]` Reserve stake account, to deposit SOL
-    ///   3. `[s]` Account providing the lamports to be deposited into the pool
-    ///   4. `[w]` User account to receive pool tokens
-    ///   5. `[w]` Account to receive fee tokens
-    ///   6. `[w]` Account to receive a portion of fee as referral fees
-    ///   7. `[w]` Pool token mint account
-    ///   8. `[]` System program account
-    ///   9. `[]` Token program id
-    ///  10. `[s]` (Optional) Stake pool sol deposit authority.
-    DepositSolWithSlippage {
-        /// Amount of lamports to deposit into the reserve
-        lamports_in: u64,
-        /// Minimum amount of pool tokens that must be received
-        minimum_pool_tokens_out: u64,
-    },
-
-    ///   Withdraw SOL directly from the pool's reserve account. Fails if the
-    ///   reserve does not have enough SOL or if the slippage constraint is not
-    ///   met.
-    ///
-    ///   0. `[w]` Stake pool
-    ///   1. `[]` Stake pool withdraw authority
-    ///   2. `[s]` User transfer authority, for pool token account
-    ///   3. `[w]` User account to burn pool tokens
-    ///   4. `[w]` Reserve stake account, to withdraw SOL
-    ///   5. `[w]` Account receiving the lamports from the reserve, must be a
-    ///      system account
-    ///   6. `[w]` Account to receive pool fee tokens
-    ///   7. `[w]` Pool token mint account
-    ///   8. '[]' Clock sysvar
-    ///   9. '[]' Stake history sysvar
-    ///  10. `[]` Stake program account
-    ///  11. `[]` Token program id
-    ///  12. `[s]` (Optional) Stake pool sol withdraw authority
-    WithdrawSolWithSlippage {
-        /// Pool tokens to burn in exchange for lamports
-        pool_tokens_in: u64,
-        /// Minimum amount of lamports that must be received
-        minimum_lamports_out: u64,
-    },
-}
-
-/// Creates an 'initialize' instruction.
-pub fn initialize(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    pool_mint: &Pubkey,
-    manager_pool_account: &Pubkey,
-    token_program_id: &Pubkey,
-    deposit_authority: Option<Pubkey>,
-    fee: Fee,
-    withdrawal_fee: Fee,
-    deposit_fee: Fee,
-    referral_fee: u8,
-    max_validators: u32,
-) -> Instruction {
-    let init_data = StakePoolInstruction::Initialize {
-        fee,
-        withdrawal_fee,
-        deposit_fee,
-        referral_fee,
-        max_validators,
-    };
-    let data = borsh::to_vec(&init_data).unwrap();
-    let mut accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-        AccountMeta::new_readonly(*staker, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new_readonly(*reserve_stake, false),
-        AccountMeta::new(*pool_mint, false),
-        AccountMeta::new(*manager_pool_account, false),
-        AccountMeta::new_readonly(*token_program_id, false),
-    ];
-    if let Some(deposit_authority) = deposit_authority {
-        accounts.push(AccountMeta::new_readonly(deposit_authority, true));
-    }
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates `AddValidatorToPool` instruction (add new validator stake account to
-/// the pool)
-pub fn add_validator_to_pool(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    reserve: &Pubkey,
-    stake_pool_withdraw: &Pubkey,
-    validator_list: &Pubkey,
-    stake: &Pubkey,
-    validator: &Pubkey,
-    seed: Option<NonZeroU32>,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new(*reserve, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*stake, false),
-        AccountMeta::new_readonly(*validator, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    let data = borsh::to_vec(&StakePoolInstruction::AddValidatorToPool(
-        seed.map(|s| s.get()).unwrap_or(0),
-    ))
-    .unwrap();
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates `RemoveValidatorFromPool` instruction (remove validator stake
-/// account from the pool)
-pub fn remove_validator_from_pool(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw: &Pubkey,
-    validator_list: &Pubkey,
-    stake_account: &Pubkey,
-    transient_stake_account: &Pubkey,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*stake_account, false),
-        AccountMeta::new(*transient_stake_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::RemoveValidatorFromPool).unwrap(),
-    }
-}
-
-/// Creates `DecreaseValidatorStake` instruction (rebalance from validator
-/// account to transient account)
-#[deprecated(
-    since = "0.7.0",
-    note = "please use `decrease_validator_stake_with_reserve`"
-)]
-pub fn decrease_validator_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    validator_stake: &Pubkey,
-    transient_stake: &Pubkey,
-    lamports: u64,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*validator_stake, false),
-        AccountMeta::new(*transient_stake, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::DecreaseValidatorStake {
-            lamports,
-            transient_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `DecreaseAdditionalValidatorStake` instruction (rebalance from
-/// validator account to transient account)
-pub fn decrease_additional_validator_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    validator_stake: &Pubkey,
-    ephemeral_stake: &Pubkey,
-    transient_stake: &Pubkey,
-    lamports: u64,
-    transient_stake_seed: u64,
-    ephemeral_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new(*validator_stake, false),
-        AccountMeta::new(*ephemeral_stake, false),
-        AccountMeta::new(*transient_stake, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::DecreaseAdditionalValidatorStake {
-            lamports,
-            transient_stake_seed,
-            ephemeral_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `DecreaseValidatorStakeWithReserve` instruction (rebalance from
-/// validator account to transient account)
-pub fn decrease_validator_stake_with_reserve(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    validator_stake: &Pubkey,
-    transient_stake: &Pubkey,
-    lamports: u64,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new(*validator_stake, false),
-        AccountMeta::new(*transient_stake, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::DecreaseValidatorStakeWithReserve {
-            lamports,
-            transient_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `IncreaseValidatorStake` instruction (rebalance from reserve account
-/// to transient account)
-pub fn increase_validator_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    transient_stake: &Pubkey,
-    validator_stake: &Pubkey,
-    validator: &Pubkey,
-    lamports: u64,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new(*transient_stake, false),
-        AccountMeta::new_readonly(*validator_stake, false),
-        AccountMeta::new_readonly(*validator, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::IncreaseValidatorStake {
-            lamports,
-            transient_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `IncreaseAdditionalValidatorStake` instruction (rebalance from
-/// reserve account to transient account)
-pub fn increase_additional_validator_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    ephemeral_stake: &Pubkey,
-    transient_stake: &Pubkey,
-    validator_stake: &Pubkey,
-    validator: &Pubkey,
-    lamports: u64,
-    transient_stake_seed: u64,
-    ephemeral_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new(*ephemeral_stake, false),
-        AccountMeta::new(*transient_stake, false),
-        AccountMeta::new_readonly(*validator_stake, false),
-        AccountMeta::new_readonly(*validator, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::IncreaseAdditionalValidatorStake {
-            lamports,
-            transient_stake_seed,
-            ephemeral_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `Redelegate` instruction (rebalance from one validator account to
-/// another)
-pub fn redelegate(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    staker: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list: &Pubkey,
-    reserve_stake: &Pubkey,
-    source_validator_stake: &Pubkey,
-    source_transient_stake: &Pubkey,
-    ephemeral_stake: &Pubkey,
-    destination_transient_stake: &Pubkey,
-    destination_validator_stake: &Pubkey,
-    validator: &Pubkey,
-    lamports: u64,
-    source_transient_stake_seed: u64,
-    ephemeral_stake_seed: u64,
-    destination_transient_stake_seed: u64,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*staker, true),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new(*source_validator_stake, false),
-        AccountMeta::new(*source_transient_stake, false),
-        AccountMeta::new(*ephemeral_stake, false),
-        AccountMeta::new(*destination_transient_stake, false),
-        AccountMeta::new_readonly(*destination_validator_stake, false),
-        AccountMeta::new_readonly(*validator, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::Redelegate {
-            lamports,
-            source_transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_transient_stake_seed,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates `SetPreferredDepositValidator` instruction
-pub fn set_preferred_validator(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-    staker: &Pubkey,
-    validator_list_address: &Pubkey,
-    validator_type: PreferredValidatorType,
-    validator_vote_address: Option<Pubkey>,
-) -> Instruction {
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*stake_pool_address, false),
-            AccountMeta::new_readonly(*staker, true),
-            AccountMeta::new_readonly(*validator_list_address, false),
-        ],
-        data: borsh::to_vec(&StakePoolInstruction::SetPreferredValidator {
-            validator_type,
-            validator_vote_address,
-        })
-        .unwrap(),
-    }
-}
-
-/// Create an `AddValidatorToPool` instruction given an existing stake pool and
-/// vote account
-pub fn add_validator_to_pool_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    seed: Option<NonZeroU32>,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (stake_account_address, _) =
-        find_stake_program_address(program_id, vote_account_address, stake_pool_address, seed);
-    add_validator_to_pool(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &stake_pool.reserve_stake,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_account_address,
-        vote_account_address,
-        seed,
-    )
-}
-
-/// Create an `RemoveValidatorFromPool` instruction given an existing stake pool
-/// and vote account
-pub fn remove_validator_from_pool_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    validator_stake_seed: Option<NonZeroU32>,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (stake_account_address, _) = find_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    );
-    let (transient_stake_account, _) = find_transient_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    );
-    remove_validator_from_pool(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_account_address,
-        &transient_stake_account,
-    )
-}
-
-/// Create an `IncreaseValidatorStake` instruction given an existing stake pool
-/// and vote account
-pub fn increase_validator_stake_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    lamports: u64,
-    validator_stake_seed: Option<NonZeroU32>,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    );
-    let (validator_stake_address, _) = find_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    );
-
-    increase_validator_stake(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_pool.reserve_stake,
-        &transient_stake_address,
-        &validator_stake_address,
-        vote_account_address,
-        lamports,
-        transient_stake_seed,
-    )
-}
-
-/// Create an `IncreaseAdditionalValidatorStake` instruction given an existing
-/// stake pool and vote account
-pub fn increase_additional_validator_stake_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    lamports: u64,
-    validator_stake_seed: Option<NonZeroU32>,
-    transient_stake_seed: u64,
-    ephemeral_stake_seed: u64,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (ephemeral_stake_address, _) =
-        find_ephemeral_stake_program_address(program_id, stake_pool_address, ephemeral_stake_seed);
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    );
-    let (validator_stake_address, _) = find_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    );
-
-    increase_additional_validator_stake(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_pool.reserve_stake,
-        &ephemeral_stake_address,
-        &transient_stake_address,
-        &validator_stake_address,
-        vote_account_address,
-        lamports,
-        transient_stake_seed,
-        ephemeral_stake_seed,
-    )
-}
-
-/// Create a `DecreaseValidatorStake` instruction given an existing stake pool
-/// and vote account
-pub fn decrease_validator_stake_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    lamports: u64,
-    validator_stake_seed: Option<NonZeroU32>,
-    transient_stake_seed: u64,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (validator_stake_address, _) = find_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    );
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    );
-    decrease_validator_stake_with_reserve(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_pool.reserve_stake,
-        &validator_stake_address,
-        &transient_stake_address,
-        lamports,
-        transient_stake_seed,
-    )
-}
-
-/// Create a `DecreaseAdditionalValidatorStake` instruction given an existing
-/// stake pool and vote account
-pub fn decrease_additional_validator_stake_with_vote(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    stake_pool_address: &Pubkey,
-    vote_account_address: &Pubkey,
-    lamports: u64,
-    validator_stake_seed: Option<NonZeroU32>,
-    transient_stake_seed: u64,
-    ephemeral_stake_seed: u64,
-) -> Instruction {
-    let pool_withdraw_authority =
-        find_withdraw_authority_program_address(program_id, stake_pool_address).0;
-    let (validator_stake_address, _) = find_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    );
-    let (ephemeral_stake_address, _) =
-        find_ephemeral_stake_program_address(program_id, stake_pool_address, ephemeral_stake_seed);
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        program_id,
-        vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    );
-    decrease_additional_validator_stake(
-        program_id,
-        stake_pool_address,
-        &stake_pool.staker,
-        &pool_withdraw_authority,
-        &stake_pool.validator_list,
-        &stake_pool.reserve_stake,
-        &validator_stake_address,
-        &ephemeral_stake_address,
-        &transient_stake_address,
-        lamports,
-        transient_stake_seed,
-        ephemeral_stake_seed,
-    )
-}
-
-/// Creates `UpdateValidatorListBalance` instruction (update validator stake
-/// account balances)
-#[deprecated(
-    since = "1.1.0",
-    note = "please use `update_validator_list_balance_chunk`"
-)]
-pub fn update_validator_list_balance(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list_address: &Pubkey,
-    reserve_stake: &Pubkey,
-    validator_list: &ValidatorList,
-    validator_vote_accounts: &[Pubkey],
-    start_index: u32,
-    no_merge: bool,
-) -> Instruction {
-    let mut accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list_address, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    accounts.append(
-        &mut validator_vote_accounts
-            .iter()
-            .flat_map(|vote_account_address| {
-                let validator_stake_info = validator_list.find(vote_account_address);
-                if let Some(validator_stake_info) = validator_stake_info {
-                    let (validator_stake_account, _) = find_stake_program_address(
-                        program_id,
-                        vote_account_address,
-                        stake_pool,
-                        NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-                    );
-                    let (transient_stake_account, _) = find_transient_stake_program_address(
-                        program_id,
-                        vote_account_address,
-                        stake_pool,
-                        validator_stake_info.transient_seed_suffix.into(),
-                    );
-                    vec![
-                        AccountMeta::new(validator_stake_account, false),
-                        AccountMeta::new(transient_stake_account, false),
-                    ]
-                } else {
-                    vec![]
-                }
-            })
-            .collect::<Vec<AccountMeta>>(),
-    );
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::UpdateValidatorListBalance {
-            start_index,
-            no_merge,
-        })
-        .unwrap(),
-    }
-}
-
-/// Creates an `UpdateValidatorListBalance` instruction (update validator stake
-/// account balances) to update `validator_list[start_index..start_index +
-/// len]`.
-///
-/// Returns `Err(ProgramError::InvalidInstructionData)` if:
-/// - `start_index..start_index + len` is out of bounds for
-///   `validator_list.validators`
-pub fn update_validator_list_balance_chunk(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list_address: &Pubkey,
-    reserve_stake: &Pubkey,
-    validator_list: &ValidatorList,
-    len: usize,
-    start_index: usize,
-    no_merge: bool,
-) -> Result<Instruction, ProgramError> {
-    let mut accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*validator_list_address, false),
-        AccountMeta::new(*reserve_stake, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    let validator_list_subslice = validator_list
-        .validators
-        .get(start_index..start_index.saturating_add(len))
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    accounts.extend(validator_list_subslice.iter().flat_map(
-        |ValidatorStakeInfo {
-             vote_account_address,
-             validator_seed_suffix,
-             transient_seed_suffix,
-             ..
-         }| {
-            let (validator_stake_account, _) = find_stake_program_address(
-                program_id,
-                vote_account_address,
-                stake_pool,
-                NonZeroU32::new((*validator_seed_suffix).into()),
-            );
-            let (transient_stake_account, _) = find_transient_stake_program_address(
-                program_id,
-                vote_account_address,
-                stake_pool,
-                (*transient_seed_suffix).into(),
-            );
-            [
-                AccountMeta::new(validator_stake_account, false),
-                AccountMeta::new(transient_stake_account, false),
-            ]
-        },
-    ));
-    Ok(Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::UpdateValidatorListBalance {
-            start_index: start_index.try_into().unwrap(),
-            no_merge,
-        })
-        .unwrap(),
-    })
-}
-
-/// Creates `UpdateValidatorListBalance` instruction (update validator stake
-/// account balances)
-///
-/// Returns `None` if all validators in the given chunk has already been updated
-/// for this epoch, returns the required instruction otherwise.
-pub fn update_stale_validator_list_balance_chunk(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    validator_list_address: &Pubkey,
-    reserve_stake: &Pubkey,
-    validator_list: &ValidatorList,
-    len: usize,
-    start_index: usize,
-    no_merge: bool,
-    current_epoch: Epoch,
-) -> Result<Option<Instruction>, ProgramError> {
-    let validator_list_subslice = validator_list
-        .validators
-        .get(start_index..start_index.saturating_add(len))
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    if validator_list_subslice.iter().all(|info| {
-        let last_update_epoch: u64 = info.last_update_epoch.into();
-        last_update_epoch >= current_epoch
-    }) {
-        return Ok(None);
-    }
-    update_validator_list_balance_chunk(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        validator_list_address,
-        reserve_stake,
-        validator_list,
-        len,
-        start_index,
-        no_merge,
-    )
-    .map(Some)
-}
-
-/// Creates `UpdateStakePoolBalance` instruction (pool balance from the stake
-/// account list balances)
-pub fn update_stake_pool_balance(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    withdraw_authority: &Pubkey,
-    validator_list_storage: &Pubkey,
-    reserve_stake: &Pubkey,
-    manager_fee_account: &Pubkey,
-    stake_pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*withdraw_authority, false),
-        AccountMeta::new(*validator_list_storage, false),
-        AccountMeta::new_readonly(*reserve_stake, false),
-        AccountMeta::new(*manager_fee_account, false),
-        AccountMeta::new(*stake_pool_mint, false),
-        AccountMeta::new_readonly(*token_program_id, false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::UpdateStakePoolBalance).unwrap(),
-    }
-}
-
-/// Creates `CleanupRemovedValidatorEntries` instruction (removes entries from
-/// the validator list)
-pub fn cleanup_removed_validator_entries(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new(*validator_list_storage, false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::CleanupRemovedValidatorEntries).unwrap(),
-    }
-}
-
-/// Creates all `UpdateValidatorListBalance` and `UpdateStakePoolBalance`
-/// instructions for fully updating a stake pool each epoch
-pub fn update_stake_pool(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    validator_list: &ValidatorList,
-    stake_pool_address: &Pubkey,
-    no_merge: bool,
-) -> (Vec<Instruction>, Vec<Instruction>) {
-    let (withdraw_authority, _) =
-        find_withdraw_authority_program_address(program_id, stake_pool_address);
-
-    let update_list_instructions = validator_list
-        .validators
-        .chunks(MAX_VALIDATORS_TO_UPDATE)
-        .enumerate()
-        .map(|(i, chunk)| {
-            // unwrap-safety: chunk len and offset are derived
-            update_validator_list_balance_chunk(
-                program_id,
-                stake_pool_address,
-                &withdraw_authority,
-                &stake_pool.validator_list,
-                &stake_pool.reserve_stake,
-                validator_list,
-                chunk.len(),
-                i.saturating_mul(MAX_VALIDATORS_TO_UPDATE),
-                no_merge,
-            )
-            .unwrap()
-        })
-        .collect();
-
-    let final_instructions = vec![
-        update_stake_pool_balance(
-            program_id,
-            stake_pool_address,
-            &withdraw_authority,
-            &stake_pool.validator_list,
-            &stake_pool.reserve_stake,
-            &stake_pool.manager_fee_account,
-            &stake_pool.pool_mint,
-            &stake_pool.token_program_id,
-        ),
-        cleanup_removed_validator_entries(
-            program_id,
-            stake_pool_address,
-            &stake_pool.validator_list,
-        ),
-    ];
-    (update_list_instructions, final_instructions)
-}
-
-/// Creates the `UpdateValidatorListBalance` instructions only for validators on
-/// `validator_list` that have not been updated for this epoch, and the
-/// `UpdateStakePoolBalance` instruction for fully updating the stake pool.
-///
-/// Basically same as [`update_stake_pool`], but skips validators that are
-/// already updated for this epoch
-pub fn update_stale_stake_pool(
-    program_id: &Pubkey,
-    stake_pool: &StakePool,
-    validator_list: &ValidatorList,
-    stake_pool_address: &Pubkey,
-    no_merge: bool,
-    current_epoch: Epoch,
-) -> (Vec<Instruction>, Vec<Instruction>) {
-    let (withdraw_authority, _) =
-        find_withdraw_authority_program_address(program_id, stake_pool_address);
-
-    let update_list_instructions = validator_list
-        .validators
-        .chunks(MAX_VALIDATORS_TO_UPDATE)
-        .enumerate()
-        .filter_map(|(i, chunk)| {
-            // unwrap-safety: chunk len and offset are derived
-            update_stale_validator_list_balance_chunk(
-                program_id,
-                stake_pool_address,
-                &withdraw_authority,
-                &stake_pool.validator_list,
-                &stake_pool.reserve_stake,
-                validator_list,
-                chunk.len(),
-                i.saturating_mul(MAX_VALIDATORS_TO_UPDATE),
-                no_merge,
-                current_epoch,
-            )
-            .unwrap()
-        })
-        .collect();
-
-    let final_instructions = vec![
-        update_stake_pool_balance(
-            program_id,
-            stake_pool_address,
-            &withdraw_authority,
-            &stake_pool.validator_list,
-            &stake_pool.reserve_stake,
-            &stake_pool.manager_fee_account,
-            &stake_pool.pool_mint,
-            &stake_pool.token_program_id,
-        ),
-        cleanup_removed_validator_entries(
-            program_id,
-            stake_pool_address,
-            &stake_pool.validator_list,
-        ),
-    ];
-    (update_list_instructions, final_instructions)
-}
-
-fn deposit_stake_internal(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_deposit_authority: Option<&Pubkey>,
-    stake_pool_withdraw_authority: &Pubkey,
-    deposit_stake_address: &Pubkey,
-    deposit_stake_withdraw_authority: &Pubkey,
-    validator_stake_account: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    minimum_pool_tokens_out: Option<u64>,
-) -> Vec<Instruction> {
-    let mut instructions = vec![];
-    let mut accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new(*validator_list_storage, false),
-    ];
-    if let Some(stake_pool_deposit_authority) = stake_pool_deposit_authority {
-        accounts.push(AccountMeta::new_readonly(
-            *stake_pool_deposit_authority,
-            true,
-        ));
-        instructions.extend_from_slice(&[
-            stake::instruction::authorize(
-                deposit_stake_address,
-                deposit_stake_withdraw_authority,
-                stake_pool_deposit_authority,
-                stake::state::StakeAuthorize::Staker,
-                None,
-            ),
-            stake::instruction::authorize(
-                deposit_stake_address,
-                deposit_stake_withdraw_authority,
-                stake_pool_deposit_authority,
-                stake::state::StakeAuthorize::Withdrawer,
-                None,
-            ),
-        ]);
-    } else {
-        let stake_pool_deposit_authority =
-            find_deposit_authority_program_address(program_id, stake_pool).0;
-        accounts.push(AccountMeta::new_readonly(
-            stake_pool_deposit_authority,
-            false,
-        ));
-        instructions.extend_from_slice(&[
-            stake::instruction::authorize(
-                deposit_stake_address,
-                deposit_stake_withdraw_authority,
-                &stake_pool_deposit_authority,
-                stake::state::StakeAuthorize::Staker,
-                None,
-            ),
-            stake::instruction::authorize(
-                deposit_stake_address,
-                deposit_stake_withdraw_authority,
-                &stake_pool_deposit_authority,
-                stake::state::StakeAuthorize::Withdrawer,
-                None,
-            ),
-        ]);
-    };
-
-    accounts.extend_from_slice(&[
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*deposit_stake_address, false),
-        AccountMeta::new(*validator_stake_account, false),
-        AccountMeta::new(*reserve_stake_account, false),
-        AccountMeta::new(*pool_tokens_to, false),
-        AccountMeta::new(*manager_fee_account, false),
-        AccountMeta::new(*referrer_pool_tokens_account, false),
-        AccountMeta::new(*pool_mint, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(*token_program_id, false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ]);
-    instructions.push(
-        if let Some(minimum_pool_tokens_out) = minimum_pool_tokens_out {
-            Instruction {
-                program_id: *program_id,
-                accounts,
-                data: borsh::to_vec(&StakePoolInstruction::DepositStakeWithSlippage {
-                    minimum_pool_tokens_out,
-                })
-                .unwrap(),
-            }
-        } else {
-            Instruction {
-                program_id: *program_id,
-                accounts,
-                data: borsh::to_vec(&StakePoolInstruction::DepositStake).unwrap(),
-            }
-        },
-    );
-    instructions
-}
-
-/// Creates instructions required to deposit into a stake pool, given a stake
-/// account owned by the user.
-pub fn deposit_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    deposit_stake_address: &Pubkey,
-    deposit_stake_withdraw_authority: &Pubkey,
-    validator_stake_account: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Vec<Instruction> {
-    deposit_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        None,
-        stake_pool_withdraw_authority,
-        deposit_stake_address,
-        deposit_stake_withdraw_authority,
-        validator_stake_account,
-        reserve_stake_account,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        None,
-    )
-}
-
-/// Creates instructions to deposit into a stake pool with slippage
-pub fn deposit_stake_with_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    deposit_stake_address: &Pubkey,
-    deposit_stake_withdraw_authority: &Pubkey,
-    validator_stake_account: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    minimum_pool_tokens_out: u64,
-) -> Vec<Instruction> {
-    deposit_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        None,
-        stake_pool_withdraw_authority,
-        deposit_stake_address,
-        deposit_stake_withdraw_authority,
-        validator_stake_account,
-        reserve_stake_account,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        Some(minimum_pool_tokens_out),
-    )
-}
-
-/// Creates instructions required to deposit into a stake pool, given a stake
-/// account owned by the user. The difference with `deposit()` is that a deposit
-/// authority must sign this instruction, which is required for private pools.
-pub fn deposit_stake_with_authority(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_deposit_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    deposit_stake_address: &Pubkey,
-    deposit_stake_withdraw_authority: &Pubkey,
-    validator_stake_account: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-) -> Vec<Instruction> {
-    deposit_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        Some(stake_pool_deposit_authority),
-        stake_pool_withdraw_authority,
-        deposit_stake_address,
-        deposit_stake_withdraw_authority,
-        validator_stake_account,
-        reserve_stake_account,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        None,
-    )
-}
-
-/// Creates instructions required to deposit into a stake pool with slippage,
-/// given a stake account owned by the user. The difference with `deposit()` is
-/// that a deposit authority must sign this instruction, which is required for
-/// private pools.
-pub fn deposit_stake_with_authority_and_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_deposit_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    deposit_stake_address: &Pubkey,
-    deposit_stake_withdraw_authority: &Pubkey,
-    validator_stake_account: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    minimum_pool_tokens_out: u64,
-) -> Vec<Instruction> {
-    deposit_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        Some(stake_pool_deposit_authority),
-        stake_pool_withdraw_authority,
-        deposit_stake_address,
-        deposit_stake_withdraw_authority,
-        validator_stake_account,
-        reserve_stake_account,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        Some(minimum_pool_tokens_out),
-    )
-}
-
-/// Creates instructions required to deposit SOL directly into a stake pool.
-fn deposit_sol_internal(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_from: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    sol_deposit_authority: Option<&Pubkey>,
-    lamports_in: u64,
-    minimum_pool_tokens_out: Option<u64>,
-) -> Instruction {
-    let mut accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new(*reserve_stake_account, false),
-        AccountMeta::new(*lamports_from, true),
-        AccountMeta::new(*pool_tokens_to, false),
-        AccountMeta::new(*manager_fee_account, false),
-        AccountMeta::new(*referrer_pool_tokens_account, false),
-        AccountMeta::new(*pool_mint, false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(*token_program_id, false),
-    ];
-    if let Some(sol_deposit_authority) = sol_deposit_authority {
-        accounts.push(AccountMeta::new_readonly(*sol_deposit_authority, true));
-    }
-    if let Some(minimum_pool_tokens_out) = minimum_pool_tokens_out {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::DepositSolWithSlippage {
-                lamports_in,
-                minimum_pool_tokens_out,
-            })
-            .unwrap(),
-        }
-    } else {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::DepositSol(lamports_in)).unwrap(),
-        }
-    }
-}
-
-/// Creates instruction to deposit SOL directly into a stake pool.
-pub fn deposit_sol(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_from: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    lamports_in: u64,
-) -> Instruction {
-    deposit_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        reserve_stake_account,
-        lamports_from,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        None,
-        lamports_in,
-        None,
-    )
-}
-
-/// Creates instruction to deposit SOL directly into a stake pool with slippage
-/// constraint.
-pub fn deposit_sol_with_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_from: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    lamports_in: u64,
-    minimum_pool_tokens_out: u64,
-) -> Instruction {
-    deposit_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        reserve_stake_account,
-        lamports_from,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        None,
-        lamports_in,
-        Some(minimum_pool_tokens_out),
-    )
-}
-
-/// Creates instruction required to deposit SOL directly into a stake pool.
-/// The difference with `deposit_sol()` is that a deposit
-/// authority must sign this instruction.
-pub fn deposit_sol_with_authority(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    sol_deposit_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_from: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    lamports_in: u64,
-) -> Instruction {
-    deposit_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        reserve_stake_account,
-        lamports_from,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        Some(sol_deposit_authority),
-        lamports_in,
-        None,
-    )
-}
-
-/// Creates instruction to deposit SOL directly into a stake pool with slippage
-/// constraint.
-pub fn deposit_sol_with_authority_and_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    sol_deposit_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_from: &Pubkey,
-    pool_tokens_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    referrer_pool_tokens_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    lamports_in: u64,
-    minimum_pool_tokens_out: u64,
-) -> Instruction {
-    deposit_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        reserve_stake_account,
-        lamports_from,
-        pool_tokens_to,
-        manager_fee_account,
-        referrer_pool_tokens_account,
-        pool_mint,
-        token_program_id,
-        Some(sol_deposit_authority),
-        lamports_in,
-        Some(minimum_pool_tokens_out),
-    )
-}
-
-fn withdraw_stake_internal(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_withdraw: &Pubkey,
-    stake_to_split: &Pubkey,
-    stake_to_receive: &Pubkey,
-    user_stake_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    user_pool_token_account: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-    minimum_lamports_out: Option<u64>,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new(*validator_list_storage, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw, false),
-        AccountMeta::new(*stake_to_split, false),
-        AccountMeta::new(*stake_to_receive, false),
-        AccountMeta::new_readonly(*user_stake_authority, false),
-        AccountMeta::new_readonly(*user_transfer_authority, true),
-        AccountMeta::new(*user_pool_token_account, false),
-        AccountMeta::new(*manager_fee_account, false),
-        AccountMeta::new(*pool_mint, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(*token_program_id, false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    if let Some(minimum_lamports_out) = minimum_lamports_out {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::WithdrawStakeWithSlippage {
-                pool_tokens_in,
-                minimum_lamports_out,
-            })
-            .unwrap(),
-        }
-    } else {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::WithdrawStake(pool_tokens_in)).unwrap(),
-        }
-    }
-}
-
-/// Creates a 'WithdrawStake' instruction.
-pub fn withdraw_stake(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_withdraw: &Pubkey,
-    stake_to_split: &Pubkey,
-    stake_to_receive: &Pubkey,
-    user_stake_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    user_pool_token_account: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-) -> Instruction {
-    withdraw_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        stake_pool_withdraw,
-        stake_to_split,
-        stake_to_receive,
-        user_stake_authority,
-        user_transfer_authority,
-        user_pool_token_account,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        pool_tokens_in,
-        None,
-    )
-}
-
-/// Creates a 'WithdrawStakeWithSlippage' instruction.
-pub fn withdraw_stake_with_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    validator_list_storage: &Pubkey,
-    stake_pool_withdraw: &Pubkey,
-    stake_to_split: &Pubkey,
-    stake_to_receive: &Pubkey,
-    user_stake_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    user_pool_token_account: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-    minimum_lamports_out: u64,
-) -> Instruction {
-    withdraw_stake_internal(
-        program_id,
-        stake_pool,
-        validator_list_storage,
-        stake_pool_withdraw,
-        stake_to_split,
-        stake_to_receive,
-        user_stake_authority,
-        user_transfer_authority,
-        user_pool_token_account,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        pool_tokens_in,
-        Some(minimum_lamports_out),
-    )
-}
-
-fn withdraw_sol_internal(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    pool_tokens_from: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    sol_withdraw_authority: Option<&Pubkey>,
-    pool_tokens_in: u64,
-    minimum_lamports_out: Option<u64>,
-) -> Instruction {
-    let mut accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*stake_pool_withdraw_authority, false),
-        AccountMeta::new_readonly(*user_transfer_authority, true),
-        AccountMeta::new(*pool_tokens_from, false),
-        AccountMeta::new(*reserve_stake_account, false),
-        AccountMeta::new(*lamports_to, false),
-        AccountMeta::new(*manager_fee_account, false),
-        AccountMeta::new(*pool_mint, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-        AccountMeta::new_readonly(*token_program_id, false),
-    ];
-    if let Some(sol_withdraw_authority) = sol_withdraw_authority {
-        accounts.push(AccountMeta::new_readonly(*sol_withdraw_authority, true));
-    }
-    if let Some(minimum_lamports_out) = minimum_lamports_out {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::WithdrawSolWithSlippage {
-                pool_tokens_in,
-                minimum_lamports_out,
-            })
-            .unwrap(),
-        }
-    } else {
-        Instruction {
-            program_id: *program_id,
-            accounts,
-            data: borsh::to_vec(&StakePoolInstruction::WithdrawSol(pool_tokens_in)).unwrap(),
-        }
-    }
-}
-
-/// Creates instruction required to withdraw SOL directly from a stake pool.
-pub fn withdraw_sol(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    pool_tokens_from: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-) -> Instruction {
-    withdraw_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        user_transfer_authority,
-        pool_tokens_from,
-        reserve_stake_account,
-        lamports_to,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        None,
-        pool_tokens_in,
-        None,
-    )
-}
-
-/// Creates instruction required to withdraw SOL directly from a stake pool with
-/// slippage constraints.
-pub fn withdraw_sol_with_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    pool_tokens_from: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-    minimum_lamports_out: u64,
-) -> Instruction {
-    withdraw_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        user_transfer_authority,
-        pool_tokens_from,
-        reserve_stake_account,
-        lamports_to,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        None,
-        pool_tokens_in,
-        Some(minimum_lamports_out),
-    )
-}
-
-/// Creates instruction required to withdraw SOL directly from a stake pool.
-/// The difference with `withdraw_sol()` is that the sol withdraw authority
-/// must sign this instruction.
-pub fn withdraw_sol_with_authority(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    sol_withdraw_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    pool_tokens_from: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-) -> Instruction {
-    withdraw_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        user_transfer_authority,
-        pool_tokens_from,
-        reserve_stake_account,
-        lamports_to,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        Some(sol_withdraw_authority),
-        pool_tokens_in,
-        None,
-    )
-}
-
-/// Creates instruction required to withdraw SOL directly from a stake pool with
-/// a slippage constraint.
-/// The difference with `withdraw_sol()` is that the sol withdraw authority
-/// must sign this instruction.
-pub fn withdraw_sol_with_authority_and_slippage(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    sol_withdraw_authority: &Pubkey,
-    stake_pool_withdraw_authority: &Pubkey,
-    user_transfer_authority: &Pubkey,
-    pool_tokens_from: &Pubkey,
-    reserve_stake_account: &Pubkey,
-    lamports_to: &Pubkey,
-    manager_fee_account: &Pubkey,
-    pool_mint: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_tokens_in: u64,
-    minimum_lamports_out: u64,
-) -> Instruction {
-    withdraw_sol_internal(
-        program_id,
-        stake_pool,
-        stake_pool_withdraw_authority,
-        user_transfer_authority,
-        pool_tokens_from,
-        reserve_stake_account,
-        lamports_to,
-        manager_fee_account,
-        pool_mint,
-        token_program_id,
-        Some(sol_withdraw_authority),
-        pool_tokens_in,
-        Some(minimum_lamports_out),
-    )
-}
-
-/// Creates a 'set manager' instruction.
-pub fn set_manager(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    new_manager: &Pubkey,
-    new_fee_receiver: &Pubkey,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-        AccountMeta::new_readonly(*new_manager, true),
-        AccountMeta::new_readonly(*new_fee_receiver, false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::SetManager).unwrap(),
-    }
-}
-
-/// Creates a 'set fee' instruction.
-pub fn set_fee(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    fee: FeeType,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::SetFee { fee }).unwrap(),
-    }
-}
-
-/// Creates a 'set staker' instruction.
-pub fn set_staker(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    set_staker_authority: &Pubkey,
-    new_staker: &Pubkey,
-) -> Instruction {
-    let accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*set_staker_authority, true),
-        AccountMeta::new_readonly(*new_staker, false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::SetStaker).unwrap(),
-    }
-}
-
-/// Creates a 'SetFundingAuthority' instruction.
-pub fn set_funding_authority(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    new_sol_deposit_authority: Option<&Pubkey>,
-    funding_type: FundingType,
-) -> Instruction {
-    let mut accounts = vec![
-        AccountMeta::new(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-    ];
-    if let Some(auth) = new_sol_deposit_authority {
-        accounts.push(AccountMeta::new_readonly(*auth, false))
-    }
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::SetFundingAuthority(funding_type)).unwrap(),
-    }
-}
-
-/// Creates an instruction to update metadata in the mpl token metadata program
-/// account for the pool token
-pub fn update_token_metadata(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    pool_mint: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> Instruction {
-    let (stake_pool_withdraw_authority, _) =
-        find_withdraw_authority_program_address(program_id, stake_pool);
-    let (token_metadata, _) = find_metadata_account(pool_mint);
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-        AccountMeta::new_readonly(stake_pool_withdraw_authority, false),
-        AccountMeta::new(token_metadata, false),
-        AccountMeta::new_readonly(inline_mpl_token_metadata::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::UpdateTokenMetadata { name, symbol, uri })
-            .unwrap(),
-    }
-}
-
-/// Creates an instruction to create metadata using the mpl token metadata
-/// program for the pool token
-pub fn create_token_metadata(
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    manager: &Pubkey,
-    pool_mint: &Pubkey,
-    payer: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> Instruction {
-    let (stake_pool_withdraw_authority, _) =
-        find_withdraw_authority_program_address(program_id, stake_pool);
-    let (token_metadata, _) = find_metadata_account(pool_mint);
-
-    let accounts = vec![
-        AccountMeta::new_readonly(*stake_pool, false),
-        AccountMeta::new_readonly(*manager, true),
-        AccountMeta::new_readonly(stake_pool_withdraw_authority, false),
-        AccountMeta::new_readonly(*pool_mint, false),
-        AccountMeta::new(*payer, true),
-        AccountMeta::new(token_metadata, false),
-        AccountMeta::new_readonly(inline_mpl_token_metadata::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data: borsh::to_vec(&StakePoolInstruction::CreateTokenMetadata { name, symbol, uri })
-            .unwrap(),
-    }
-}
diff --git a/stake-pool/program/src/lib.rs b/stake-pool/program/src/lib.rs
deleted file mode 100644
index fe48880be98..00000000000
--- a/stake-pool/program/src/lib.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-#![deny(missing_docs)]
-
-//! A program for creating and managing pools of stake
-
-pub mod big_vec;
-pub mod error;
-pub mod inline_mpl_token_metadata;
-pub mod instruction;
-pub mod processor;
-pub mod state;
-
-#[cfg(not(feature = "no-entrypoint"))]
-pub mod entrypoint;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-use {
-    crate::state::Fee,
-    solana_program::{pubkey::Pubkey, stake::state::Meta},
-    std::num::NonZeroU32,
-};
-
-/// Seed for deposit authority seed
-const AUTHORITY_DEPOSIT: &[u8] = b"deposit";
-
-/// Seed for withdraw authority seed
-const AUTHORITY_WITHDRAW: &[u8] = b"withdraw";
-
-/// Seed for transient stake account
-const TRANSIENT_STAKE_SEED_PREFIX: &[u8] = b"transient";
-
-/// Seed for ephemeral stake account
-const EPHEMERAL_STAKE_SEED_PREFIX: &[u8] = b"ephemeral";
-
-/// Minimum amount of staked lamports required in a validator stake account to
-/// allow for merges without a mismatch on credits observed
-pub const MINIMUM_ACTIVE_STAKE: u64 = 1_000_000;
-
-/// Minimum amount of lamports in the reserve
-pub const MINIMUM_RESERVE_LAMPORTS: u64 = 0;
-
-/// Maximum amount of validator stake accounts to update per
-/// `UpdateValidatorListBalance` instruction, based on compute limits
-pub const MAX_VALIDATORS_TO_UPDATE: usize = 5;
-
-/// Maximum factor by which a withdrawal fee can be increased per epoch
-/// protecting stakers from malicious users.
-/// If current fee is 0, WITHDRAWAL_BASELINE_FEE is used as the baseline
-pub const MAX_WITHDRAWAL_FEE_INCREASE: Fee = Fee {
-    numerator: 3,
-    denominator: 2,
-};
-/// Drop-in baseline fee when evaluating withdrawal fee increases when fee is 0
-pub const WITHDRAWAL_BASELINE_FEE: Fee = Fee {
-    numerator: 1,
-    denominator: 1000,
-};
-
-/// The maximum number of transient stake accounts respecting
-/// transaction account limits.
-pub const MAX_TRANSIENT_STAKE_ACCOUNTS: usize = 10;
-
-/// Get the stake amount under consideration when calculating pool token
-/// conversions
-#[inline]
-pub fn minimum_stake_lamports(meta: &Meta, stake_program_minimum_delegation: u64) -> u64 {
-    meta.rent_exempt_reserve
-        .saturating_add(minimum_delegation(stake_program_minimum_delegation))
-}
-
-/// Get the minimum delegation required by a stake account in a stake pool
-#[inline]
-pub fn minimum_delegation(stake_program_minimum_delegation: u64) -> u64 {
-    std::cmp::max(stake_program_minimum_delegation, MINIMUM_ACTIVE_STAKE)
-}
-
-/// Get the stake amount under consideration when calculating pool token
-/// conversions
-#[inline]
-pub fn minimum_reserve_lamports(meta: &Meta) -> u64 {
-    meta.rent_exempt_reserve
-        .saturating_add(MINIMUM_RESERVE_LAMPORTS)
-}
-
-/// Generates the deposit authority program address for the stake pool
-pub fn find_deposit_authority_program_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[stake_pool_address.as_ref(), AUTHORITY_DEPOSIT],
-        program_id,
-    )
-}
-
-/// Generates the withdraw authority program address for the stake pool
-pub fn find_withdraw_authority_program_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[stake_pool_address.as_ref(), AUTHORITY_WITHDRAW],
-        program_id,
-    )
-}
-
-/// Generates the stake program address for a validator's vote account
-pub fn find_stake_program_address(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    stake_pool_address: &Pubkey,
-    seed: Option<NonZeroU32>,
-) -> (Pubkey, u8) {
-    let seed = seed.map(|s| s.get().to_le_bytes());
-    Pubkey::find_program_address(
-        &[
-            vote_account_address.as_ref(),
-            stake_pool_address.as_ref(),
-            seed.as_ref().map(|s| s.as_slice()).unwrap_or(&[]),
-        ],
-        program_id,
-    )
-}
-
-/// Generates the stake program address for a validator's vote account
-pub fn find_transient_stake_program_address(
-    program_id: &Pubkey,
-    vote_account_address: &Pubkey,
-    stake_pool_address: &Pubkey,
-    seed: u64,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[
-            TRANSIENT_STAKE_SEED_PREFIX,
-            vote_account_address.as_ref(),
-            stake_pool_address.as_ref(),
-            &seed.to_le_bytes(),
-        ],
-        program_id,
-    )
-}
-
-/// Generates the ephemeral program address for stake pool redelegation
-pub fn find_ephemeral_stake_program_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-    seed: u64,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(
-        &[
-            EPHEMERAL_STAKE_SEED_PREFIX,
-            stake_pool_address.as_ref(),
-            &seed.to_le_bytes(),
-        ],
-        program_id,
-    )
-}
-
-solana_program::declare_id!("SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy");
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn validator_stake_account_derivation() {
-        let vote = Pubkey::new_unique();
-        let stake_pool = Pubkey::new_unique();
-        let function_derived = find_stake_program_address(&id(), &vote, &stake_pool, None);
-        let hand_derived =
-            Pubkey::find_program_address(&[vote.as_ref(), stake_pool.as_ref()], &id());
-        assert_eq!(function_derived, hand_derived);
-    }
-}
diff --git a/stake-pool/program/src/processor.rs b/stake-pool/program/src/processor.rs
deleted file mode 100644
index 893346ebce8..00000000000
--- a/stake-pool/program/src/processor.rs
+++ /dev/null
@@ -1,4130 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{
-        error::StakePoolError,
-        find_deposit_authority_program_address,
-        inline_mpl_token_metadata::{
-            self,
-            instruction::{create_metadata_accounts_v3, update_metadata_accounts_v2},
-            pda::find_metadata_account,
-            state::DataV2,
-        },
-        instruction::{FundingType, PreferredValidatorType, StakePoolInstruction},
-        minimum_delegation, minimum_reserve_lamports, minimum_stake_lamports,
-        state::{
-            is_extension_supported_for_mint, AccountType, Fee, FeeType, FutureEpoch, StakePool,
-            StakeStatus, StakeWithdrawSource, ValidatorList, ValidatorListHeader,
-            ValidatorStakeInfo,
-        },
-        AUTHORITY_DEPOSIT, AUTHORITY_WITHDRAW, EPHEMERAL_STAKE_SEED_PREFIX,
-        TRANSIENT_STAKE_SEED_PREFIX,
-    },
-    borsh::BorshDeserialize,
-    num_traits::FromPrimitive,
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        borsh1::try_from_slice_unchecked,
-        clock::{Clock, Epoch},
-        decode_error::DecodeError,
-        entrypoint::ProgramResult,
-        msg,
-        program::{invoke, invoke_signed},
-        program_error::{PrintProgramError, ProgramError},
-        pubkey::Pubkey,
-        rent::Rent,
-        stake, system_instruction, system_program,
-        sysvar::Sysvar,
-    },
-    spl_token_2022::{
-        check_spl_token_program_account,
-        extension::{BaseStateWithExtensions, StateWithExtensions},
-        native_mint,
-        state::Mint,
-    },
-    std::num::NonZeroU32,
-};
-
-/// Deserialize the stake state from AccountInfo
-fn get_stake_state(
-    stake_account_info: &AccountInfo,
-) -> Result<(stake::state::Meta, stake::state::Stake), ProgramError> {
-    let stake_state =
-        try_from_slice_unchecked::<stake::state::StakeStateV2>(&stake_account_info.data.borrow())?;
-    match stake_state {
-        stake::state::StakeStateV2::Stake(meta, stake, _) => Ok((meta, stake)),
-        _ => Err(StakePoolError::WrongStakeStake.into()),
-    }
-}
-
-/// Check validity of vote address for a particular stake account
-fn check_validator_stake_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-    stake_account_address: &Pubkey,
-    vote_address: &Pubkey,
-    seed: Option<NonZeroU32>,
-) -> Result<(), ProgramError> {
-    // Check stake account address validity
-    let (validator_stake_address, _) =
-        crate::find_stake_program_address(program_id, vote_address, stake_pool_address, seed);
-    if validator_stake_address != *stake_account_address {
-        msg!(
-            "Incorrect stake account address for vote {}, expected {}, received {}",
-            vote_address,
-            validator_stake_address,
-            stake_account_address
-        );
-        Err(StakePoolError::InvalidStakeAccountAddress.into())
-    } else {
-        Ok(())
-    }
-}
-
-/// Check validity of vote address for a particular stake account
-fn check_transient_stake_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-    stake_account_address: &Pubkey,
-    vote_address: &Pubkey,
-    seed: u64,
-) -> Result<u8, ProgramError> {
-    // Check stake account address validity
-    let (transient_stake_address, bump_seed) = crate::find_transient_stake_program_address(
-        program_id,
-        vote_address,
-        stake_pool_address,
-        seed,
-    );
-    if transient_stake_address != *stake_account_address {
-        Err(StakePoolError::InvalidStakeAccountAddress.into())
-    } else {
-        Ok(bump_seed)
-    }
-}
-
-/// Check address validity for an ephemeral stake account
-fn check_ephemeral_stake_address(
-    program_id: &Pubkey,
-    stake_pool_address: &Pubkey,
-    stake_account_address: &Pubkey,
-    seed: u64,
-) -> Result<u8, ProgramError> {
-    // Check stake account address validity
-    let (ephemeral_stake_address, bump_seed) =
-        crate::find_ephemeral_stake_program_address(program_id, stake_pool_address, seed);
-    if ephemeral_stake_address != *stake_account_address {
-        Err(StakePoolError::InvalidStakeAccountAddress.into())
-    } else {
-        Ok(bump_seed)
-    }
-}
-
-/// Check mpl metadata account address for the pool mint
-fn check_mpl_metadata_account_address(
-    metadata_address: &Pubkey,
-    pool_mint: &Pubkey,
-) -> Result<(), ProgramError> {
-    let (metadata_account_pubkey, _) = find_metadata_account(pool_mint);
-    if metadata_account_pubkey != *metadata_address {
-        Err(StakePoolError::InvalidMetadataAccount.into())
-    } else {
-        Ok(())
-    }
-}
-
-/// Check system program address
-fn check_system_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != system_program::id() {
-        msg!(
-            "Expected system program {}, received {}",
-            system_program::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check stake program address
-fn check_stake_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != stake::program::id() {
-        msg!(
-            "Expected stake program {}, received {}",
-            stake::program::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check mpl metadata program
-fn check_mpl_metadata_program(program_id: &Pubkey) -> Result<(), ProgramError> {
-    if *program_id != inline_mpl_token_metadata::id() {
-        msg!(
-            "Expected mpl metadata program {}, received {}",
-            inline_mpl_token_metadata::id(),
-            program_id
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Check account owner is the given program
-fn check_account_owner(
-    account_info: &AccountInfo,
-    program_id: &Pubkey,
-) -> Result<(), ProgramError> {
-    if *program_id != *account_info.owner {
-        msg!(
-            "Expected account to be owned by program {}, received {}",
-            program_id,
-            account_info.owner
-        );
-        Err(ProgramError::IncorrectProgramId)
-    } else {
-        Ok(())
-    }
-}
-
-/// Checks if a stake account can be managed by the pool
-fn stake_is_usable_by_pool(
-    meta: &stake::state::Meta,
-    expected_authority: &Pubkey,
-    expected_lockup: &stake::state::Lockup,
-) -> bool {
-    meta.authorized.staker == *expected_authority
-        && meta.authorized.withdrawer == *expected_authority
-        && meta.lockup == *expected_lockup
-}
-
-/// Checks if a stake account is active, without taking into account cooldowns
-fn stake_is_inactive_without_history(stake: &stake::state::Stake, epoch: Epoch) -> bool {
-    stake.delegation.deactivation_epoch < epoch
-        || (stake.delegation.activation_epoch == epoch
-            && stake.delegation.deactivation_epoch == epoch)
-}
-
-/// Roughly checks if a stake account is deactivating
-fn check_if_stake_deactivating(
-    account_info: &AccountInfo,
-    vote_account_address: &Pubkey,
-    epoch: Epoch,
-) -> Result<(), ProgramError> {
-    let (_, stake) = get_stake_state(account_info)?;
-    if stake.delegation.deactivation_epoch != epoch {
-        msg!(
-            "Existing stake {} delegated to {} not deactivated in epoch {}",
-            account_info.key,
-            vote_account_address,
-            epoch,
-        );
-        Err(StakePoolError::WrongStakeStake.into())
-    } else {
-        Ok(())
-    }
-}
-
-/// Roughly checks if a stake account is activating
-fn check_if_stake_activating(
-    account_info: &AccountInfo,
-    vote_account_address: &Pubkey,
-    epoch: Epoch,
-) -> Result<(), ProgramError> {
-    let (_, stake) = get_stake_state(account_info)?;
-    if stake.delegation.deactivation_epoch != Epoch::MAX
-        || stake.delegation.activation_epoch != epoch
-    {
-        msg!(
-            "Existing stake {} delegated to {} not activated in epoch {}",
-            account_info.key,
-            vote_account_address,
-            epoch,
-        );
-        Err(StakePoolError::WrongStakeStake.into())
-    } else {
-        Ok(())
-    }
-}
-
-/// Check that the stake state is correct: usable by the pool and delegated to
-/// the expected validator
-fn check_stake_state(
-    stake_account_info: &AccountInfo,
-    withdraw_authority: &Pubkey,
-    vote_account_address: &Pubkey,
-    lockup: &stake::state::Lockup,
-) -> Result<(), ProgramError> {
-    let (meta, stake) = get_stake_state(stake_account_info)?;
-    if !stake_is_usable_by_pool(&meta, withdraw_authority, lockup) {
-        msg!(
-            "Validator stake for {} not usable by pool, must be owned by withdraw authority",
-            vote_account_address
-        );
-        return Err(StakePoolError::WrongStakeStake.into());
-    }
-    if stake.delegation.voter_pubkey != *vote_account_address {
-        msg!(
-            "Validator stake {} not delegated to {}",
-            stake_account_info.key,
-            vote_account_address
-        );
-        return Err(StakePoolError::WrongStakeStake.into());
-    }
-    Ok(())
-}
-
-/// Checks if a validator stake account is valid, which means that it's usable
-/// by the pool and delegated to the expected validator. These conditions can be
-/// violated if a validator was force destaked during a cluster restart.
-fn check_validator_stake_account(
-    stake_account_info: &AccountInfo,
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    withdraw_authority: &Pubkey,
-    vote_account_address: &Pubkey,
-    seed: u32,
-    lockup: &stake::state::Lockup,
-) -> Result<(), ProgramError> {
-    check_account_owner(stake_account_info, &stake::program::id())?;
-    check_validator_stake_address(
-        program_id,
-        stake_pool,
-        stake_account_info.key,
-        vote_account_address,
-        NonZeroU32::new(seed),
-    )?;
-    check_stake_state(
-        stake_account_info,
-        withdraw_authority,
-        vote_account_address,
-        lockup,
-    )?;
-    Ok(())
-}
-
-/// Checks if a transient stake account is valid, which means that it's usable
-/// by the pool and delegated to the expected validator. These conditions can be
-/// violated if a validator was force destaked during a cluster restart.
-fn check_transient_stake_account(
-    stake_account_info: &AccountInfo,
-    program_id: &Pubkey,
-    stake_pool: &Pubkey,
-    withdraw_authority: &Pubkey,
-    vote_account_address: &Pubkey,
-    seed: u64,
-    lockup: &stake::state::Lockup,
-) -> Result<(), ProgramError> {
-    check_account_owner(stake_account_info, &stake::program::id())?;
-    check_transient_stake_address(
-        program_id,
-        stake_pool,
-        stake_account_info.key,
-        vote_account_address,
-        seed,
-    )?;
-    check_stake_state(
-        stake_account_info,
-        withdraw_authority,
-        vote_account_address,
-        lockup,
-    )?;
-    Ok(())
-}
-
-/// Create a stake account on a PDA without transferring lamports
-fn create_stake_account(
-    stake_account_info: AccountInfo<'_>,
-    stake_account_signer_seeds: &[&[u8]],
-    stake_space: usize,
-) -> Result<(), ProgramError> {
-    invoke_signed(
-        &system_instruction::allocate(stake_account_info.key, stake_space as u64),
-        &[stake_account_info.clone()],
-        &[stake_account_signer_seeds],
-    )?;
-    invoke_signed(
-        &system_instruction::assign(stake_account_info.key, &stake::program::id()),
-        &[stake_account_info],
-        &[stake_account_signer_seeds],
-    )
-}
-
-/// Program state handler.
-pub struct Processor {}
-impl Processor {
-    /// Issue a delegate_stake instruction.
-    #[allow(clippy::too_many_arguments)]
-    fn stake_delegate<'a>(
-        stake_info: AccountInfo<'a>,
-        vote_account_info: AccountInfo<'a>,
-        clock_info: AccountInfo<'a>,
-        stake_history_info: AccountInfo<'a>,
-        stake_config_info: AccountInfo<'a>,
-        authority_info: AccountInfo<'a>,
-        stake_pool: &Pubkey,
-        authority_type: &[u8],
-        bump_seed: u8,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let ix = stake::instruction::delegate_stake(
-            stake_info.key,
-            authority_info.key,
-            vote_account_info.key,
-        );
-
-        invoke_signed(
-            &ix,
-            &[
-                stake_info,
-                vote_account_info,
-                clock_info,
-                stake_history_info,
-                stake_config_info,
-                authority_info,
-            ],
-            signers,
-        )
-    }
-
-    /// Issue a stake_deactivate instruction.
-    fn stake_deactivate<'a>(
-        stake_info: AccountInfo<'a>,
-        clock_info: AccountInfo<'a>,
-        authority_info: AccountInfo<'a>,
-        stake_pool: &Pubkey,
-        authority_type: &[u8],
-        bump_seed: u8,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let ix = stake::instruction::deactivate_stake(stake_info.key, authority_info.key);
-
-        invoke_signed(&ix, &[stake_info, clock_info, authority_info], signers)
-    }
-
-    /// Issue a stake_split instruction.
-    fn stake_split<'a>(
-        stake_pool: &Pubkey,
-        stake_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        amount: u64,
-        split_stake: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let split_instruction =
-            stake::instruction::split(stake_account.key, authority.key, amount, split_stake.key);
-
-        invoke_signed(
-            split_instruction
-                .last()
-                .ok_or(ProgramError::InvalidInstructionData)?,
-            &[stake_account, split_stake, authority],
-            signers,
-        )
-    }
-
-    /// Issue a stake_merge instruction.
-    #[allow(clippy::too_many_arguments)]
-    fn stake_merge<'a>(
-        stake_pool: &Pubkey,
-        source_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        destination_account: AccountInfo<'a>,
-        clock: AccountInfo<'a>,
-        stake_history: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let merge_instruction =
-            stake::instruction::merge(destination_account.key, source_account.key, authority.key);
-
-        invoke_signed(
-            &merge_instruction[0],
-            &[
-                destination_account,
-                source_account,
-                clock,
-                stake_history,
-                authority,
-            ],
-            signers,
-        )
-    }
-
-    /// Issue stake::instruction::authorize instructions to update both
-    /// authorities
-    fn stake_authorize<'a>(
-        stake_account: AccountInfo<'a>,
-        stake_authority: AccountInfo<'a>,
-        new_stake_authority: &Pubkey,
-        clock: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Staker,
-            None,
-        );
-
-        invoke(
-            &authorize_instruction,
-            &[
-                stake_account.clone(),
-                clock.clone(),
-                stake_authority.clone(),
-            ],
-        )?;
-
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Withdrawer,
-            None,
-        );
-
-        invoke(
-            &authorize_instruction,
-            &[stake_account, clock, stake_authority],
-        )
-    }
-
-    /// Issue stake::instruction::authorize instructions to update both
-    /// authorities
-    #[allow(clippy::too_many_arguments)]
-    fn stake_authorize_signed<'a>(
-        stake_pool: &Pubkey,
-        stake_account: AccountInfo<'a>,
-        stake_authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        new_stake_authority: &Pubkey,
-        clock: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Staker,
-            None,
-        );
-
-        invoke_signed(
-            &authorize_instruction,
-            &[
-                stake_account.clone(),
-                clock.clone(),
-                stake_authority.clone(),
-            ],
-            signers,
-        )?;
-
-        let authorize_instruction = stake::instruction::authorize(
-            stake_account.key,
-            stake_authority.key,
-            new_stake_authority,
-            stake::state::StakeAuthorize::Withdrawer,
-            None,
-        );
-        invoke_signed(
-            &authorize_instruction,
-            &[stake_account, clock, stake_authority],
-            signers,
-        )
-    }
-
-    /// Issue stake::instruction::withdraw instruction to move additional
-    /// lamports
-    #[allow(clippy::too_many_arguments)]
-    fn stake_withdraw<'a>(
-        stake_pool: &Pubkey,
-        source_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        destination_account: AccountInfo<'a>,
-        clock: AccountInfo<'a>,
-        stake_history: AccountInfo<'a>,
-        lamports: u64,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-        let custodian_pubkey = None;
-
-        let withdraw_instruction = stake::instruction::withdraw(
-            source_account.key,
-            authority.key,
-            destination_account.key,
-            lamports,
-            custodian_pubkey,
-        );
-
-        invoke_signed(
-            &withdraw_instruction,
-            &[
-                source_account,
-                destination_account,
-                clock,
-                stake_history,
-                authority,
-            ],
-            signers,
-        )
-    }
-
-    /// Issue stake::instruction::redelegate instruction to redelegate stake
-    #[allow(clippy::too_many_arguments)]
-    fn stake_redelegate<'a>(
-        stake_pool: &Pubkey,
-        source_account: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        destination_account: AccountInfo<'a>,
-        vote_account: AccountInfo<'a>,
-        stake_config: AccountInfo<'a>,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let redelegate_instruction = &stake::instruction::redelegate(
-            source_account.key,
-            authority.key,
-            vote_account.key,
-            destination_account.key,
-        )[2];
-
-        invoke_signed(
-            redelegate_instruction,
-            &[
-                source_account,
-                destination_account,
-                vote_account,
-                stake_config,
-                authority,
-            ],
-            signers,
-        )
-    }
-
-    /// Issue a spl_token `Burn` instruction.
-    #[allow(clippy::too_many_arguments)]
-    fn token_burn<'a>(
-        token_program: AccountInfo<'a>,
-        burn_account: AccountInfo<'a>,
-        mint: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        amount: u64,
-    ) -> Result<(), ProgramError> {
-        let ix = spl_token_2022::instruction::burn(
-            token_program.key,
-            burn_account.key,
-            mint.key,
-            authority.key,
-            &[],
-            amount,
-        )?;
-
-        invoke(&ix, &[burn_account, mint, authority])
-    }
-
-    /// Issue a spl_token `MintTo` instruction.
-    #[allow(clippy::too_many_arguments)]
-    fn token_mint_to<'a>(
-        stake_pool: &Pubkey,
-        token_program: AccountInfo<'a>,
-        mint: AccountInfo<'a>,
-        destination: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        authority_type: &[u8],
-        bump_seed: u8,
-        amount: u64,
-    ) -> Result<(), ProgramError> {
-        let authority_signature_seeds = [stake_pool.as_ref(), authority_type, &[bump_seed]];
-        let signers = &[&authority_signature_seeds[..]];
-
-        let ix = spl_token_2022::instruction::mint_to(
-            token_program.key,
-            mint.key,
-            destination.key,
-            authority.key,
-            &[],
-            amount,
-        )?;
-
-        invoke_signed(&ix, &[mint, destination, authority], signers)
-    }
-
-    /// Issue a spl_token `Transfer` instruction.
-    #[allow(clippy::too_many_arguments)]
-    fn token_transfer<'a>(
-        token_program: AccountInfo<'a>,
-        source: AccountInfo<'a>,
-        mint: AccountInfo<'a>,
-        destination: AccountInfo<'a>,
-        authority: AccountInfo<'a>,
-        amount: u64,
-        decimals: u8,
-    ) -> Result<(), ProgramError> {
-        let ix = spl_token_2022::instruction::transfer_checked(
-            token_program.key,
-            source.key,
-            mint.key,
-            destination.key,
-            authority.key,
-            &[],
-            amount,
-            decimals,
-        )?;
-        invoke(&ix, &[source, mint, destination, authority])
-    }
-
-    fn sol_transfer<'a>(
-        source: AccountInfo<'a>,
-        destination: AccountInfo<'a>,
-        amount: u64,
-    ) -> Result<(), ProgramError> {
-        let ix = solana_program::system_instruction::transfer(source.key, destination.key, amount);
-        invoke(&ix, &[source, destination])
-    }
-
-    /// Processes `Initialize` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_initialize(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        epoch_fee: Fee,
-        withdrawal_fee: Fee,
-        deposit_fee: Fee,
-        referral_fee: u8,
-        max_validators: u32,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-
-        let rent = Rent::get()?;
-
-        if !manager_info.is_signer {
-            msg!("Manager did not sign initialization");
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-
-        if stake_pool_info.key == validator_list_info.key {
-            msg!("Cannot use same account for stake pool and validator list");
-            return Err(StakePoolError::AlreadyInUse.into());
-        }
-
-        // This check is unnecessary since the runtime will check the ownership,
-        // but provides clarity that the parameter is in fact checked.
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_uninitialized() {
-            msg!("Provided stake pool already in use");
-            return Err(StakePoolError::AlreadyInUse.into());
-        }
-
-        // This check is unnecessary since the runtime will check the ownership,
-        // but provides clarity that the parameter is in fact checked.
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list =
-            try_from_slice_unchecked::<ValidatorList>(&validator_list_info.data.borrow())?;
-        if !validator_list.header.is_uninitialized() {
-            msg!("Provided validator list already in use");
-            return Err(StakePoolError::AlreadyInUse.into());
-        }
-
-        let data_length = validator_list_info.data_len();
-        let expected_max_validators = ValidatorList::calculate_max_validators(data_length);
-        if expected_max_validators != max_validators as usize || max_validators == 0 {
-            msg!(
-                "Incorrect validator list size provided, expected {}, provided {}",
-                expected_max_validators,
-                max_validators
-            );
-            return Err(StakePoolError::UnexpectedValidatorListAccountSize.into());
-        }
-        validator_list.header.account_type = AccountType::ValidatorList;
-        validator_list.header.max_validators = max_validators;
-        validator_list.validators.clear();
-
-        if !rent.is_exempt(stake_pool_info.lamports(), stake_pool_info.data_len()) {
-            msg!("Stake pool not rent-exempt");
-            return Err(ProgramError::AccountNotRentExempt);
-        }
-
-        if !rent.is_exempt(
-            validator_list_info.lamports(),
-            validator_list_info.data_len(),
-        ) {
-            msg!("Validator stake list not rent-exempt");
-            return Err(ProgramError::AccountNotRentExempt);
-        }
-
-        // Numerator should be smaller than or equal to denominator (fee <= 1)
-        if epoch_fee.numerator > epoch_fee.denominator
-            || withdrawal_fee.numerator > withdrawal_fee.denominator
-            || deposit_fee.numerator > deposit_fee.denominator
-            || referral_fee > 100u8
-        {
-            return Err(StakePoolError::FeeTooHigh.into());
-        }
-
-        check_spl_token_program_account(token_program_info.key)?;
-
-        if pool_mint_info.owner != token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-
-        stake_pool.token_program_id = *token_program_info.key;
-        stake_pool.pool_mint = *pool_mint_info.key;
-
-        let (stake_deposit_authority, sol_deposit_authority) =
-            match next_account_info(account_info_iter) {
-                Ok(deposit_authority_info) => (
-                    *deposit_authority_info.key,
-                    Some(*deposit_authority_info.key),
-                ),
-                Err(_) => (
-                    find_deposit_authority_program_address(program_id, stake_pool_info.key).0,
-                    None,
-                ),
-            };
-        let (withdraw_authority_key, stake_withdraw_bump_seed) =
-            crate::find_withdraw_authority_program_address(program_id, stake_pool_info.key);
-        if withdraw_authority_key != *withdraw_authority_info.key {
-            msg!(
-                "Incorrect withdraw authority provided, expected {}, received {}",
-                withdraw_authority_key,
-                withdraw_authority_info.key
-            );
-            return Err(StakePoolError::InvalidProgramAddress.into());
-        }
-
-        {
-            let pool_mint_data = pool_mint_info.try_borrow_data()?;
-            let pool_mint = StateWithExtensions::<Mint>::unpack(&pool_mint_data)?;
-
-            if pool_mint.base.supply != 0 {
-                return Err(StakePoolError::NonZeroPoolTokenSupply.into());
-            }
-
-            if pool_mint.base.decimals != native_mint::DECIMALS {
-                return Err(StakePoolError::IncorrectMintDecimals.into());
-            }
-
-            if !pool_mint
-                .base
-                .mint_authority
-                .contains(&withdraw_authority_key)
-            {
-                return Err(StakePoolError::WrongMintingAuthority.into());
-            }
-
-            if pool_mint.base.freeze_authority.is_some() {
-                return Err(StakePoolError::InvalidMintFreezeAuthority.into());
-            }
-
-            let extensions = pool_mint.get_extension_types()?;
-            if extensions
-                .iter()
-                .any(|x| !is_extension_supported_for_mint(x))
-            {
-                return Err(StakePoolError::UnsupportedMintExtension.into());
-            }
-        }
-        stake_pool.check_manager_fee_info(manager_fee_info)?;
-
-        if *reserve_stake_info.owner != stake::program::id() {
-            msg!("Reserve stake account not owned by stake program");
-            return Err(ProgramError::IncorrectProgramId);
-        }
-        let stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-            &reserve_stake_info.data.borrow(),
-        )?;
-        let total_lamports = if let stake::state::StakeStateV2::Initialized(meta) = stake_state {
-            if meta.lockup != stake::state::Lockup::default() {
-                msg!("Reserve stake account has some lockup");
-                return Err(StakePoolError::WrongStakeStake.into());
-            }
-
-            if meta.authorized.staker != withdraw_authority_key {
-                msg!(
-                    "Reserve stake account has incorrect staker {}, should be {}",
-                    meta.authorized.staker,
-                    withdraw_authority_key
-                );
-                return Err(StakePoolError::WrongStakeStake.into());
-            }
-
-            if meta.authorized.withdrawer != withdraw_authority_key {
-                msg!(
-                    "Reserve stake account has incorrect withdrawer {}, should be {}",
-                    meta.authorized.staker,
-                    withdraw_authority_key
-                );
-                return Err(StakePoolError::WrongStakeStake.into());
-            }
-            reserve_stake_info
-                .lamports()
-                .checked_sub(minimum_reserve_lamports(&meta))
-                .ok_or(StakePoolError::CalculationFailure)?
-        } else {
-            msg!("Reserve stake account not in intialized state");
-            return Err(StakePoolError::WrongStakeStake.into());
-        };
-
-        if total_lamports > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_withdraw_bump_seed,
-                total_lamports,
-            )?;
-        }
-
-        borsh::to_writer(
-            &mut validator_list_info.data.borrow_mut()[..],
-            &validator_list,
-        )?;
-
-        stake_pool.account_type = AccountType::StakePool;
-        stake_pool.manager = *manager_info.key;
-        stake_pool.staker = *staker_info.key;
-        stake_pool.stake_deposit_authority = stake_deposit_authority;
-        stake_pool.stake_withdraw_bump_seed = stake_withdraw_bump_seed;
-        stake_pool.validator_list = *validator_list_info.key;
-        stake_pool.reserve_stake = *reserve_stake_info.key;
-        stake_pool.manager_fee_account = *manager_fee_info.key;
-        stake_pool.total_lamports = total_lamports;
-        stake_pool.pool_token_supply = total_lamports;
-        stake_pool.last_update_epoch = Clock::get()?.epoch;
-        stake_pool.lockup = stake::state::Lockup::default();
-        stake_pool.epoch_fee = epoch_fee;
-        stake_pool.next_epoch_fee = FutureEpoch::None;
-        stake_pool.preferred_deposit_validator_vote_address = None;
-        stake_pool.preferred_withdraw_validator_vote_address = None;
-        stake_pool.stake_deposit_fee = deposit_fee;
-        stake_pool.stake_withdrawal_fee = withdrawal_fee;
-        stake_pool.next_stake_withdrawal_fee = FutureEpoch::None;
-        stake_pool.stake_referral_fee = referral_fee;
-        stake_pool.sol_deposit_authority = sol_deposit_authority;
-        stake_pool.sol_deposit_fee = deposit_fee;
-        stake_pool.sol_referral_fee = referral_fee;
-        stake_pool.sol_withdraw_authority = None;
-        stake_pool.sol_withdrawal_fee = withdrawal_fee;
-        stake_pool.next_sol_withdrawal_fee = FutureEpoch::None;
-        stake_pool.last_epoch_pool_token_supply = 0;
-        stake_pool.last_epoch_total_lamports = 0;
-
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)
-            .map_err(|e| e.into())
-    }
-
-    /// Processes `AddValidatorToPool` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_add_validator_to_pool(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        raw_validator_seed: u32,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let stake_info = next_account_info(account_info_iter)?;
-        let validator_vote_info = next_account_info(account_info_iter)?;
-        let rent_info = next_account_info(account_info_iter)?;
-        let rent = &Rent::from_account_info(rent_info)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_system_program(system_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-
-        stake_pool.check_staker(staker_info)?;
-        stake_pool.check_reserve_stake(reserve_stake_info)?;
-        stake_pool.check_validator_list(validator_list_info)?;
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        if header.max_validators == validator_list.len() {
-            return Err(ProgramError::AccountDataTooSmall);
-        }
-        let maybe_validator_stake_info = validator_list.find::<ValidatorStakeInfo, _>(|x| {
-            ValidatorStakeInfo::memcmp_pubkey(x, validator_vote_info.key)
-        });
-        if maybe_validator_stake_info.is_some() {
-            return Err(StakePoolError::ValidatorAlreadyAdded.into());
-        }
-
-        let validator_seed = NonZeroU32::new(raw_validator_seed);
-        let (stake_address, bump_seed) = crate::find_stake_program_address(
-            program_id,
-            validator_vote_info.key,
-            stake_pool_info.key,
-            validator_seed,
-        );
-        if stake_address != *stake_info.key {
-            return Err(StakePoolError::InvalidStakeAccountAddress.into());
-        }
-
-        let validator_seed_bytes = validator_seed.map(|s| s.get().to_le_bytes());
-        let stake_account_signer_seeds: &[&[_]] = &[
-            validator_vote_info.key.as_ref(),
-            stake_pool_info.key.as_ref(),
-            validator_seed_bytes
-                .as_ref()
-                .map(|s| s.as_slice())
-                .unwrap_or(&[]),
-            &[bump_seed],
-        ];
-
-        // Fund the stake account with the minimum + rent-exempt balance
-        let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-        let stake_minimum_delegation = stake::tools::get_minimum_delegation()?;
-        let required_lamports = minimum_delegation(stake_minimum_delegation)
-            .saturating_add(rent.minimum_balance(stake_space));
-
-        // Check that we're not draining the reserve totally
-        let reserve_stake = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-            &reserve_stake_info.data.borrow(),
-        )?;
-        let reserve_meta = reserve_stake
-            .meta()
-            .ok_or(StakePoolError::WrongStakeStake)?;
-        let minimum_lamports = minimum_reserve_lamports(&reserve_meta);
-        let reserve_lamports = reserve_stake_info.lamports();
-        if reserve_lamports.saturating_sub(required_lamports) < minimum_lamports {
-            msg!(
-                "Need to add {} lamports for the reserve stake to be rent-exempt after adding a validator, reserve currently has {} lamports",
-                required_lamports.saturating_add(minimum_lamports).saturating_sub(reserve_lamports),
-                reserve_lamports
-            );
-            return Err(ProgramError::InsufficientFunds);
-        }
-
-        // Create new stake account
-        create_stake_account(stake_info.clone(), stake_account_signer_seeds, stake_space)?;
-        // split into validator stake account
-        Self::stake_split(
-            stake_pool_info.key,
-            reserve_stake_info.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            required_lamports,
-            stake_info.clone(),
-        )?;
-
-        Self::stake_delegate(
-            stake_info.clone(),
-            validator_vote_info.clone(),
-            clock_info.clone(),
-            stake_history_info.clone(),
-            stake_config_info.clone(),
-            withdraw_authority_info.clone(),
-            stake_pool_info.key,
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-        )?;
-
-        validator_list.push(ValidatorStakeInfo {
-            status: StakeStatus::Active.into(),
-            vote_account_address: *validator_vote_info.key,
-            active_stake_lamports: required_lamports.into(),
-            transient_stake_lamports: 0.into(),
-            last_update_epoch: clock.epoch.into(),
-            transient_seed_suffix: 0.into(),
-            unused: 0.into(),
-            validator_seed_suffix: raw_validator_seed.into(),
-        })?;
-
-        Ok(())
-    }
-
-    /// Processes `RemoveValidatorFromPool` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_remove_validator_from_pool(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let stake_account_info = next_account_info(account_info_iter)?;
-        let transient_stake_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_stake_program(stake_program_info.key)?;
-        check_account_owner(stake_pool_info, program_id)?;
-
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_staker(staker_info)?;
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            msg!(
-                "clock {} pool {}",
-                clock.epoch,
-                stake_pool.last_update_epoch
-            );
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        stake_pool.check_validator_list(validator_list_info)?;
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let (_, stake) = get_stake_state(stake_account_info)?;
-        let vote_account_address = stake.delegation.voter_pubkey;
-        let maybe_validator_stake_info = validator_list.find_mut::<ValidatorStakeInfo, _>(|x| {
-            ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-        });
-        if maybe_validator_stake_info.is_none() {
-            msg!(
-                "Vote account {} not found in stake pool",
-                vote_account_address
-            );
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-        let validator_stake_info = maybe_validator_stake_info.unwrap();
-        check_validator_stake_address(
-            program_id,
-            stake_pool_info.key,
-            stake_account_info.key,
-            &vote_account_address,
-            NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-        )?;
-
-        if validator_stake_info.status != StakeStatus::Active.into() {
-            msg!("Validator is already marked for removal");
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-
-        let new_status = if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-            check_transient_stake_address(
-                program_id,
-                stake_pool_info.key,
-                transient_stake_account_info.key,
-                &vote_account_address,
-                validator_stake_info.transient_seed_suffix.into(),
-            )?;
-
-            match get_stake_state(transient_stake_account_info) {
-                Ok((meta, stake))
-                    if stake_is_usable_by_pool(
-                        &meta,
-                        withdraw_authority_info.key,
-                        &stake_pool.lockup,
-                    ) =>
-                {
-                    if stake.delegation.deactivation_epoch == Epoch::MAX {
-                        Self::stake_deactivate(
-                            transient_stake_account_info.clone(),
-                            clock_info.clone(),
-                            withdraw_authority_info.clone(),
-                            stake_pool_info.key,
-                            AUTHORITY_WITHDRAW,
-                            stake_pool.stake_withdraw_bump_seed,
-                        )?;
-                    }
-                    StakeStatus::DeactivatingAll
-                }
-                _ => StakeStatus::DeactivatingValidator,
-            }
-        } else {
-            StakeStatus::DeactivatingValidator
-        };
-
-        // If the stake was force-deactivated through deactivate-delinquent or
-        // some other means, we *do not* need to deactivate it again
-        if stake.delegation.deactivation_epoch == Epoch::MAX {
-            Self::stake_deactivate(
-                stake_account_info.clone(),
-                clock_info.clone(),
-                withdraw_authority_info.clone(),
-                stake_pool_info.key,
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-            )?;
-        }
-
-        validator_stake_info.status = new_status.into();
-
-        if stake_pool.preferred_deposit_validator_vote_address == Some(vote_account_address) {
-            stake_pool.preferred_deposit_validator_vote_address = None;
-        }
-        if stake_pool.preferred_withdraw_validator_vote_address == Some(vote_account_address) {
-            stake_pool.preferred_withdraw_validator_vote_address = None;
-        }
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        Ok(())
-    }
-
-    /// Processes `DecreaseValidatorStake` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_decrease_validator_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        lamports: u64,
-        transient_stake_seed: u64,
-        maybe_ephemeral_stake_seed: Option<u64>,
-        fund_rent_exempt_reserve: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let maybe_reserve_stake_info = fund_rent_exempt_reserve
-            .then(|| next_account_info(account_info_iter))
-            .transpose()?;
-        let validator_stake_account_info = next_account_info(account_info_iter)?;
-        let maybe_ephemeral_stake_account_info = maybe_ephemeral_stake_seed
-            .map(|_| next_account_info(account_info_iter))
-            .transpose()?;
-        let transient_stake_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let (rent, maybe_stake_history_info) =
-            if maybe_ephemeral_stake_seed.is_some() || fund_rent_exempt_reserve {
-                (Rent::get()?, Some(next_account_info(account_info_iter)?))
-            } else {
-                // legacy instruction takes the rent account
-                let rent_info = next_account_info(account_info_iter)?;
-                (Rent::from_account_info(rent_info)?, None)
-            };
-        let system_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_system_program(system_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-        check_account_owner(stake_pool_info, program_id)?;
-
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            msg!("Expected valid stake pool");
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_staker(staker_info)?;
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        stake_pool.check_validator_list(validator_list_info)?;
-        check_account_owner(validator_list_info, program_id)?;
-        let validator_list_data = &mut *validator_list_info.data.borrow_mut();
-        let (validator_list_header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(validator_list_data)?;
-        if !validator_list_header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        if let Some(reserve_stake_info) = maybe_reserve_stake_info {
-            stake_pool.check_reserve_stake(reserve_stake_info)?;
-        }
-
-        let (meta, stake) = get_stake_state(validator_stake_account_info)?;
-        let vote_account_address = stake.delegation.voter_pubkey;
-
-        let maybe_validator_stake_info = validator_list.find_mut::<ValidatorStakeInfo, _>(|x| {
-            ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-        });
-        if maybe_validator_stake_info.is_none() {
-            msg!(
-                "Vote account {} not found in stake pool",
-                vote_account_address
-            );
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-        let validator_stake_info = maybe_validator_stake_info.unwrap();
-        check_validator_stake_address(
-            program_id,
-            stake_pool_info.key,
-            validator_stake_account_info.key,
-            &vote_account_address,
-            NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-        )?;
-        if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-            if maybe_ephemeral_stake_seed.is_none() {
-                msg!("Attempting to decrease stake on a validator with pending transient stake, use DecreaseAdditionalValidatorStake with the existing seed");
-                return Err(StakePoolError::TransientAccountInUse.into());
-            }
-            if transient_stake_seed != u64::from(validator_stake_info.transient_seed_suffix) {
-                msg!(
-                    "Transient stake already exists with seed {}, you must use that one",
-                    u64::from(validator_stake_info.transient_seed_suffix)
-                );
-                return Err(ProgramError::InvalidSeeds);
-            }
-            check_if_stake_deactivating(
-                transient_stake_account_info,
-                &vote_account_address,
-                clock.epoch,
-            )?;
-        }
-
-        let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-        let stake_rent = rent.minimum_balance(stake_space);
-
-        let stake_minimum_delegation = stake::tools::get_minimum_delegation()?;
-        let current_minimum_lamports = minimum_delegation(stake_minimum_delegation);
-        if lamports < current_minimum_lamports {
-            msg!(
-                "Need at least {} lamports for transient stake to meet minimum delegation and rent-exempt requirements, {} provided",
-                current_minimum_lamports,
-                lamports
-            );
-            return Err(ProgramError::AccountNotRentExempt);
-        }
-
-        let remaining_lamports = validator_stake_account_info
-            .lamports()
-            .checked_sub(lamports)
-            .ok_or(ProgramError::InsufficientFunds)?;
-        let required_lamports = minimum_stake_lamports(&meta, stake_minimum_delegation);
-        if remaining_lamports < required_lamports {
-            msg!("Need at least {} lamports in the stake account after decrease, {} requested, {} is the current possible maximum",
-                required_lamports,
-                lamports,
-                validator_stake_account_info.lamports().checked_sub(required_lamports).ok_or(StakePoolError::CalculationFailure)?
-            );
-            return Err(ProgramError::InsufficientFunds);
-        }
-
-        let (source_stake_account_info, split_lamports) =
-            if let Some((ephemeral_stake_seed, ephemeral_stake_account_info)) =
-                maybe_ephemeral_stake_seed.zip(maybe_ephemeral_stake_account_info)
-            {
-                let ephemeral_stake_bump_seed = check_ephemeral_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    ephemeral_stake_account_info.key,
-                    ephemeral_stake_seed,
-                )?;
-                let ephemeral_stake_account_signer_seeds: &[&[_]] = &[
-                    EPHEMERAL_STAKE_SEED_PREFIX,
-                    stake_pool_info.key.as_ref(),
-                    &ephemeral_stake_seed.to_le_bytes(),
-                    &[ephemeral_stake_bump_seed],
-                ];
-                create_stake_account(
-                    ephemeral_stake_account_info.clone(),
-                    ephemeral_stake_account_signer_seeds,
-                    stake_space,
-                )?;
-
-                // if needed, withdraw rent-exempt reserve for ephemeral account
-                if let Some(reserve_stake_info) = maybe_reserve_stake_info {
-                    let required_lamports_for_rent_exemption =
-                        stake_rent.saturating_sub(ephemeral_stake_account_info.lamports());
-                    if required_lamports_for_rent_exemption > 0 {
-                        if required_lamports_for_rent_exemption >= reserve_stake_info.lamports() {
-                            return Err(StakePoolError::ReserveDepleted.into());
-                        }
-                        let stake_history_info = maybe_stake_history_info
-                            .ok_or(StakePoolError::MissingRequiredSysvar)?;
-                        Self::stake_withdraw(
-                            stake_pool_info.key,
-                            reserve_stake_info.clone(),
-                            withdraw_authority_info.clone(),
-                            AUTHORITY_WITHDRAW,
-                            stake_pool.stake_withdraw_bump_seed,
-                            ephemeral_stake_account_info.clone(),
-                            clock_info.clone(),
-                            stake_history_info.clone(),
-                            required_lamports_for_rent_exemption,
-                        )?;
-                    }
-                }
-
-                // split into ephemeral stake account
-                Self::stake_split(
-                    stake_pool_info.key,
-                    validator_stake_account_info.clone(),
-                    withdraw_authority_info.clone(),
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                    lamports,
-                    ephemeral_stake_account_info.clone(),
-                )?;
-
-                Self::stake_deactivate(
-                    ephemeral_stake_account_info.clone(),
-                    clock_info.clone(),
-                    withdraw_authority_info.clone(),
-                    stake_pool_info.key,
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                )?;
-
-                (
-                    ephemeral_stake_account_info,
-                    ephemeral_stake_account_info.lamports(),
-                )
-            } else {
-                // if no ephemeral account is provided, split everything from the
-                // validator stake account, into the transient stake account
-                (validator_stake_account_info, lamports)
-            };
-
-        let transient_stake_bump_seed = check_transient_stake_address(
-            program_id,
-            stake_pool_info.key,
-            transient_stake_account_info.key,
-            &vote_account_address,
-            transient_stake_seed,
-        )?;
-
-        if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-            let stake_history_info = maybe_stake_history_info.unwrap();
-            // transient stake exists, try to merge from the source account,
-            // which is always an ephemeral account
-            Self::stake_merge(
-                stake_pool_info.key,
-                source_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                transient_stake_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-            )?;
-        } else {
-            let transient_stake_account_signer_seeds: &[&[_]] = &[
-                TRANSIENT_STAKE_SEED_PREFIX,
-                vote_account_address.as_ref(),
-                stake_pool_info.key.as_ref(),
-                &transient_stake_seed.to_le_bytes(),
-                &[transient_stake_bump_seed],
-            ];
-
-            create_stake_account(
-                transient_stake_account_info.clone(),
-                transient_stake_account_signer_seeds,
-                stake_space,
-            )?;
-
-            // if needed, withdraw rent-exempt reserve for transient account
-            if let Some(reserve_stake_info) = maybe_reserve_stake_info {
-                let required_lamports =
-                    stake_rent.saturating_sub(transient_stake_account_info.lamports());
-                // in the case of doing a full split from an ephemeral account,
-                // the rent-exempt reserve moves over, so no need to fund it from
-                // the pool reserve
-                if source_stake_account_info.lamports() != split_lamports {
-                    let stake_history_info =
-                        maybe_stake_history_info.ok_or(StakePoolError::MissingRequiredSysvar)?;
-                    if required_lamports >= reserve_stake_info.lamports() {
-                        return Err(StakePoolError::ReserveDepleted.into());
-                    }
-                    if required_lamports > 0 {
-                        Self::stake_withdraw(
-                            stake_pool_info.key,
-                            reserve_stake_info.clone(),
-                            withdraw_authority_info.clone(),
-                            AUTHORITY_WITHDRAW,
-                            stake_pool.stake_withdraw_bump_seed,
-                            transient_stake_account_info.clone(),
-                            clock_info.clone(),
-                            stake_history_info.clone(),
-                            required_lamports,
-                        )?;
-                    }
-                }
-            }
-
-            // split into transient stake account
-            Self::stake_split(
-                stake_pool_info.key,
-                source_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                split_lamports,
-                transient_stake_account_info.clone(),
-            )?;
-
-            // Deactivate transient stake if necessary
-            let (_, stake) = get_stake_state(transient_stake_account_info)?;
-            if stake.delegation.deactivation_epoch == Epoch::MAX {
-                Self::stake_deactivate(
-                    transient_stake_account_info.clone(),
-                    clock_info.clone(),
-                    withdraw_authority_info.clone(),
-                    stake_pool_info.key,
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                )?;
-            }
-        }
-
-        validator_stake_info.active_stake_lamports =
-            u64::from(validator_stake_info.active_stake_lamports)
-                .checked_sub(lamports)
-                .ok_or(StakePoolError::CalculationFailure)?
-                .into();
-        validator_stake_info.transient_stake_lamports =
-            transient_stake_account_info.lamports().into();
-        validator_stake_info.transient_seed_suffix = transient_stake_seed.into();
-
-        Ok(())
-    }
-
-    /// Processes `IncreaseValidatorStake` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_increase_validator_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        lamports: u64,
-        transient_stake_seed: u64,
-        maybe_ephemeral_stake_seed: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let reserve_stake_account_info = next_account_info(account_info_iter)?;
-        let maybe_ephemeral_stake_account_info = maybe_ephemeral_stake_seed
-            .map(|_| next_account_info(account_info_iter))
-            .transpose()?;
-        let transient_stake_account_info = next_account_info(account_info_iter)?;
-        let validator_stake_account_info = next_account_info(account_info_iter)?;
-        let validator_vote_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let rent = if maybe_ephemeral_stake_seed.is_some() {
-            // instruction with ephemeral account doesn't take the rent account
-            Rent::get()?
-        } else {
-            // legacy instruction takes the rent account
-            let rent_info = next_account_info(account_info_iter)?;
-            Rent::from_account_info(rent_info)?
-        };
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_system_program(system_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-        check_account_owner(stake_pool_info, program_id)?;
-
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            msg!("Expected valid stake pool");
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_staker(staker_info)?;
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        stake_pool.check_validator_list(validator_list_info)?;
-        stake_pool.check_reserve_stake(reserve_stake_account_info)?;
-        check_account_owner(validator_list_info, program_id)?;
-
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let vote_account_address = validator_vote_account_info.key;
-
-        let maybe_validator_stake_info = validator_list.find_mut::<ValidatorStakeInfo, _>(|x| {
-            ValidatorStakeInfo::memcmp_pubkey(x, vote_account_address)
-        });
-        if maybe_validator_stake_info.is_none() {
-            msg!(
-                "Vote account {} not found in stake pool",
-                vote_account_address
-            );
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-        let validator_stake_info = maybe_validator_stake_info.unwrap();
-        if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-            if maybe_ephemeral_stake_seed.is_none() {
-                msg!("Attempting to increase stake on a validator with pending transient stake, use IncreaseAdditionalValidatorStake with the existing seed");
-                return Err(StakePoolError::TransientAccountInUse.into());
-            }
-            if transient_stake_seed != u64::from(validator_stake_info.transient_seed_suffix) {
-                msg!(
-                    "Transient stake already exists with seed {}, you must use that one",
-                    u64::from(validator_stake_info.transient_seed_suffix)
-                );
-                return Err(ProgramError::InvalidSeeds);
-            }
-            check_if_stake_activating(
-                transient_stake_account_info,
-                vote_account_address,
-                clock.epoch,
-            )?;
-        }
-
-        check_validator_stake_account(
-            validator_stake_account_info,
-            program_id,
-            stake_pool_info.key,
-            withdraw_authority_info.key,
-            vote_account_address,
-            validator_stake_info.validator_seed_suffix.into(),
-            &stake_pool.lockup,
-        )?;
-
-        if validator_stake_info.status != StakeStatus::Active.into() {
-            msg!("Validator is marked for removal and no longer allows increases");
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-
-        let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-        let stake_rent = rent.minimum_balance(stake_space);
-        let stake_minimum_delegation = stake::tools::get_minimum_delegation()?;
-        let current_minimum_delegation = minimum_delegation(stake_minimum_delegation);
-        if lamports < current_minimum_delegation {
-            msg!(
-                "Need more than {} lamports for transient stake to meet minimum delegation requirement, {} provided",
-                current_minimum_delegation,
-                lamports
-            );
-            return Err(ProgramError::Custom(
-                stake::instruction::StakeError::InsufficientDelegation as u32,
-            ));
-        }
-
-        // the stake account rent exemption is withdrawn after the merge, so
-        // to add `lamports` to a validator, we need to create a stake account
-        // with `lamports + stake_rent`
-        let total_lamports = lamports.saturating_add(stake_rent);
-
-        if reserve_stake_account_info
-            .lamports()
-            .saturating_sub(total_lamports)
-            < stake_rent
-        {
-            let max_split_amount = reserve_stake_account_info
-                .lamports()
-                .saturating_sub(stake_rent.saturating_mul(2));
-            msg!(
-                "Reserve stake does not have enough lamports for increase, maximum amount {}, {} requested",
-                max_split_amount,
-                lamports
-            );
-            return Err(ProgramError::InsufficientFunds);
-        }
-
-        let source_stake_account_info =
-            if let Some((ephemeral_stake_seed, ephemeral_stake_account_info)) =
-                maybe_ephemeral_stake_seed.zip(maybe_ephemeral_stake_account_info)
-            {
-                let ephemeral_stake_bump_seed = check_ephemeral_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    ephemeral_stake_account_info.key,
-                    ephemeral_stake_seed,
-                )?;
-                let ephemeral_stake_account_signer_seeds: &[&[_]] = &[
-                    EPHEMERAL_STAKE_SEED_PREFIX,
-                    stake_pool_info.key.as_ref(),
-                    &ephemeral_stake_seed.to_le_bytes(),
-                    &[ephemeral_stake_bump_seed],
-                ];
-                create_stake_account(
-                    ephemeral_stake_account_info.clone(),
-                    ephemeral_stake_account_signer_seeds,
-                    stake_space,
-                )?;
-
-                // split into ephemeral stake account
-                Self::stake_split(
-                    stake_pool_info.key,
-                    reserve_stake_account_info.clone(),
-                    withdraw_authority_info.clone(),
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                    total_lamports,
-                    ephemeral_stake_account_info.clone(),
-                )?;
-
-                // activate stake to validator
-                Self::stake_delegate(
-                    ephemeral_stake_account_info.clone(),
-                    validator_vote_account_info.clone(),
-                    clock_info.clone(),
-                    stake_history_info.clone(),
-                    stake_config_info.clone(),
-                    withdraw_authority_info.clone(),
-                    stake_pool_info.key,
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                )?;
-                ephemeral_stake_account_info
-            } else {
-                // if no ephemeral account is provided, split everything from the
-                // reserve account, into the transient stake account
-                reserve_stake_account_info
-            };
-
-        let transient_stake_bump_seed = check_transient_stake_address(
-            program_id,
-            stake_pool_info.key,
-            transient_stake_account_info.key,
-            vote_account_address,
-            transient_stake_seed,
-        )?;
-
-        if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-            // transient stake exists, try to merge from the source account,
-            // which is always an ephemeral account
-            Self::stake_merge(
-                stake_pool_info.key,
-                source_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                transient_stake_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-            )?;
-        } else {
-            // no transient stake, split
-            let transient_stake_account_signer_seeds: &[&[_]] = &[
-                TRANSIENT_STAKE_SEED_PREFIX,
-                vote_account_address.as_ref(),
-                stake_pool_info.key.as_ref(),
-                &transient_stake_seed.to_le_bytes(),
-                &[transient_stake_bump_seed],
-            ];
-
-            create_stake_account(
-                transient_stake_account_info.clone(),
-                transient_stake_account_signer_seeds,
-                stake_space,
-            )?;
-
-            // split into transient stake account
-            Self::stake_split(
-                stake_pool_info.key,
-                source_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                total_lamports,
-                transient_stake_account_info.clone(),
-            )?;
-
-            // Activate transient stake to validator if necessary
-            let stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-                &transient_stake_account_info.data.borrow(),
-            )?;
-            match stake_state {
-                // if it was delegated on or before this epoch, we're good
-                stake::state::StakeStateV2::Stake(_, stake, _)
-                    if stake.delegation.activation_epoch <= clock.epoch => {}
-                // all other situations, delegate!
-                _ => {
-                    Self::stake_delegate(
-                        transient_stake_account_info.clone(),
-                        validator_vote_account_info.clone(),
-                        clock_info.clone(),
-                        stake_history_info.clone(),
-                        stake_config_info.clone(),
-                        withdraw_authority_info.clone(),
-                        stake_pool_info.key,
-                        AUTHORITY_WITHDRAW,
-                        stake_pool.stake_withdraw_bump_seed,
-                    )?;
-                }
-            }
-        }
-
-        validator_stake_info.transient_stake_lamports =
-            u64::from(validator_stake_info.transient_stake_lamports)
-                .checked_add(total_lamports)
-                .ok_or(StakePoolError::CalculationFailure)?
-                .into();
-        validator_stake_info.transient_seed_suffix = transient_stake_seed.into();
-
-        Ok(())
-    }
-
-    /// Processes `Redelegate` instruction.
-    #[inline(never)] // needed due to stack size violation
-    fn process_redelegate(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        lamports: u64,
-        source_transient_stake_seed: u64,
-        ephemeral_stake_seed: u64,
-        destination_transient_stake_seed: u64,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let source_validator_stake_account_info = next_account_info(account_info_iter)?;
-        let source_transient_stake_account_info = next_account_info(account_info_iter)?;
-        let ephemeral_stake_account_info = next_account_info(account_info_iter)?;
-        let destination_transient_stake_account_info = next_account_info(account_info_iter)?;
-        let destination_validator_stake_account_info = next_account_info(account_info_iter)?;
-        let validator_vote_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_system_program(system_program_info.key)?;
-        check_stake_program(stake_program_info.key)?;
-        check_account_owner(stake_pool_info, program_id)?;
-
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            msg!("Expected valid stake pool");
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_staker(staker_info)?;
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        stake_pool.check_validator_list(validator_list_info)?;
-        check_account_owner(validator_list_info, program_id)?;
-        stake_pool.check_reserve_stake(reserve_stake_info)?;
-
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let rent = Rent::get()?;
-        let stake_space = std::mem::size_of::<stake::state::StakeStateV2>();
-        let stake_rent = rent.minimum_balance(stake_space);
-        let stake_minimum_delegation = stake::tools::get_minimum_delegation()?;
-        let current_minimum_delegation = minimum_delegation(stake_minimum_delegation);
-
-        // check that we're redelegating enough
-        {
-            // redelegation requires that the source account maintains rent exemption and
-            // that the destination account has rent-exemption and minimum
-            // delegation
-            let minimum_redelegation_lamports =
-                current_minimum_delegation.saturating_add(stake_rent);
-            if lamports < minimum_redelegation_lamports {
-                msg!(
-                    "Need more than {} lamports for redelegated stake and transient stake to meet minimum delegation requirement, {} provided",
-                    minimum_redelegation_lamports,
-                    lamports
-                );
-                return Err(ProgramError::Custom(
-                    stake::instruction::StakeError::InsufficientDelegation as u32,
-                ));
-            }
-
-            // check that we're not draining the source account
-            let current_minimum_lamports = stake_rent.saturating_add(current_minimum_delegation);
-            if source_validator_stake_account_info
-                .lamports()
-                .saturating_sub(lamports)
-                < current_minimum_lamports
-            {
-                let max_split_amount = source_validator_stake_account_info
-                    .lamports()
-                    .saturating_sub(current_minimum_lamports);
-                msg!(
-                    "Source stake does not have {} lamports for redelegation, must be {} at most",
-                    lamports,
-                    max_split_amount,
-                );
-                return Err(ProgramError::InsufficientFunds);
-            }
-        }
-
-        // check source account state
-        let (_, stake) = get_stake_state(source_validator_stake_account_info)?;
-        let vote_account_address = stake.delegation.voter_pubkey;
-        {
-            let maybe_validator_stake_info =
-                validator_list.find_mut::<ValidatorStakeInfo, _>(|x| {
-                    ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-                });
-            if maybe_validator_stake_info.is_none() {
-                msg!(
-                    "Source vote account {} not found in stake pool",
-                    vote_account_address
-                );
-                return Err(StakePoolError::ValidatorNotFound.into());
-            }
-            let validator_stake_info = maybe_validator_stake_info.unwrap();
-            check_validator_stake_address(
-                program_id,
-                stake_pool_info.key,
-                source_validator_stake_account_info.key,
-                &vote_account_address,
-                NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-            )?;
-            if u64::from(validator_stake_info.transient_stake_lamports) > 0 {
-                return Err(StakePoolError::TransientAccountInUse.into());
-            }
-            if validator_stake_info.status != StakeStatus::Active.into() {
-                msg!("Validator is marked for removal and no longer allows redelegation");
-                return Err(StakePoolError::ValidatorNotFound.into());
-            }
-            validator_stake_info.active_stake_lamports =
-                u64::from(validator_stake_info.active_stake_lamports)
-                    .checked_sub(lamports)
-                    .ok_or(StakePoolError::CalculationFailure)?
-                    .into();
-            validator_stake_info.transient_stake_lamports = stake_rent.into();
-            validator_stake_info.transient_seed_suffix = source_transient_stake_seed.into();
-        }
-
-        // split from source, into source transient
-        {
-            // check transient account
-            let source_transient_stake_bump_seed = check_transient_stake_address(
-                program_id,
-                stake_pool_info.key,
-                source_transient_stake_account_info.key,
-                &vote_account_address,
-                source_transient_stake_seed,
-            )?;
-            let source_transient_stake_account_signer_seeds: &[&[_]] = &[
-                TRANSIENT_STAKE_SEED_PREFIX,
-                vote_account_address.as_ref(),
-                stake_pool_info.key.as_ref(),
-                &source_transient_stake_seed.to_le_bytes(),
-                &[source_transient_stake_bump_seed],
-            ];
-
-            create_stake_account(
-                source_transient_stake_account_info.clone(),
-                source_transient_stake_account_signer_seeds,
-                stake_space,
-            )?;
-
-            // if needed, pre-fund the rent-exempt reserve from the reserve stake
-            let required_lamports_for_rent_exemption =
-                stake_rent.saturating_sub(source_transient_stake_account_info.lamports());
-            if required_lamports_for_rent_exemption > 0 {
-                if required_lamports_for_rent_exemption >= reserve_stake_info.lamports() {
-                    return Err(StakePoolError::ReserveDepleted.into());
-                }
-                Self::stake_withdraw(
-                    stake_pool_info.key,
-                    reserve_stake_info.clone(),
-                    withdraw_authority_info.clone(),
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                    source_transient_stake_account_info.clone(),
-                    clock_info.clone(),
-                    stake_history_info.clone(),
-                    required_lamports_for_rent_exemption,
-                )?;
-            }
-            Self::stake_split(
-                stake_pool_info.key,
-                source_validator_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                lamports,
-                source_transient_stake_account_info.clone(),
-            )?;
-        }
-
-        // redelegate from source transient to ephemeral
-        {
-            let ephemeral_stake_bump_seed = check_ephemeral_stake_address(
-                program_id,
-                stake_pool_info.key,
-                ephemeral_stake_account_info.key,
-                ephemeral_stake_seed,
-            )?;
-            let ephemeral_stake_account_signer_seeds: &[&[_]] = &[
-                EPHEMERAL_STAKE_SEED_PREFIX,
-                stake_pool_info.key.as_ref(),
-                &ephemeral_stake_seed.to_le_bytes(),
-                &[ephemeral_stake_bump_seed],
-            ];
-            create_stake_account(
-                ephemeral_stake_account_info.clone(),
-                ephemeral_stake_account_signer_seeds,
-                stake_space,
-            )?;
-            Self::stake_redelegate(
-                stake_pool_info.key,
-                source_transient_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                ephemeral_stake_account_info.clone(),
-                validator_vote_account_info.clone(),
-                stake_config_info.clone(),
-            )?;
-        }
-
-        {
-            // check destination stake and transient stake accounts
-            let vote_account_address = validator_vote_account_info.key;
-            let maybe_validator_stake_info =
-                validator_list.find_mut::<ValidatorStakeInfo, _>(|x| {
-                    ValidatorStakeInfo::memcmp_pubkey(x, vote_account_address)
-                });
-            if maybe_validator_stake_info.is_none() {
-                msg!(
-                    "Destination vote account {} not found in stake pool",
-                    vote_account_address
-                );
-                return Err(StakePoolError::ValidatorNotFound.into());
-            }
-            let validator_stake_info = maybe_validator_stake_info.unwrap();
-            check_validator_stake_account(
-                destination_validator_stake_account_info,
-                program_id,
-                stake_pool_info.key,
-                withdraw_authority_info.key,
-                vote_account_address,
-                validator_stake_info.validator_seed_suffix.into(),
-                &stake_pool.lockup,
-            )?;
-            if validator_stake_info.status != StakeStatus::Active.into() {
-                msg!(
-                    "Destination validator is marked for removal and no longer allows redelegation"
-                );
-                return Err(StakePoolError::ValidatorNotFound.into());
-            }
-            let transient_account_exists =
-                u64::from(validator_stake_info.transient_stake_lamports) > 0;
-            validator_stake_info.transient_stake_lamports =
-                u64::from(validator_stake_info.transient_stake_lamports)
-                    .checked_add(lamports)
-                    .ok_or(StakePoolError::CalculationFailure)?
-                    .into();
-
-            if transient_account_exists {
-                // if transient stake exists, make sure it's the right one and that it's
-                // usable by the pool
-                if u64::from(validator_stake_info.transient_seed_suffix)
-                    != destination_transient_stake_seed
-                {
-                    msg!("Provided seed {} does not match current seed {} for transient stake account",
-                        destination_transient_stake_seed,
-                        u64::from(validator_stake_info.transient_seed_suffix)
-                    );
-                    return Err(StakePoolError::InvalidStakeAccountAddress.into());
-                }
-                check_transient_stake_account(
-                    destination_transient_stake_account_info,
-                    program_id,
-                    stake_pool_info.key,
-                    withdraw_authority_info.key,
-                    vote_account_address,
-                    destination_transient_stake_seed,
-                    &stake_pool.lockup,
-                )?;
-                check_if_stake_activating(
-                    destination_transient_stake_account_info,
-                    vote_account_address,
-                    clock.epoch,
-                )?;
-                Self::stake_merge(
-                    stake_pool_info.key,
-                    ephemeral_stake_account_info.clone(),
-                    withdraw_authority_info.clone(),
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                    destination_transient_stake_account_info.clone(),
-                    clock_info.clone(),
-                    stake_history_info.clone(),
-                )?;
-            } else {
-                // otherwise, create the new account and split into it
-                let destination_transient_stake_bump_seed = check_transient_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    destination_transient_stake_account_info.key,
-                    vote_account_address,
-                    destination_transient_stake_seed,
-                )?;
-                let destination_transient_stake_account_signer_seeds: &[&[_]] = &[
-                    TRANSIENT_STAKE_SEED_PREFIX,
-                    vote_account_address.as_ref(),
-                    stake_pool_info.key.as_ref(),
-                    &destination_transient_stake_seed.to_le_bytes(),
-                    &[destination_transient_stake_bump_seed],
-                ];
-                create_stake_account(
-                    destination_transient_stake_account_info.clone(),
-                    destination_transient_stake_account_signer_seeds,
-                    stake_space,
-                )?;
-                Self::stake_split(
-                    stake_pool_info.key,
-                    ephemeral_stake_account_info.clone(),
-                    withdraw_authority_info.clone(),
-                    AUTHORITY_WITHDRAW,
-                    stake_pool.stake_withdraw_bump_seed,
-                    lamports,
-                    destination_transient_stake_account_info.clone(),
-                )?;
-                validator_stake_info.transient_seed_suffix =
-                    destination_transient_stake_seed.into();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Process `SetPreferredValidator` instruction
-    #[inline(never)] // needed due to stack size violation
-    fn process_set_preferred_validator(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        validator_type: PreferredValidatorType,
-        vote_account_address: Option<Pubkey>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let staker_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        check_account_owner(validator_list_info, program_id)?;
-
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            msg!("Expected valid stake pool");
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_staker(staker_info)?;
-        stake_pool.check_validator_list(validator_list_info)?;
-
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        if let Some(vote_account_address) = vote_account_address {
-            let maybe_validator_stake_info = validator_list.find::<ValidatorStakeInfo, _>(|x| {
-                ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-            });
-            match maybe_validator_stake_info {
-                Some(vsi) => {
-                    if vsi.status != StakeStatus::Active.into() {
-                        msg!("Validator for {:?} about to be removed, cannot set as preferred deposit account", validator_type);
-                        return Err(StakePoolError::InvalidPreferredValidator.into());
-                    }
-                }
-                None => {
-                    msg!("Validator for {:?} not present in the stake pool, cannot set as preferred deposit account", validator_type);
-                    return Err(StakePoolError::ValidatorNotFound.into());
-                }
-            }
-        }
-
-        match validator_type {
-            PreferredValidatorType::Deposit => {
-                stake_pool.preferred_deposit_validator_vote_address = vote_account_address
-            }
-            PreferredValidatorType::Withdraw => {
-                stake_pool.preferred_withdraw_validator_vote_address = vote_account_address
-            }
-        };
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-        Ok(())
-    }
-
-    /// Processes `UpdateValidatorListBalance` instruction.
-    #[inline(always)] // needed to maximize number of validators
-    fn process_update_validator_list_balance(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        start_index: u32,
-        no_merge: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-        let validator_stake_accounts = account_info_iter.as_slice();
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        stake_pool.check_validator_list(validator_list_info)?;
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_reserve_stake(reserve_stake_info)?;
-        check_stake_program(stake_program_info.key)?;
-
-        if validator_stake_accounts
-            .len()
-            .checked_rem(2)
-            .ok_or(StakePoolError::CalculationFailure)?
-            != 0
-        {
-            msg!("Odd number of validator stake accounts passed in, should be pairs of validator stake and transient stake accounts");
-            return Err(StakePoolError::UnexpectedValidatorListAccountSize.into());
-        }
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (validator_list_header, mut big_vec) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        let validator_slice = ValidatorListHeader::deserialize_mut_slice(
-            &mut big_vec,
-            start_index as usize,
-            validator_stake_accounts.len() / 2,
-        )?;
-
-        if !validator_list_header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let validator_iter = &mut validator_slice
-            .iter_mut()
-            .zip(validator_stake_accounts.chunks_exact(2));
-        for (validator_stake_record, validator_stakes) in validator_iter {
-            // chunks_exact means that we always get 2 elements, making this safe
-            let validator_stake_info = validator_stakes
-                .first()
-                .ok_or(ProgramError::InvalidInstructionData)?;
-            let transient_stake_info = validator_stakes
-                .last()
-                .ok_or(ProgramError::InvalidInstructionData)?;
-            if check_validator_stake_address(
-                program_id,
-                stake_pool_info.key,
-                validator_stake_info.key,
-                &validator_stake_record.vote_account_address,
-                NonZeroU32::new(validator_stake_record.validator_seed_suffix.into()),
-            )
-            .is_err()
-            {
-                continue;
-            };
-            if check_transient_stake_address(
-                program_id,
-                stake_pool_info.key,
-                transient_stake_info.key,
-                &validator_stake_record.vote_account_address,
-                validator_stake_record.transient_seed_suffix.into(),
-            )
-            .is_err()
-            {
-                continue;
-            };
-
-            let mut active_stake_lamports = 0;
-            let mut transient_stake_lamports = 0;
-            let validator_stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-                &validator_stake_info.data.borrow(),
-            )
-            .ok();
-            let transient_stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-                &transient_stake_info.data.borrow(),
-            )
-            .ok();
-
-            // Possible merge situations for transient stake
-            //  * active -> merge into validator stake
-            //  * activating -> nothing, just account its lamports
-            //  * deactivating -> nothing, just account its lamports
-            //  * inactive -> merge into reserve stake
-            //  * not a stake -> ignore
-            match transient_stake_state {
-                Some(stake::state::StakeStateV2::Initialized(meta)) => {
-                    if stake_is_usable_by_pool(
-                        &meta,
-                        withdraw_authority_info.key,
-                        &stake_pool.lockup,
-                    ) {
-                        if no_merge {
-                            transient_stake_lamports = transient_stake_info.lamports();
-                        } else {
-                            // merge into reserve
-                            Self::stake_merge(
-                                stake_pool_info.key,
-                                transient_stake_info.clone(),
-                                withdraw_authority_info.clone(),
-                                AUTHORITY_WITHDRAW,
-                                stake_pool.stake_withdraw_bump_seed,
-                                reserve_stake_info.clone(),
-                                clock_info.clone(),
-                                stake_history_info.clone(),
-                            )?;
-                            validator_stake_record.status.remove_transient_stake()?;
-                        }
-                    }
-                }
-                Some(stake::state::StakeStateV2::Stake(meta, stake, _)) => {
-                    if stake_is_usable_by_pool(
-                        &meta,
-                        withdraw_authority_info.key,
-                        &stake_pool.lockup,
-                    ) {
-                        if no_merge {
-                            transient_stake_lamports = transient_stake_info.lamports();
-                        } else if stake_is_inactive_without_history(&stake, clock.epoch) {
-                            // deactivated, merge into reserve
-                            Self::stake_merge(
-                                stake_pool_info.key,
-                                transient_stake_info.clone(),
-                                withdraw_authority_info.clone(),
-                                AUTHORITY_WITHDRAW,
-                                stake_pool.stake_withdraw_bump_seed,
-                                reserve_stake_info.clone(),
-                                clock_info.clone(),
-                                stake_history_info.clone(),
-                            )?;
-                            validator_stake_record.status.remove_transient_stake()?;
-                        } else if stake.delegation.activation_epoch < clock.epoch {
-                            if let Some(stake::state::StakeStateV2::Stake(_, validator_stake, _)) =
-                                validator_stake_state
-                            {
-                                if validator_stake.delegation.activation_epoch < clock.epoch {
-                                    Self::stake_merge(
-                                        stake_pool_info.key,
-                                        transient_stake_info.clone(),
-                                        withdraw_authority_info.clone(),
-                                        AUTHORITY_WITHDRAW,
-                                        stake_pool.stake_withdraw_bump_seed,
-                                        validator_stake_info.clone(),
-                                        clock_info.clone(),
-                                        stake_history_info.clone(),
-                                    )?;
-                                } else {
-                                    msg!("Stake activating or just active, not ready to merge");
-                                    transient_stake_lamports = transient_stake_info.lamports();
-                                }
-                            } else {
-                                msg!("Transient stake is activating or active, but validator stake is not, need to add the validator stake account on {} back into the stake pool", stake.delegation.voter_pubkey);
-                                transient_stake_lamports = transient_stake_info.lamports();
-                            }
-                        } else {
-                            msg!("Transient stake not ready to be merged anywhere");
-                            transient_stake_lamports = transient_stake_info.lamports();
-                        }
-                    }
-                }
-                None
-                | Some(stake::state::StakeStateV2::Uninitialized)
-                | Some(stake::state::StakeStateV2::RewardsPool) => {} // do nothing
-            }
-
-            // Status for validator stake
-            //  * active -> do everything
-            //  * any other state / not a stake -> error state, but account for transient
-            //    stake
-            let validator_stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-                &validator_stake_info.data.borrow(),
-            )
-            .ok();
-            match validator_stake_state {
-                Some(stake::state::StakeStateV2::Stake(meta, stake, _)) => {
-                    let additional_lamports = validator_stake_info
-                        .lamports()
-                        .saturating_sub(stake.delegation.stake)
-                        .saturating_sub(meta.rent_exempt_reserve);
-                    // withdraw any extra lamports back to the reserve
-                    if additional_lamports > 0
-                        && stake_is_usable_by_pool(
-                            &meta,
-                            withdraw_authority_info.key,
-                            &stake_pool.lockup,
-                        )
-                    {
-                        Self::stake_withdraw(
-                            stake_pool_info.key,
-                            validator_stake_info.clone(),
-                            withdraw_authority_info.clone(),
-                            AUTHORITY_WITHDRAW,
-                            stake_pool.stake_withdraw_bump_seed,
-                            reserve_stake_info.clone(),
-                            clock_info.clone(),
-                            stake_history_info.clone(),
-                            additional_lamports,
-                        )?;
-                    }
-                    match validator_stake_record.status.try_into()? {
-                        StakeStatus::Active => {
-                            active_stake_lamports = validator_stake_info.lamports();
-                        }
-                        StakeStatus::DeactivatingValidator | StakeStatus::DeactivatingAll => {
-                            if no_merge {
-                                active_stake_lamports = validator_stake_info.lamports();
-                            } else if stake_is_usable_by_pool(
-                                &meta,
-                                withdraw_authority_info.key,
-                                &stake_pool.lockup,
-                            ) && stake_is_inactive_without_history(&stake, clock.epoch)
-                            {
-                                // Validator was removed through normal means.
-                                // Absorb the lamports into the reserve.
-                                Self::stake_merge(
-                                    stake_pool_info.key,
-                                    validator_stake_info.clone(),
-                                    withdraw_authority_info.clone(),
-                                    AUTHORITY_WITHDRAW,
-                                    stake_pool.stake_withdraw_bump_seed,
-                                    reserve_stake_info.clone(),
-                                    clock_info.clone(),
-                                    stake_history_info.clone(),
-                                )?;
-                                validator_stake_record.status.remove_validator_stake()?;
-                            }
-                        }
-                        StakeStatus::DeactivatingTransient | StakeStatus::ReadyForRemoval => {
-                            msg!("Validator stake account no longer part of the pool, ignoring");
-                        }
-                    }
-                }
-                Some(stake::state::StakeStateV2::Initialized(meta))
-                    if stake_is_usable_by_pool(
-                        &meta,
-                        withdraw_authority_info.key,
-                        &stake_pool.lockup,
-                    ) =>
-                {
-                    // If a validator stake is `Initialized`, the validator could
-                    // have been destaked during a cluster restart or removed through
-                    // normal means. Either way, absorb those lamports into the reserve.
-                    // The transient stake was likely absorbed into the reserve earlier.
-                    Self::stake_merge(
-                        stake_pool_info.key,
-                        validator_stake_info.clone(),
-                        withdraw_authority_info.clone(),
-                        AUTHORITY_WITHDRAW,
-                        stake_pool.stake_withdraw_bump_seed,
-                        reserve_stake_info.clone(),
-                        clock_info.clone(),
-                        stake_history_info.clone(),
-                    )?;
-                    validator_stake_record.status.remove_validator_stake()?;
-                }
-                Some(stake::state::StakeStateV2::Initialized(_))
-                | Some(stake::state::StakeStateV2::Uninitialized)
-                | Some(stake::state::StakeStateV2::RewardsPool)
-                | None => {
-                    msg!("Validator stake account no longer part of the pool, ignoring");
-                }
-            }
-
-            validator_stake_record.last_update_epoch = clock.epoch.into();
-            validator_stake_record.active_stake_lamports = active_stake_lamports.into();
-            validator_stake_record.transient_stake_lamports = transient_stake_lamports.into();
-        }
-
-        Ok(())
-    }
-
-    /// Processes `UpdateStakePoolBalance` instruction.
-    #[inline(always)] // needed to optimize number of validators
-    fn process_update_stake_pool_balance(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let withdraw_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let clock = Clock::get()?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        stake_pool.check_mint(pool_mint_info)?;
-        stake_pool.check_authority_withdraw(withdraw_info.key, program_id, stake_pool_info.key)?;
-        stake_pool.check_reserve_stake(reserve_stake_info)?;
-        if stake_pool.manager_fee_account != *manager_fee_info.key {
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-
-        if *validator_list_info.key != stake_pool.validator_list {
-            return Err(StakePoolError::InvalidValidatorStakeList.into());
-        }
-        if stake_pool.token_program_id != *token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let previous_lamports = stake_pool.total_lamports;
-        let previous_pool_token_supply = stake_pool.pool_token_supply;
-        let reserve_stake = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-            &reserve_stake_info.data.borrow(),
-        )?;
-        let mut total_lamports =
-            if let stake::state::StakeStateV2::Initialized(meta) = reserve_stake {
-                reserve_stake_info
-                    .lamports()
-                    .checked_sub(minimum_reserve_lamports(&meta))
-                    .ok_or(StakePoolError::CalculationFailure)?
-            } else {
-                msg!("Reserve stake account in unknown state, aborting");
-                return Err(StakePoolError::WrongStakeStake.into());
-            };
-        for validator_stake_record in validator_list
-            .deserialize_slice::<ValidatorStakeInfo>(0, validator_list.len() as usize)?
-        {
-            if u64::from(validator_stake_record.last_update_epoch) < clock.epoch {
-                return Err(StakePoolError::StakeListOutOfDate.into());
-            }
-            total_lamports = total_lamports
-                .checked_add(validator_stake_record.stake_lamports()?)
-                .ok_or(StakePoolError::CalculationFailure)?;
-        }
-
-        let reward_lamports = total_lamports.saturating_sub(previous_lamports);
-
-        // If the manager fee info is invalid, they don't deserve to receive the fee.
-        let fee = if stake_pool.check_manager_fee_info(manager_fee_info).is_ok() {
-            stake_pool
-                .calc_epoch_fee_amount(reward_lamports)
-                .ok_or(StakePoolError::CalculationFailure)?
-        } else {
-            0
-        };
-
-        if fee > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                withdraw_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                fee,
-            )?;
-        }
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            if let Some(fee) = stake_pool.next_epoch_fee.get() {
-                stake_pool.epoch_fee = *fee;
-            }
-            stake_pool.next_epoch_fee.update_epoch();
-
-            if let Some(fee) = stake_pool.next_stake_withdrawal_fee.get() {
-                stake_pool.stake_withdrawal_fee = *fee;
-            }
-            stake_pool.next_stake_withdrawal_fee.update_epoch();
-
-            if let Some(fee) = stake_pool.next_sol_withdrawal_fee.get() {
-                stake_pool.sol_withdrawal_fee = *fee;
-            }
-            stake_pool.next_sol_withdrawal_fee.update_epoch();
-
-            stake_pool.last_update_epoch = clock.epoch;
-            stake_pool.last_epoch_total_lamports = previous_lamports;
-            stake_pool.last_epoch_pool_token_supply = previous_pool_token_supply;
-        }
-        stake_pool.total_lamports = total_lamports;
-
-        let pool_mint_data = pool_mint_info.try_borrow_data()?;
-        let pool_mint = StateWithExtensions::<Mint>::unpack(&pool_mint_data)?;
-        stake_pool.pool_token_supply = pool_mint.base.supply;
-
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        Ok(())
-    }
-
-    /// Processes the `CleanupRemovedValidatorEntries` instruction
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_cleanup_removed_validator_entries(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        stake_pool.check_validator_list(validator_list_info)?;
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        validator_list.retain::<ValidatorStakeInfo, _>(ValidatorStakeInfo::is_not_removed)?;
-
-        Ok(())
-    }
-
-    /// Processes [DepositStake](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_deposit_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        minimum_pool_tokens_out: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let stake_deposit_authority_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let stake_info = next_account_info(account_info_iter)?;
-        let validator_stake_account_info = next_account_info(account_info_iter)?;
-        let reserve_stake_account_info = next_account_info(account_info_iter)?;
-        let dest_user_pool_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let referrer_fee_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_stake_program(stake_program_info.key)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_stake_deposit_authority(stake_deposit_authority_info.key)?;
-        stake_pool.check_mint(pool_mint_info)?;
-        stake_pool.check_validator_list(validator_list_info)?;
-        stake_pool.check_reserve_stake(reserve_stake_account_info)?;
-
-        if stake_pool.token_program_id != *token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-
-        if stake_pool.manager_fee_account != *manager_fee_info.key {
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-        // There is no bypass if the manager fee account is invalid. Deposits
-        // don't hold user funds hostage, so if the fee account is invalid, users
-        // cannot deposit in the pool.  Let it fail here!
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let (_, validator_stake) = get_stake_state(validator_stake_account_info)?;
-        let pre_all_validator_lamports = validator_stake_account_info.lamports();
-        let vote_account_address = validator_stake.delegation.voter_pubkey;
-        if let Some(preferred_deposit) = stake_pool.preferred_deposit_validator_vote_address {
-            if preferred_deposit != vote_account_address {
-                msg!(
-                    "Incorrect deposit address, expected {}, received {}",
-                    preferred_deposit,
-                    vote_account_address
-                );
-                return Err(StakePoolError::IncorrectDepositVoteAddress.into());
-            }
-        }
-
-        let validator_stake_info = validator_list
-            .find_mut::<ValidatorStakeInfo, _>(|x| {
-                ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-            })
-            .ok_or(StakePoolError::ValidatorNotFound)?;
-        check_validator_stake_address(
-            program_id,
-            stake_pool_info.key,
-            validator_stake_account_info.key,
-            &vote_account_address,
-            NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-        )?;
-
-        if validator_stake_info.status != StakeStatus::Active.into() {
-            msg!("Validator is marked for removal and no longer accepting deposits");
-            return Err(StakePoolError::ValidatorNotFound.into());
-        }
-
-        msg!("Stake pre merge {}", validator_stake.delegation.stake);
-
-        let (stake_deposit_authority_program_address, deposit_bump_seed) =
-            find_deposit_authority_program_address(program_id, stake_pool_info.key);
-        if *stake_deposit_authority_info.key == stake_deposit_authority_program_address {
-            Self::stake_authorize_signed(
-                stake_pool_info.key,
-                stake_info.clone(),
-                stake_deposit_authority_info.clone(),
-                AUTHORITY_DEPOSIT,
-                deposit_bump_seed,
-                withdraw_authority_info.key,
-                clock_info.clone(),
-            )?;
-        } else {
-            Self::stake_authorize(
-                stake_info.clone(),
-                stake_deposit_authority_info.clone(),
-                withdraw_authority_info.key,
-                clock_info.clone(),
-            )?;
-        }
-
-        Self::stake_merge(
-            stake_pool_info.key,
-            stake_info.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            validator_stake_account_info.clone(),
-            clock_info.clone(),
-            stake_history_info.clone(),
-        )?;
-
-        let (_, post_validator_stake) = get_stake_state(validator_stake_account_info)?;
-        let post_all_validator_lamports = validator_stake_account_info.lamports();
-        msg!("Stake post merge {}", post_validator_stake.delegation.stake);
-
-        let total_deposit_lamports = post_all_validator_lamports
-            .checked_sub(pre_all_validator_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let stake_deposit_lamports = post_validator_stake
-            .delegation
-            .stake
-            .checked_sub(validator_stake.delegation.stake)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let sol_deposit_lamports = total_deposit_lamports
-            .checked_sub(stake_deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let new_pool_tokens = stake_pool
-            .calc_pool_tokens_for_deposit(total_deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let new_pool_tokens_from_stake = stake_pool
-            .calc_pool_tokens_for_deposit(stake_deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let new_pool_tokens_from_sol = new_pool_tokens
-            .checked_sub(new_pool_tokens_from_stake)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let stake_deposit_fee = stake_pool
-            .calc_pool_tokens_stake_deposit_fee(new_pool_tokens_from_stake)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let sol_deposit_fee = stake_pool
-            .calc_pool_tokens_sol_deposit_fee(new_pool_tokens_from_sol)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let total_fee = stake_deposit_fee
-            .checked_add(sol_deposit_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let pool_tokens_user = new_pool_tokens
-            .checked_sub(total_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let pool_tokens_referral_fee = stake_pool
-            .calc_pool_tokens_stake_referral_fee(total_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let pool_tokens_manager_deposit_fee = total_fee
-            .checked_sub(pool_tokens_referral_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        if pool_tokens_user
-            .saturating_add(pool_tokens_manager_deposit_fee)
-            .saturating_add(pool_tokens_referral_fee)
-            != new_pool_tokens
-        {
-            return Err(StakePoolError::CalculationFailure.into());
-        }
-
-        if pool_tokens_user == 0 {
-            return Err(StakePoolError::DepositTooSmall.into());
-        }
-
-        if let Some(minimum_pool_tokens_out) = minimum_pool_tokens_out {
-            if pool_tokens_user < minimum_pool_tokens_out {
-                return Err(StakePoolError::ExceededSlippage.into());
-            }
-        }
-
-        Self::token_mint_to(
-            stake_pool_info.key,
-            token_program_info.clone(),
-            pool_mint_info.clone(),
-            dest_user_pool_info.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            pool_tokens_user,
-        )?;
-        if pool_tokens_manager_deposit_fee > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                pool_tokens_manager_deposit_fee,
-            )?;
-        }
-        if pool_tokens_referral_fee > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                referrer_fee_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                pool_tokens_referral_fee,
-            )?;
-        }
-
-        // withdraw additional lamports to the reserve
-        if sol_deposit_lamports > 0 {
-            Self::stake_withdraw(
-                stake_pool_info.key,
-                validator_stake_account_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                reserve_stake_account_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-                sol_deposit_lamports,
-            )?;
-        }
-
-        stake_pool.pool_token_supply = stake_pool
-            .pool_token_supply
-            .checked_add(new_pool_tokens)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        // We treat the extra lamports as though they were
-        // transferred directly to the reserve stake account.
-        stake_pool.total_lamports = stake_pool
-            .total_lamports
-            .checked_add(total_deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        validator_stake_info.active_stake_lamports = validator_stake_account_info.lamports().into();
-
-        Ok(())
-    }
-
-    /// Processes [DepositSol](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_deposit_sol(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        deposit_lamports: u64,
-        minimum_pool_tokens_out: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let reserve_stake_account_info = next_account_info(account_info_iter)?;
-        let from_user_lamports_info = next_account_info(account_info_iter)?;
-        let dest_user_pool_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let referrer_fee_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let sol_deposit_authority_info = next_account_info(account_info_iter);
-
-        let clock = Clock::get()?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_sol_deposit_authority(sol_deposit_authority_info)?;
-        stake_pool.check_mint(pool_mint_info)?;
-        stake_pool.check_reserve_stake(reserve_stake_account_info)?;
-
-        if stake_pool.token_program_id != *token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-        check_system_program(system_program_info.key)?;
-
-        if stake_pool.manager_fee_account != *manager_fee_info.key {
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-        // There is no bypass if the manager fee account is invalid. Deposits
-        // don't hold user funds hostage, so if the fee account is invalid, users
-        // cannot deposit in the pool.  Let it fail here!
-
-        // We want this to hold to ensure that deposit_sol mints pool tokens
-        // at the right price
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        let new_pool_tokens = stake_pool
-            .calc_pool_tokens_for_deposit(deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let pool_tokens_sol_deposit_fee = stake_pool
-            .calc_pool_tokens_sol_deposit_fee(new_pool_tokens)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let pool_tokens_user = new_pool_tokens
-            .checked_sub(pool_tokens_sol_deposit_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let pool_tokens_referral_fee = stake_pool
-            .calc_pool_tokens_sol_referral_fee(pool_tokens_sol_deposit_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let pool_tokens_manager_deposit_fee = pool_tokens_sol_deposit_fee
-            .checked_sub(pool_tokens_referral_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        if pool_tokens_user
-            .saturating_add(pool_tokens_manager_deposit_fee)
-            .saturating_add(pool_tokens_referral_fee)
-            != new_pool_tokens
-        {
-            return Err(StakePoolError::CalculationFailure.into());
-        }
-
-        if pool_tokens_user == 0 {
-            return Err(StakePoolError::DepositTooSmall.into());
-        }
-
-        if let Some(minimum_pool_tokens_out) = minimum_pool_tokens_out {
-            if pool_tokens_user < minimum_pool_tokens_out {
-                return Err(StakePoolError::ExceededSlippage.into());
-            }
-        }
-
-        Self::sol_transfer(
-            from_user_lamports_info.clone(),
-            reserve_stake_account_info.clone(),
-            deposit_lamports,
-        )?;
-
-        Self::token_mint_to(
-            stake_pool_info.key,
-            token_program_info.clone(),
-            pool_mint_info.clone(),
-            dest_user_pool_info.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            pool_tokens_user,
-        )?;
-
-        if pool_tokens_manager_deposit_fee > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                pool_tokens_manager_deposit_fee,
-            )?;
-        }
-
-        if pool_tokens_referral_fee > 0 {
-            Self::token_mint_to(
-                stake_pool_info.key,
-                token_program_info.clone(),
-                pool_mint_info.clone(),
-                referrer_fee_info.clone(),
-                withdraw_authority_info.clone(),
-                AUTHORITY_WITHDRAW,
-                stake_pool.stake_withdraw_bump_seed,
-                pool_tokens_referral_fee,
-            )?;
-        }
-
-        stake_pool.pool_token_supply = stake_pool
-            .pool_token_supply
-            .checked_add(new_pool_tokens)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        stake_pool.total_lamports = stake_pool
-            .total_lamports
-            .checked_add(deposit_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        Ok(())
-    }
-
-    /// Processes [WithdrawStake](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_withdraw_stake(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        pool_tokens: u64,
-        minimum_lamports_out: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let validator_list_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let stake_split_from = next_account_info(account_info_iter)?;
-        let stake_split_to = next_account_info(account_info_iter)?;
-        let user_stake_authority_info = next_account_info(account_info_iter)?;
-        let user_transfer_authority_info = next_account_info(account_info_iter)?;
-        let burn_from_pool_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-
-        check_stake_program(stake_program_info.key)?;
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let decimals = stake_pool.check_mint(pool_mint_info)?;
-        stake_pool.check_validator_list(validator_list_info)?;
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-
-        if stake_pool.manager_fee_account != *manager_fee_info.key {
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-        if stake_pool.token_program_id != *token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-
-        if stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        check_account_owner(validator_list_info, program_id)?;
-        let mut validator_list_data = validator_list_info.data.borrow_mut();
-        let (header, mut validator_list) =
-            ValidatorListHeader::deserialize_vec(&mut validator_list_data)?;
-        if !header.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        // To prevent a faulty manager fee account from preventing withdrawals
-        // if the token program does not own the account, or if the account is not
-        // initialized
-        let pool_tokens_fee = if stake_pool.manager_fee_account == *burn_from_pool_info.key
-            || stake_pool.check_manager_fee_info(manager_fee_info).is_err()
-        {
-            0
-        } else {
-            stake_pool
-                .calc_pool_tokens_stake_withdrawal_fee(pool_tokens)
-                .ok_or(StakePoolError::CalculationFailure)?
-        };
-        let pool_tokens_burnt = pool_tokens
-            .checked_sub(pool_tokens_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let mut withdraw_lamports = stake_pool
-            .calc_lamports_withdraw_amount(pool_tokens_burnt)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        if withdraw_lamports == 0 {
-            return Err(StakePoolError::WithdrawalTooSmall.into());
-        }
-
-        if let Some(minimum_lamports_out) = minimum_lamports_out {
-            if withdraw_lamports < minimum_lamports_out {
-                return Err(StakePoolError::ExceededSlippage.into());
-            }
-        }
-
-        let stake_minimum_delegation = stake::tools::get_minimum_delegation()?;
-        let stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-            &stake_split_from.data.borrow(),
-        )?;
-        let meta = stake_state.meta().ok_or(StakePoolError::WrongStakeStake)?;
-        let required_lamports = minimum_stake_lamports(&meta, stake_minimum_delegation);
-
-        let lamports_per_pool_token = stake_pool
-            .get_lamports_per_pool_token()
-            .ok_or(StakePoolError::CalculationFailure)?;
-        let minimum_lamports_with_tolerance =
-            required_lamports.saturating_add(lamports_per_pool_token);
-
-        let has_active_stake = validator_list
-            .find::<ValidatorStakeInfo, _>(|x| {
-                ValidatorStakeInfo::active_lamports_greater_than(
-                    x,
-                    &minimum_lamports_with_tolerance,
-                )
-            })
-            .is_some();
-        let has_transient_stake = validator_list
-            .find::<ValidatorStakeInfo, _>(|x| {
-                ValidatorStakeInfo::transient_lamports_greater_than(
-                    x,
-                    &minimum_lamports_with_tolerance,
-                )
-            })
-            .is_some();
-
-        let validator_list_item_info = if *stake_split_from.key == stake_pool.reserve_stake {
-            // check that the validator stake accounts have no withdrawable stake
-            if has_transient_stake || has_active_stake {
-                msg!("Error withdrawing from reserve: validator stake accounts have lamports available, please use those first.");
-                return Err(StakePoolError::StakeLamportsNotEqualToMinimum.into());
-            }
-
-            // check that reserve has enough (should never fail, but who knows?)
-            stake_split_from
-                .lamports()
-                .checked_sub(minimum_reserve_lamports(&meta))
-                .ok_or(StakePoolError::StakeLamportsNotEqualToMinimum)?;
-            None
-        } else {
-            let delegation = stake_state
-                .delegation()
-                .ok_or(StakePoolError::WrongStakeStake)?;
-            let vote_account_address = delegation.voter_pubkey;
-
-            if let Some(preferred_withdraw_validator) =
-                stake_pool.preferred_withdraw_validator_vote_address
-            {
-                let preferred_validator_info = validator_list
-                    .find::<ValidatorStakeInfo, _>(|x| {
-                        ValidatorStakeInfo::memcmp_pubkey(x, &preferred_withdraw_validator)
-                    })
-                    .ok_or(StakePoolError::ValidatorNotFound)?;
-                let available_lamports = u64::from(preferred_validator_info.active_stake_lamports)
-                    .saturating_sub(minimum_lamports_with_tolerance);
-                if preferred_withdraw_validator != vote_account_address && available_lamports > 0 {
-                    msg!("Validator vote address {} is preferred for withdrawals, it currently has {} lamports available. Please withdraw those before using other validator stake accounts.", preferred_withdraw_validator, u64::from(preferred_validator_info.active_stake_lamports));
-                    return Err(StakePoolError::IncorrectWithdrawVoteAddress.into());
-                }
-            }
-
-            let validator_stake_info = validator_list
-                .find_mut::<ValidatorStakeInfo, _>(|x| {
-                    ValidatorStakeInfo::memcmp_pubkey(x, &vote_account_address)
-                })
-                .ok_or(StakePoolError::ValidatorNotFound)?;
-
-            let withdraw_source = if has_active_stake {
-                // if there's any active stake, we must withdraw from an active
-                // stake account
-                check_validator_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    stake_split_from.key,
-                    &vote_account_address,
-                    NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-                )?;
-                StakeWithdrawSource::Active
-            } else if has_transient_stake {
-                // if there's any transient stake, we must withdraw from there
-                check_transient_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    stake_split_from.key,
-                    &vote_account_address,
-                    validator_stake_info.transient_seed_suffix.into(),
-                )?;
-                StakeWithdrawSource::Transient
-            } else {
-                // if there's no active or transient stake, we can take the whole account
-                check_validator_stake_address(
-                    program_id,
-                    stake_pool_info.key,
-                    stake_split_from.key,
-                    &vote_account_address,
-                    NonZeroU32::new(validator_stake_info.validator_seed_suffix.into()),
-                )?;
-                StakeWithdrawSource::ValidatorRemoval
-            };
-
-            if validator_stake_info.status != StakeStatus::Active.into() {
-                msg!("Validator is marked for removal and no longer allowing withdrawals");
-                return Err(StakePoolError::ValidatorNotFound.into());
-            }
-
-            match withdraw_source {
-                StakeWithdrawSource::Active | StakeWithdrawSource::Transient => {
-                    let remaining_lamports = stake_split_from
-                        .lamports()
-                        .saturating_sub(withdraw_lamports);
-                    if remaining_lamports < required_lamports {
-                        msg!("Attempting to withdraw {} lamports from validator account with {} stake lamports, {} must remain", withdraw_lamports, stake_split_from.lamports(), required_lamports);
-                        return Err(StakePoolError::StakeLamportsNotEqualToMinimum.into());
-                    }
-                }
-                StakeWithdrawSource::ValidatorRemoval => {
-                    let split_from_lamports = stake_split_from.lamports();
-                    let upper_bound = split_from_lamports.saturating_add(lamports_per_pool_token);
-                    if withdraw_lamports < split_from_lamports || withdraw_lamports > upper_bound {
-                        msg!(
-                            "Cannot withdraw a whole account worth {} lamports, \
-                              must withdraw at least {} lamports worth of pool tokens \
-                              with a margin of {} lamports",
-                            withdraw_lamports,
-                            split_from_lamports,
-                            lamports_per_pool_token
-                        );
-                        return Err(StakePoolError::StakeLamportsNotEqualToMinimum.into());
-                    }
-                    // truncate the lamports down to the amount in the account
-                    withdraw_lamports = split_from_lamports;
-                }
-            }
-            Some((validator_stake_info, withdraw_source))
-        };
-
-        Self::token_burn(
-            token_program_info.clone(),
-            burn_from_pool_info.clone(),
-            pool_mint_info.clone(),
-            user_transfer_authority_info.clone(),
-            pool_tokens_burnt,
-        )?;
-
-        Self::stake_split(
-            stake_pool_info.key,
-            stake_split_from.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            withdraw_lamports,
-            stake_split_to.clone(),
-        )?;
-
-        Self::stake_authorize_signed(
-            stake_pool_info.key,
-            stake_split_to.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            user_stake_authority_info.key,
-            clock_info.clone(),
-        )?;
-
-        if pool_tokens_fee > 0 {
-            Self::token_transfer(
-                token_program_info.clone(),
-                burn_from_pool_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                user_transfer_authority_info.clone(),
-                pool_tokens_fee,
-                decimals,
-            )?;
-        }
-
-        stake_pool.pool_token_supply = stake_pool
-            .pool_token_supply
-            .checked_sub(pool_tokens_burnt)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        stake_pool.total_lamports = stake_pool
-            .total_lamports
-            .checked_sub(withdraw_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        if let Some((validator_list_item, withdraw_source)) = validator_list_item_info {
-            match withdraw_source {
-                StakeWithdrawSource::Active => {
-                    validator_list_item.active_stake_lamports =
-                        u64::from(validator_list_item.active_stake_lamports)
-                            .checked_sub(withdraw_lamports)
-                            .ok_or(StakePoolError::CalculationFailure)?
-                            .into()
-                }
-                StakeWithdrawSource::Transient => {
-                    validator_list_item.transient_stake_lamports =
-                        u64::from(validator_list_item.transient_stake_lamports)
-                            .checked_sub(withdraw_lamports)
-                            .ok_or(StakePoolError::CalculationFailure)?
-                            .into()
-                }
-                StakeWithdrawSource::ValidatorRemoval => {
-                    validator_list_item.active_stake_lamports =
-                        u64::from(validator_list_item.active_stake_lamports)
-                            .checked_sub(withdraw_lamports)
-                            .ok_or(StakePoolError::CalculationFailure)?
-                            .into();
-                    if u64::from(validator_list_item.active_stake_lamports) != 0 {
-                        msg!("Attempting to remove a validator from the pool, but withdrawal leaves {} lamports, update the pool to merge any unaccounted lamports",
-                            u64::from(validator_list_item.active_stake_lamports));
-                        return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-                    }
-                    // since we already checked that there's no transient stake,
-                    // we can immediately set this as ready for removal
-                    validator_list_item.status = StakeStatus::ReadyForRemoval.into();
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Processes [WithdrawSol](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_withdraw_sol(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        pool_tokens: u64,
-        minimum_lamports_out: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let user_transfer_authority_info = next_account_info(account_info_iter)?;
-        let burn_from_pool_info = next_account_info(account_info_iter)?;
-        let reserve_stake_info = next_account_info(account_info_iter)?;
-        let destination_lamports_info = next_account_info(account_info_iter)?;
-        let manager_fee_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_program_info = next_account_info(account_info_iter)?;
-        let token_program_info = next_account_info(account_info_iter)?;
-        let sol_withdraw_authority_info = next_account_info(account_info_iter);
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_sol_withdraw_authority(sol_withdraw_authority_info)?;
-        let decimals = stake_pool.check_mint(pool_mint_info)?;
-        stake_pool.check_reserve_stake(reserve_stake_info)?;
-
-        if stake_pool.token_program_id != *token_program_info.key {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-        check_stake_program(stake_program_info.key)?;
-
-        if stake_pool.manager_fee_account != *manager_fee_info.key {
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-
-        // We want this to hold to ensure that withdraw_sol burns pool tokens
-        // at the right price
-        if stake_pool.last_update_epoch < Clock::get()?.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        // To prevent a faulty manager fee account from preventing withdrawals
-        // if the token program does not own the account, or if the account is not
-        // initialized
-        let pool_tokens_fee = if stake_pool.manager_fee_account == *burn_from_pool_info.key
-            || stake_pool.check_manager_fee_info(manager_fee_info).is_err()
-        {
-            0
-        } else {
-            stake_pool
-                .calc_pool_tokens_sol_withdrawal_fee(pool_tokens)
-                .ok_or(StakePoolError::CalculationFailure)?
-        };
-        let pool_tokens_burnt = pool_tokens
-            .checked_sub(pool_tokens_fee)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        let withdraw_lamports = stake_pool
-            .calc_lamports_withdraw_amount(pool_tokens_burnt)
-            .ok_or(StakePoolError::CalculationFailure)?;
-
-        if withdraw_lamports == 0 {
-            return Err(StakePoolError::WithdrawalTooSmall.into());
-        }
-
-        if let Some(minimum_lamports_out) = minimum_lamports_out {
-            if withdraw_lamports < minimum_lamports_out {
-                return Err(StakePoolError::ExceededSlippage.into());
-            }
-        }
-
-        let new_reserve_lamports = reserve_stake_info
-            .lamports()
-            .saturating_sub(withdraw_lamports);
-        let stake_state = try_from_slice_unchecked::<stake::state::StakeStateV2>(
-            &reserve_stake_info.data.borrow(),
-        )?;
-        if let stake::state::StakeStateV2::Initialized(meta) = stake_state {
-            let minimum_reserve_lamports = minimum_reserve_lamports(&meta);
-            if new_reserve_lamports < minimum_reserve_lamports {
-                msg!("Attempting to withdraw {} lamports, maximum possible SOL withdrawal is {} lamports",
-                    withdraw_lamports,
-                    reserve_stake_info.lamports().saturating_sub(minimum_reserve_lamports)
-                );
-                return Err(StakePoolError::SolWithdrawalTooLarge.into());
-            }
-        } else {
-            msg!("Reserve stake account not in intialized state");
-            return Err(StakePoolError::WrongStakeStake.into());
-        };
-
-        Self::token_burn(
-            token_program_info.clone(),
-            burn_from_pool_info.clone(),
-            pool_mint_info.clone(),
-            user_transfer_authority_info.clone(),
-            pool_tokens_burnt,
-        )?;
-
-        if pool_tokens_fee > 0 {
-            Self::token_transfer(
-                token_program_info.clone(),
-                burn_from_pool_info.clone(),
-                pool_mint_info.clone(),
-                manager_fee_info.clone(),
-                user_transfer_authority_info.clone(),
-                pool_tokens_fee,
-                decimals,
-            )?;
-        }
-
-        Self::stake_withdraw(
-            stake_pool_info.key,
-            reserve_stake_info.clone(),
-            withdraw_authority_info.clone(),
-            AUTHORITY_WITHDRAW,
-            stake_pool.stake_withdraw_bump_seed,
-            destination_lamports_info.clone(),
-            clock_info.clone(),
-            stake_history_info.clone(),
-            withdraw_lamports,
-        )?;
-
-        stake_pool.pool_token_supply = stake_pool
-            .pool_token_supply
-            .checked_sub(pool_tokens_burnt)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        stake_pool.total_lamports = stake_pool
-            .total_lamports
-            .checked_sub(withdraw_lamports)
-            .ok_or(StakePoolError::CalculationFailure)?;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-
-        Ok(())
-    }
-
-    #[inline(never)]
-    fn process_create_pool_token_metadata(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        name: String,
-        symbol: String,
-        uri: String,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let pool_mint_info = next_account_info(account_info_iter)?;
-        let payer_info = next_account_info(account_info_iter)?;
-        let metadata_info = next_account_info(account_info_iter)?;
-        let mpl_token_metadata_program_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-
-        if !payer_info.is_signer {
-            msg!("Payer did not sign metadata creation");
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-
-        check_system_program(system_program_info.key)?;
-        check_account_owner(payer_info, &system_program::id())?;
-        check_account_owner(stake_pool_info, program_id)?;
-        check_mpl_metadata_program(mpl_token_metadata_program_info.key)?;
-
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_manager(manager_info)?;
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        stake_pool.check_mint(pool_mint_info)?;
-        check_mpl_metadata_account_address(metadata_info.key, &stake_pool.pool_mint)?;
-
-        // Token mint authority for stake-pool token is stake-pool withdraw authority
-        let token_mint_authority = withdraw_authority_info;
-
-        let new_metadata_instruction = create_metadata_accounts_v3(
-            *mpl_token_metadata_program_info.key,
-            *metadata_info.key,
-            *pool_mint_info.key,
-            *token_mint_authority.key,
-            *payer_info.key,
-            *token_mint_authority.key,
-            name,
-            symbol,
-            uri,
-        );
-
-        let (_, stake_withdraw_bump_seed) =
-            crate::find_withdraw_authority_program_address(program_id, stake_pool_info.key);
-
-        let token_mint_authority_signer_seeds: &[&[_]] = &[
-            stake_pool_info.key.as_ref(),
-            AUTHORITY_WITHDRAW,
-            &[stake_withdraw_bump_seed],
-        ];
-
-        invoke_signed(
-            &new_metadata_instruction,
-            &[
-                metadata_info.clone(),
-                pool_mint_info.clone(),
-                withdraw_authority_info.clone(),
-                payer_info.clone(),
-                withdraw_authority_info.clone(),
-                system_program_info.clone(),
-            ],
-            &[token_mint_authority_signer_seeds],
-        )?;
-
-        Ok(())
-    }
-
-    #[inline(never)]
-    fn process_update_pool_token_metadata(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        name: String,
-        symbol: String,
-        uri: String,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-        let withdraw_authority_info = next_account_info(account_info_iter)?;
-        let metadata_info = next_account_info(account_info_iter)?;
-        let mpl_token_metadata_program_info = next_account_info(account_info_iter)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-
-        check_mpl_metadata_program(mpl_token_metadata_program_info.key)?;
-
-        let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_manager(manager_info)?;
-        stake_pool.check_authority_withdraw(
-            withdraw_authority_info.key,
-            program_id,
-            stake_pool_info.key,
-        )?;
-        check_mpl_metadata_account_address(metadata_info.key, &stake_pool.pool_mint)?;
-
-        // Token mint authority for stake-pool token is withdraw authority only
-        let token_mint_authority = withdraw_authority_info;
-
-        let update_metadata_accounts_instruction = update_metadata_accounts_v2(
-            *mpl_token_metadata_program_info.key,
-            *metadata_info.key,
-            *token_mint_authority.key,
-            None,
-            Some(DataV2 {
-                name,
-                symbol,
-                uri,
-                seller_fee_basis_points: 0,
-                creators: None,
-                collection: None,
-                uses: None,
-            }),
-            None,
-            Some(true),
-        );
-
-        let (_, stake_withdraw_bump_seed) =
-            crate::find_withdraw_authority_program_address(program_id, stake_pool_info.key);
-
-        let token_mint_authority_signer_seeds: &[&[_]] = &[
-            stake_pool_info.key.as_ref(),
-            AUTHORITY_WITHDRAW,
-            &[stake_withdraw_bump_seed],
-        ];
-
-        invoke_signed(
-            &update_metadata_accounts_instruction,
-            &[metadata_info.clone(), withdraw_authority_info.clone()],
-            &[token_mint_authority_signer_seeds],
-        )?;
-
-        Ok(())
-    }
-
-    /// Processes [SetManager](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_set_manager(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-        let new_manager_info = next_account_info(account_info_iter)?;
-        let new_manager_fee_info = next_account_info(account_info_iter)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        check_account_owner(new_manager_fee_info, &stake_pool.token_program_id)?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        stake_pool.check_manager(manager_info)?;
-        if !new_manager_info.is_signer {
-            msg!("New manager signature missing");
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-
-        stake_pool.check_manager_fee_info(new_manager_fee_info)?;
-
-        stake_pool.manager = *new_manager_info.key;
-        stake_pool.manager_fee_account = *new_manager_fee_info.key;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-        Ok(())
-    }
-
-    /// Processes [SetFee](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_set_fee(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        fee: FeeType,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-        let clock = Clock::get()?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        stake_pool.check_manager(manager_info)?;
-
-        if fee.can_only_change_next_epoch() && stake_pool.last_update_epoch < clock.epoch {
-            return Err(StakePoolError::StakeListAndPoolOutOfDate.into());
-        }
-
-        fee.check_too_high()?;
-        stake_pool.update_fee(&fee)?;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-        Ok(())
-    }
-
-    /// Processes [SetStaker](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_set_staker(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let set_staker_authority_info = next_account_info(account_info_iter)?;
-        let new_staker_info = next_account_info(account_info_iter)?;
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-
-        let staker_signed = stake_pool.check_staker(set_staker_authority_info);
-        let manager_signed = stake_pool.check_manager(set_staker_authority_info);
-        if staker_signed.is_err() && manager_signed.is_err() {
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-        stake_pool.staker = *new_staker_info.key;
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-        Ok(())
-    }
-
-    /// Processes [SetFundingAuthority](enum.Instruction.html).
-    #[inline(never)] // needed to avoid stack size violation
-    fn process_set_funding_authority(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        funding_type: FundingType,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let stake_pool_info = next_account_info(account_info_iter)?;
-        let manager_info = next_account_info(account_info_iter)?;
-
-        let new_authority = next_account_info(account_info_iter)
-            .ok()
-            .map(|new_authority_account_info| *new_authority_account_info.key);
-
-        check_account_owner(stake_pool_info, program_id)?;
-        let mut stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data.borrow())?;
-        if !stake_pool.is_valid() {
-            return Err(StakePoolError::InvalidState.into());
-        }
-        stake_pool.check_manager(manager_info)?;
-        match funding_type {
-            FundingType::StakeDeposit => {
-                stake_pool.stake_deposit_authority = new_authority.unwrap_or(
-                    find_deposit_authority_program_address(program_id, stake_pool_info.key).0,
-                );
-            }
-            FundingType::SolDeposit => stake_pool.sol_deposit_authority = new_authority,
-            FundingType::SolWithdraw => stake_pool.sol_withdraw_authority = new_authority,
-        }
-        borsh::to_writer(&mut stake_pool_info.data.borrow_mut()[..], &stake_pool)?;
-        Ok(())
-    }
-
-    /// Processes [Instruction](enum.Instruction.html).
-    pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-        let instruction = StakePoolInstruction::try_from_slice(input)?;
-        match instruction {
-            StakePoolInstruction::Initialize {
-                fee,
-                withdrawal_fee,
-                deposit_fee,
-                referral_fee,
-                max_validators,
-            } => {
-                msg!("Instruction: Initialize stake pool");
-                Self::process_initialize(
-                    program_id,
-                    accounts,
-                    fee,
-                    withdrawal_fee,
-                    deposit_fee,
-                    referral_fee,
-                    max_validators,
-                )
-            }
-            StakePoolInstruction::AddValidatorToPool(seed) => {
-                msg!("Instruction: AddValidatorToPool");
-                Self::process_add_validator_to_pool(program_id, accounts, seed)
-            }
-            StakePoolInstruction::RemoveValidatorFromPool => {
-                msg!("Instruction: RemoveValidatorFromPool");
-                Self::process_remove_validator_from_pool(program_id, accounts)
-            }
-            StakePoolInstruction::DecreaseValidatorStake {
-                lamports,
-                transient_stake_seed,
-            } => {
-                msg!("Instruction: DecreaseValidatorStake");
-                msg!("NOTE: This instruction is deprecated, please use `DecreaseValidatorStakeWithReserve`");
-                Self::process_decrease_validator_stake(
-                    program_id,
-                    accounts,
-                    lamports,
-                    transient_stake_seed,
-                    None,
-                    false,
-                )
-            }
-            StakePoolInstruction::DecreaseValidatorStakeWithReserve {
-                lamports,
-                transient_stake_seed,
-            } => {
-                msg!("Instruction: DecreaseValidatorStakeWithReserve");
-                Self::process_decrease_validator_stake(
-                    program_id,
-                    accounts,
-                    lamports,
-                    transient_stake_seed,
-                    None,
-                    true,
-                )
-            }
-            StakePoolInstruction::DecreaseAdditionalValidatorStake {
-                lamports,
-                transient_stake_seed,
-                ephemeral_stake_seed,
-            } => {
-                msg!("Instruction: DecreaseAdditionalValidatorStake");
-                Self::process_decrease_validator_stake(
-                    program_id,
-                    accounts,
-                    lamports,
-                    transient_stake_seed,
-                    Some(ephemeral_stake_seed),
-                    true,
-                )
-            }
-            StakePoolInstruction::IncreaseValidatorStake {
-                lamports,
-                transient_stake_seed,
-            } => {
-                msg!("Instruction: IncreaseValidatorStake");
-                Self::process_increase_validator_stake(
-                    program_id,
-                    accounts,
-                    lamports,
-                    transient_stake_seed,
-                    None,
-                )
-            }
-            StakePoolInstruction::IncreaseAdditionalValidatorStake {
-                lamports,
-                transient_stake_seed,
-                ephemeral_stake_seed,
-            } => {
-                msg!("Instruction: IncreaseAdditionalValidatorStake");
-                Self::process_increase_validator_stake(
-                    program_id,
-                    accounts,
-                    lamports,
-                    transient_stake_seed,
-                    Some(ephemeral_stake_seed),
-                )
-            }
-            StakePoolInstruction::SetPreferredValidator {
-                validator_type,
-                validator_vote_address,
-            } => {
-                msg!("Instruction: SetPreferredValidator");
-                Self::process_set_preferred_validator(
-                    program_id,
-                    accounts,
-                    validator_type,
-                    validator_vote_address,
-                )
-            }
-            StakePoolInstruction::UpdateValidatorListBalance {
-                start_index,
-                no_merge,
-            } => {
-                msg!("Instruction: UpdateValidatorListBalance");
-                Self::process_update_validator_list_balance(
-                    program_id,
-                    accounts,
-                    start_index,
-                    no_merge,
-                )
-            }
-            StakePoolInstruction::UpdateStakePoolBalance => {
-                msg!("Instruction: UpdateStakePoolBalance");
-                Self::process_update_stake_pool_balance(program_id, accounts)
-            }
-            StakePoolInstruction::CleanupRemovedValidatorEntries => {
-                msg!("Instruction: CleanupRemovedValidatorEntries");
-                Self::process_cleanup_removed_validator_entries(program_id, accounts)
-            }
-            StakePoolInstruction::DepositStake => {
-                msg!("Instruction: DepositStake");
-                Self::process_deposit_stake(program_id, accounts, None)
-            }
-            StakePoolInstruction::WithdrawStake(amount) => {
-                msg!("Instruction: WithdrawStake");
-                Self::process_withdraw_stake(program_id, accounts, amount, None)
-            }
-            StakePoolInstruction::SetFee { fee } => {
-                msg!("Instruction: SetFee");
-                Self::process_set_fee(program_id, accounts, fee)
-            }
-            StakePoolInstruction::SetManager => {
-                msg!("Instruction: SetManager");
-                Self::process_set_manager(program_id, accounts)
-            }
-            StakePoolInstruction::SetStaker => {
-                msg!("Instruction: SetStaker");
-                Self::process_set_staker(program_id, accounts)
-            }
-            StakePoolInstruction::SetFundingAuthority(funding_type) => {
-                msg!("Instruction: SetFundingAuthority");
-                Self::process_set_funding_authority(program_id, accounts, funding_type)
-            }
-            StakePoolInstruction::DepositSol(lamports) => {
-                msg!("Instruction: DepositSol");
-                Self::process_deposit_sol(program_id, accounts, lamports, None)
-            }
-            StakePoolInstruction::WithdrawSol(pool_tokens) => {
-                msg!("Instruction: WithdrawSol");
-                Self::process_withdraw_sol(program_id, accounts, pool_tokens, None)
-            }
-            StakePoolInstruction::CreateTokenMetadata { name, symbol, uri } => {
-                msg!("Instruction: CreateTokenMetadata");
-                Self::process_create_pool_token_metadata(program_id, accounts, name, symbol, uri)
-            }
-            StakePoolInstruction::UpdateTokenMetadata { name, symbol, uri } => {
-                msg!("Instruction: UpdateTokenMetadata");
-                Self::process_update_pool_token_metadata(program_id, accounts, name, symbol, uri)
-            }
-            StakePoolInstruction::Redelegate {
-                lamports,
-                source_transient_stake_seed,
-                ephemeral_stake_seed,
-                destination_transient_stake_seed,
-            } => {
-                msg!("Instruction: Redelegate");
-                Self::process_redelegate(
-                    program_id,
-                    accounts,
-                    lamports,
-                    source_transient_stake_seed,
-                    ephemeral_stake_seed,
-                    destination_transient_stake_seed,
-                )
-            }
-            StakePoolInstruction::DepositStakeWithSlippage {
-                minimum_pool_tokens_out,
-            } => {
-                msg!("Instruction: DepositStakeWithSlippage");
-                Self::process_deposit_stake(program_id, accounts, Some(minimum_pool_tokens_out))
-            }
-            StakePoolInstruction::WithdrawStakeWithSlippage {
-                pool_tokens_in,
-                minimum_lamports_out,
-            } => {
-                msg!("Instruction: WithdrawStakeWithSlippage");
-                Self::process_withdraw_stake(
-                    program_id,
-                    accounts,
-                    pool_tokens_in,
-                    Some(minimum_lamports_out),
-                )
-            }
-            StakePoolInstruction::DepositSolWithSlippage {
-                lamports_in,
-                minimum_pool_tokens_out,
-            } => {
-                msg!("Instruction: DepositSolWithSlippage");
-                Self::process_deposit_sol(
-                    program_id,
-                    accounts,
-                    lamports_in,
-                    Some(minimum_pool_tokens_out),
-                )
-            }
-            StakePoolInstruction::WithdrawSolWithSlippage {
-                pool_tokens_in,
-                minimum_lamports_out,
-            } => {
-                msg!("Instruction: WithdrawSolWithSlippage");
-                Self::process_withdraw_sol(
-                    program_id,
-                    accounts,
-                    pool_tokens_in,
-                    Some(minimum_lamports_out),
-                )
-            }
-        }
-    }
-}
-
-impl PrintProgramError for StakePoolError {
-    fn print<E>(&self)
-    where
-        E: 'static + std::error::Error + DecodeError<E> + PrintProgramError + FromPrimitive,
-    {
-        match self {
-            StakePoolError::AlreadyInUse => msg!("Error: The account cannot be initialized because it is already being used"),
-            StakePoolError::InvalidProgramAddress => msg!("Error: The program address provided doesn't match the value generated by the program"),
-            StakePoolError::InvalidState => msg!("Error: The stake pool state is invalid"),
-            StakePoolError::CalculationFailure => msg!("Error: The calculation failed"),
-            StakePoolError::FeeTooHigh => msg!("Error: Stake pool fee > 1"),
-            StakePoolError::WrongAccountMint => msg!("Error: Token account is associated with the wrong mint"),
-            StakePoolError::WrongManager => msg!("Error: Wrong pool manager account"),
-            StakePoolError::SignatureMissing => msg!("Error: Required signature is missing"),
-            StakePoolError::InvalidValidatorStakeList => msg!("Error: Invalid validator stake list account"),
-            StakePoolError::InvalidFeeAccount => msg!("Error: Invalid manager fee account"),
-            StakePoolError::WrongPoolMint => msg!("Error: Specified pool mint account is wrong"),
-            StakePoolError::WrongStakeStake => msg!("Error: Stake account is not in the state expected by the program"),
-            StakePoolError::UserStakeNotActive => msg!("Error: User stake is not active"),
-            StakePoolError::ValidatorAlreadyAdded => msg!("Error: Stake account voting for this validator already exists in the pool"),
-            StakePoolError::ValidatorNotFound => msg!("Error: Stake account for this validator not found in the pool"),
-            StakePoolError::InvalidStakeAccountAddress => msg!("Error: Stake account address not properly derived from the validator address"),
-            StakePoolError::StakeListOutOfDate => msg!("Error: Identify validator stake accounts with old balances and update them"),
-            StakePoolError::StakeListAndPoolOutOfDate => msg!("Error: First update old validator stake account balances and then pool stake balance"),
-            StakePoolError::UnknownValidatorStakeAccount => {
-                msg!("Error: Validator stake account is not found in the list storage")
-            }
-            StakePoolError::WrongMintingAuthority => msg!("Error: Wrong minting authority set for mint pool account"),
-            StakePoolError::UnexpectedValidatorListAccountSize=> msg!("Error: The size of the given validator stake list does match the expected amount"),
-            StakePoolError::WrongStaker=> msg!("Error: Wrong pool staker account"),
-            StakePoolError::NonZeroPoolTokenSupply => msg!("Error: Pool token supply is not zero on initialization"),
-            StakePoolError::StakeLamportsNotEqualToMinimum => msg!("Error: The lamports in the validator stake account is not equal to the minimum"),
-            StakePoolError::IncorrectDepositVoteAddress => msg!("Error: The provided deposit stake account is not delegated to the preferred deposit vote account"),
-            StakePoolError::IncorrectWithdrawVoteAddress => msg!("Error: The provided withdraw stake account is not the preferred deposit vote account"),
-            StakePoolError::InvalidMintFreezeAuthority => msg!("Error: The mint has an invalid freeze authority"),
-            StakePoolError::FeeIncreaseTooHigh => msg!("Error: The fee cannot increase by a factor exceeding the stipulated ratio"),
-            StakePoolError::WithdrawalTooSmall => msg!("Error: Not enough pool tokens provided to withdraw 1-lamport stake"),
-            StakePoolError::DepositTooSmall => msg!("Error: Not enough lamports provided for deposit to result in one pool token"),
-            StakePoolError::InvalidStakeDepositAuthority => msg!("Error: Provided stake deposit authority does not match the program's"),
-            StakePoolError::InvalidSolDepositAuthority => msg!("Error: Provided sol deposit authority does not match the program's"),
-            StakePoolError::InvalidPreferredValidator => msg!("Error: Provided preferred validator is invalid"),
-            StakePoolError::TransientAccountInUse => msg!("Error: Provided validator stake account already has a transient stake account in use"),
-            StakePoolError::InvalidSolWithdrawAuthority => msg!("Error: Provided sol withdraw authority does not match the program's"),
-            StakePoolError::SolWithdrawalTooLarge => msg!("Error: Too much SOL withdrawn from the stake pool's reserve account"),
-            StakePoolError::InvalidMetadataAccount => msg!("Error: Metadata account derived from pool mint account does not match the one passed to program"),
-            StakePoolError::UnsupportedMintExtension => msg!("Error: mint has an unsupported extension"),
-            StakePoolError::UnsupportedFeeAccountExtension => msg!("Error: fee account has an unsupported extension"),
-            StakePoolError::ExceededSlippage => msg!("Error: instruction exceeds desired slippage limit"),
-            StakePoolError::IncorrectMintDecimals => msg!("Error: Provided mint does not have 9 decimals to match SOL"),
-            StakePoolError::ReserveDepleted => msg!("Error: Pool reserve does not have enough lamports to fund rent-exempt reserve in split destination. Deposit more SOL in reserve, or pre-fund split destination with the rent-exempt reserve for a stake account."),
-            StakePoolError::MissingRequiredSysvar => msg!("Missing required sysvar account"),
-        }
-    }
-}
diff --git a/stake-pool/program/src/state.rs b/stake-pool/program/src/state.rs
deleted file mode 100644
index e2b79d535db..00000000000
--- a/stake-pool/program/src/state.rs
+++ /dev/null
@@ -1,1466 +0,0 @@
-//! State transition types
-
-use {
-    crate::{
-        big_vec::BigVec, error::StakePoolError, MAX_WITHDRAWAL_FEE_INCREASE,
-        WITHDRAWAL_BASELINE_FEE,
-    },
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    bytemuck::{Pod, Zeroable},
-    num_derive::{FromPrimitive, ToPrimitive},
-    num_traits::{FromPrimitive, ToPrimitive},
-    solana_program::{
-        account_info::AccountInfo,
-        borsh1::get_instance_packed_len,
-        msg,
-        program_error::ProgramError,
-        program_memory::sol_memcmp,
-        program_pack::{Pack, Sealed},
-        pubkey::{Pubkey, PUBKEY_BYTES},
-        stake::state::Lockup,
-    },
-    spl_pod::primitives::{PodU32, PodU64},
-    spl_token_2022::{
-        extension::{BaseStateWithExtensions, ExtensionType, StateWithExtensions},
-        state::{Account, AccountState, Mint},
-    },
-    std::{borrow::Borrow, convert::TryFrom, fmt, matches},
-};
-
-/// Enum representing the account type managed by the program
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub enum AccountType {
-    /// If the account has not been initialized, the enum will be 0
-    #[default]
-    Uninitialized,
-    /// Stake pool
-    StakePool,
-    /// Validator stake list
-    ValidatorList,
-}
-
-/// Initialized program details.
-#[repr(C)]
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub struct StakePool {
-    /// Account type, must be StakePool currently
-    pub account_type: AccountType,
-
-    /// Manager authority, allows for updating the staker, manager, and fee
-    /// account
-    pub manager: Pubkey,
-
-    /// Staker authority, allows for adding and removing validators, and
-    /// managing stake distribution
-    pub staker: Pubkey,
-
-    /// Stake deposit authority
-    ///
-    /// If a depositor pubkey is specified on initialization, then deposits must
-    /// be signed by this authority. If no deposit authority is specified,
-    /// then the stake pool will default to the result of:
-    /// `Pubkey::find_program_address(
-    ///     &[&stake_pool_address.as_ref(), b"deposit"],
-    ///     program_id,
-    /// )`
-    pub stake_deposit_authority: Pubkey,
-
-    /// Stake withdrawal authority bump seed
-    /// for `create_program_address(&[state::StakePool account, "withdrawal"])`
-    pub stake_withdraw_bump_seed: u8,
-
-    /// Validator stake list storage account
-    pub validator_list: Pubkey,
-
-    /// Reserve stake account, holds deactivated stake
-    pub reserve_stake: Pubkey,
-
-    /// Pool Mint
-    pub pool_mint: Pubkey,
-
-    /// Manager fee account
-    pub manager_fee_account: Pubkey,
-
-    /// Pool token program id
-    pub token_program_id: Pubkey,
-
-    /// Total stake under management.
-    /// Note that if `last_update_epoch` does not match the current epoch then
-    /// this field may not be accurate
-    pub total_lamports: u64,
-
-    /// Total supply of pool tokens (should always match the supply in the Pool
-    /// Mint)
-    pub pool_token_supply: u64,
-
-    /// Last epoch the `total_lamports` field was updated
-    pub last_update_epoch: u64,
-
-    /// Lockup that all stakes in the pool must have
-    pub lockup: Lockup,
-
-    /// Fee taken as a proportion of rewards each epoch
-    pub epoch_fee: Fee,
-
-    /// Fee for next epoch
-    pub next_epoch_fee: FutureEpoch<Fee>,
-
-    /// Preferred deposit validator vote account pubkey
-    pub preferred_deposit_validator_vote_address: Option<Pubkey>,
-
-    /// Preferred withdraw validator vote account pubkey
-    pub preferred_withdraw_validator_vote_address: Option<Pubkey>,
-
-    /// Fee assessed on stake deposits
-    pub stake_deposit_fee: Fee,
-
-    /// Fee assessed on withdrawals
-    pub stake_withdrawal_fee: Fee,
-
-    /// Future stake withdrawal fee, to be set for the following epoch
-    pub next_stake_withdrawal_fee: FutureEpoch<Fee>,
-
-    /// Fees paid out to referrers on referred stake deposits.
-    /// Expressed as a percentage (0 - 100) of deposit fees.
-    /// i.e. `stake_deposit_fee`% of stake deposited is collected as deposit
-    /// fees for every deposit and `stake_referral_fee`% of the collected
-    /// stake deposit fees is paid out to the referrer
-    pub stake_referral_fee: u8,
-
-    /// Toggles whether the `DepositSol` instruction requires a signature from
-    /// this `sol_deposit_authority`
-    pub sol_deposit_authority: Option<Pubkey>,
-
-    /// Fee assessed on SOL deposits
-    pub sol_deposit_fee: Fee,
-
-    /// Fees paid out to referrers on referred SOL deposits.
-    /// Expressed as a percentage (0 - 100) of SOL deposit fees.
-    /// i.e. `sol_deposit_fee`% of SOL deposited is collected as deposit fees
-    /// for every deposit and `sol_referral_fee`% of the collected SOL
-    /// deposit fees is paid out to the referrer
-    pub sol_referral_fee: u8,
-
-    /// Toggles whether the `WithdrawSol` instruction requires a signature from
-    /// the `deposit_authority`
-    pub sol_withdraw_authority: Option<Pubkey>,
-
-    /// Fee assessed on SOL withdrawals
-    pub sol_withdrawal_fee: Fee,
-
-    /// Future SOL withdrawal fee, to be set for the following epoch
-    pub next_sol_withdrawal_fee: FutureEpoch<Fee>,
-
-    /// Last epoch's total pool tokens, used only for APR estimation
-    pub last_epoch_pool_token_supply: u64,
-
-    /// Last epoch's total lamports, used only for APR estimation
-    pub last_epoch_total_lamports: u64,
-}
-impl StakePool {
-    /// calculate the pool tokens that should be minted for a deposit of
-    /// `stake_lamports`
-    #[inline]
-    pub fn calc_pool_tokens_for_deposit(&self, stake_lamports: u64) -> Option<u64> {
-        if self.total_lamports == 0 || self.pool_token_supply == 0 {
-            return Some(stake_lamports);
-        }
-        u64::try_from(
-            (stake_lamports as u128)
-                .checked_mul(self.pool_token_supply as u128)?
-                .checked_div(self.total_lamports as u128)?,
-        )
-        .ok()
-    }
-
-    /// calculate lamports amount on withdrawal
-    #[inline]
-    pub fn calc_lamports_withdraw_amount(&self, pool_tokens: u64) -> Option<u64> {
-        // `checked_div` returns `None` for a 0 quotient result, but in this
-        // case, a return of 0 is valid for small amounts of pool tokens. So
-        // we check for that separately
-        let numerator = (pool_tokens as u128).checked_mul(self.total_lamports as u128)?;
-        let denominator = self.pool_token_supply as u128;
-        if numerator < denominator || denominator == 0 {
-            Some(0)
-        } else {
-            u64::try_from(numerator.checked_div(denominator)?).ok()
-        }
-    }
-
-    /// calculate pool tokens to be deducted as withdrawal fees
-    #[inline]
-    pub fn calc_pool_tokens_stake_withdrawal_fee(&self, pool_tokens: u64) -> Option<u64> {
-        u64::try_from(self.stake_withdrawal_fee.apply(pool_tokens)?).ok()
-    }
-
-    /// calculate pool tokens to be deducted as withdrawal fees
-    #[inline]
-    pub fn calc_pool_tokens_sol_withdrawal_fee(&self, pool_tokens: u64) -> Option<u64> {
-        u64::try_from(self.sol_withdrawal_fee.apply(pool_tokens)?).ok()
-    }
-
-    /// calculate pool tokens to be deducted as stake deposit fees
-    #[inline]
-    pub fn calc_pool_tokens_stake_deposit_fee(&self, pool_tokens_minted: u64) -> Option<u64> {
-        u64::try_from(self.stake_deposit_fee.apply(pool_tokens_minted)?).ok()
-    }
-
-    /// calculate pool tokens to be deducted from deposit fees as referral fees
-    #[inline]
-    pub fn calc_pool_tokens_stake_referral_fee(&self, stake_deposit_fee: u64) -> Option<u64> {
-        u64::try_from(
-            (stake_deposit_fee as u128)
-                .checked_mul(self.stake_referral_fee as u128)?
-                .checked_div(100u128)?,
-        )
-        .ok()
-    }
-
-    /// calculate pool tokens to be deducted as SOL deposit fees
-    #[inline]
-    pub fn calc_pool_tokens_sol_deposit_fee(&self, pool_tokens_minted: u64) -> Option<u64> {
-        u64::try_from(self.sol_deposit_fee.apply(pool_tokens_minted)?).ok()
-    }
-
-    /// calculate pool tokens to be deducted from SOL deposit fees as referral
-    /// fees
-    #[inline]
-    pub fn calc_pool_tokens_sol_referral_fee(&self, sol_deposit_fee: u64) -> Option<u64> {
-        u64::try_from(
-            (sol_deposit_fee as u128)
-                .checked_mul(self.sol_referral_fee as u128)?
-                .checked_div(100u128)?,
-        )
-        .ok()
-    }
-
-    /// Calculate the fee in pool tokens that goes to the manager
-    ///
-    /// This function assumes that `reward_lamports` has not already been added
-    /// to the stake pool's `total_lamports`
-    #[inline]
-    pub fn calc_epoch_fee_amount(&self, reward_lamports: u64) -> Option<u64> {
-        if reward_lamports == 0 {
-            return Some(0);
-        }
-        let total_lamports = (self.total_lamports as u128).checked_add(reward_lamports as u128)?;
-        let fee_lamports = self.epoch_fee.apply(reward_lamports)?;
-        if total_lamports == fee_lamports || self.pool_token_supply == 0 {
-            Some(reward_lamports)
-        } else {
-            u64::try_from(
-                (self.pool_token_supply as u128)
-                    .checked_mul(fee_lamports)?
-                    .checked_div(total_lamports.checked_sub(fee_lamports)?)?,
-            )
-            .ok()
-        }
-    }
-
-    /// Get the current value of pool tokens, rounded up
-    #[inline]
-    pub fn get_lamports_per_pool_token(&self) -> Option<u64> {
-        self.total_lamports
-            .checked_add(self.pool_token_supply)?
-            .checked_sub(1)?
-            .checked_div(self.pool_token_supply)
-    }
-
-    /// Checks that the withdraw or deposit authority is valid
-    fn check_program_derived_authority(
-        authority_address: &Pubkey,
-        program_id: &Pubkey,
-        stake_pool_address: &Pubkey,
-        authority_seed: &[u8],
-        bump_seed: u8,
-    ) -> Result<(), ProgramError> {
-        let expected_address = Pubkey::create_program_address(
-            &[stake_pool_address.as_ref(), authority_seed, &[bump_seed]],
-            program_id,
-        )?;
-
-        if *authority_address == expected_address {
-            Ok(())
-        } else {
-            msg!(
-                "Incorrect authority provided, expected {}, received {}",
-                expected_address,
-                authority_address
-            );
-            Err(StakePoolError::InvalidProgramAddress.into())
-        }
-    }
-
-    /// Check if the manager fee info is a valid token program account
-    /// capable of receiving tokens from the mint.
-    pub(crate) fn check_manager_fee_info(
-        &self,
-        manager_fee_info: &AccountInfo,
-    ) -> Result<(), ProgramError> {
-        let account_data = manager_fee_info.try_borrow_data()?;
-        let token_account = StateWithExtensions::<Account>::unpack(&account_data)?;
-        if manager_fee_info.owner != &self.token_program_id
-            || token_account.base.state != AccountState::Initialized
-            || token_account.base.mint != self.pool_mint
-        {
-            msg!("Manager fee account is not owned by token program, is not initialized, or does not match stake pool's mint");
-            return Err(StakePoolError::InvalidFeeAccount.into());
-        }
-        let extensions = token_account.get_extension_types()?;
-        if extensions
-            .iter()
-            .any(|x| !is_extension_supported_for_fee_account(x))
-        {
-            return Err(StakePoolError::UnsupportedFeeAccountExtension.into());
-        }
-        Ok(())
-    }
-
-    /// Checks that the withdraw authority is valid
-    #[inline]
-    pub(crate) fn check_authority_withdraw(
-        &self,
-        withdraw_authority: &Pubkey,
-        program_id: &Pubkey,
-        stake_pool_address: &Pubkey,
-    ) -> Result<(), ProgramError> {
-        Self::check_program_derived_authority(
-            withdraw_authority,
-            program_id,
-            stake_pool_address,
-            crate::AUTHORITY_WITHDRAW,
-            self.stake_withdraw_bump_seed,
-        )
-    }
-    /// Checks that the deposit authority is valid
-    #[inline]
-    pub(crate) fn check_stake_deposit_authority(
-        &self,
-        stake_deposit_authority: &Pubkey,
-    ) -> Result<(), ProgramError> {
-        if self.stake_deposit_authority == *stake_deposit_authority {
-            Ok(())
-        } else {
-            Err(StakePoolError::InvalidStakeDepositAuthority.into())
-        }
-    }
-
-    /// Checks that the deposit authority is valid
-    /// Does nothing if `sol_deposit_authority` is currently not set
-    #[inline]
-    pub(crate) fn check_sol_deposit_authority(
-        &self,
-        maybe_sol_deposit_authority: Result<&AccountInfo, ProgramError>,
-    ) -> Result<(), ProgramError> {
-        if let Some(auth) = self.sol_deposit_authority {
-            let sol_deposit_authority = maybe_sol_deposit_authority?;
-            if auth != *sol_deposit_authority.key {
-                msg!("Expected {}, received {}", auth, sol_deposit_authority.key);
-                return Err(StakePoolError::InvalidSolDepositAuthority.into());
-            }
-            if !sol_deposit_authority.is_signer {
-                msg!("SOL Deposit authority signature missing");
-                return Err(StakePoolError::SignatureMissing.into());
-            }
-        }
-        Ok(())
-    }
-
-    /// Checks that the sol withdraw authority is valid
-    /// Does nothing if `sol_withdraw_authority` is currently not set
-    #[inline]
-    pub(crate) fn check_sol_withdraw_authority(
-        &self,
-        maybe_sol_withdraw_authority: Result<&AccountInfo, ProgramError>,
-    ) -> Result<(), ProgramError> {
-        if let Some(auth) = self.sol_withdraw_authority {
-            let sol_withdraw_authority = maybe_sol_withdraw_authority?;
-            if auth != *sol_withdraw_authority.key {
-                return Err(StakePoolError::InvalidSolWithdrawAuthority.into());
-            }
-            if !sol_withdraw_authority.is_signer {
-                msg!("SOL withdraw authority signature missing");
-                return Err(StakePoolError::SignatureMissing.into());
-            }
-        }
-        Ok(())
-    }
-
-    /// Check mint is correct
-    #[inline]
-    pub(crate) fn check_mint(&self, mint_info: &AccountInfo) -> Result<u8, ProgramError> {
-        if *mint_info.key != self.pool_mint {
-            Err(StakePoolError::WrongPoolMint.into())
-        } else {
-            let mint_data = mint_info.try_borrow_data()?;
-            let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-            Ok(mint.base.decimals)
-        }
-    }
-
-    /// Check manager validity and signature
-    pub(crate) fn check_manager(&self, manager_info: &AccountInfo) -> Result<(), ProgramError> {
-        if *manager_info.key != self.manager {
-            msg!(
-                "Incorrect manager provided, expected {}, received {}",
-                self.manager,
-                manager_info.key
-            );
-            return Err(StakePoolError::WrongManager.into());
-        }
-        if !manager_info.is_signer {
-            msg!("Manager signature missing");
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-        Ok(())
-    }
-
-    /// Check staker validity and signature
-    pub(crate) fn check_staker(&self, staker_info: &AccountInfo) -> Result<(), ProgramError> {
-        if *staker_info.key != self.staker {
-            msg!(
-                "Incorrect staker provided, expected {}, received {}",
-                self.staker,
-                staker_info.key
-            );
-            return Err(StakePoolError::WrongStaker.into());
-        }
-        if !staker_info.is_signer {
-            msg!("Staker signature missing");
-            return Err(StakePoolError::SignatureMissing.into());
-        }
-        Ok(())
-    }
-
-    /// Check the validator list is valid
-    pub fn check_validator_list(
-        &self,
-        validator_list_info: &AccountInfo,
-    ) -> Result<(), ProgramError> {
-        if *validator_list_info.key != self.validator_list {
-            msg!(
-                "Invalid validator list provided, expected {}, received {}",
-                self.validator_list,
-                validator_list_info.key
-            );
-            Err(StakePoolError::InvalidValidatorStakeList.into())
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Check the reserve stake is valid
-    pub fn check_reserve_stake(
-        &self,
-        reserve_stake_info: &AccountInfo,
-    ) -> Result<(), ProgramError> {
-        if *reserve_stake_info.key != self.reserve_stake {
-            msg!(
-                "Invalid reserve stake provided, expected {}, received {}",
-                self.reserve_stake,
-                reserve_stake_info.key
-            );
-            Err(StakePoolError::InvalidProgramAddress.into())
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Check if StakePool is actually initialized as a stake pool
-    pub fn is_valid(&self) -> bool {
-        self.account_type == AccountType::StakePool
-    }
-
-    /// Check if StakePool is currently uninitialized
-    pub fn is_uninitialized(&self) -> bool {
-        self.account_type == AccountType::Uninitialized
-    }
-
-    /// Updates one of the StakePool's fees.
-    pub fn update_fee(&mut self, fee: &FeeType) -> Result<(), StakePoolError> {
-        match fee {
-            FeeType::SolReferral(new_fee) => self.sol_referral_fee = *new_fee,
-            FeeType::StakeReferral(new_fee) => self.stake_referral_fee = *new_fee,
-            FeeType::Epoch(new_fee) => self.next_epoch_fee = FutureEpoch::new(*new_fee),
-            FeeType::StakeWithdrawal(new_fee) => {
-                new_fee.check_withdrawal(&self.stake_withdrawal_fee)?;
-                self.next_stake_withdrawal_fee = FutureEpoch::new(*new_fee)
-            }
-            FeeType::SolWithdrawal(new_fee) => {
-                new_fee.check_withdrawal(&self.sol_withdrawal_fee)?;
-                self.next_sol_withdrawal_fee = FutureEpoch::new(*new_fee)
-            }
-            FeeType::SolDeposit(new_fee) => self.sol_deposit_fee = *new_fee,
-            FeeType::StakeDeposit(new_fee) => self.stake_deposit_fee = *new_fee,
-        };
-        Ok(())
-    }
-}
-
-/// Checks if the given extension is supported for the stake pool mint
-pub fn is_extension_supported_for_mint(extension_type: &ExtensionType) -> bool {
-    const SUPPORTED_EXTENSIONS: [ExtensionType; 8] = [
-        ExtensionType::Uninitialized,
-        ExtensionType::TransferFeeConfig,
-        ExtensionType::ConfidentialTransferMint,
-        ExtensionType::ConfidentialTransferFeeConfig,
-        ExtensionType::DefaultAccountState, // ok, but a freeze authority is not
-        ExtensionType::InterestBearingConfig,
-        ExtensionType::MetadataPointer,
-        ExtensionType::TokenMetadata,
-    ];
-    if !SUPPORTED_EXTENSIONS.contains(extension_type) {
-        msg!(
-            "Stake pool mint account cannot have the {:?} extension",
-            extension_type
-        );
-        false
-    } else {
-        true
-    }
-}
-
-/// Checks if the given extension is supported for the stake pool's fee account
-pub fn is_extension_supported_for_fee_account(extension_type: &ExtensionType) -> bool {
-    // Note: this does not include the `ConfidentialTransferAccount` extension
-    // because it is possible to block non-confidential transfers with the
-    // extension enabled.
-    const SUPPORTED_EXTENSIONS: [ExtensionType; 4] = [
-        ExtensionType::Uninitialized,
-        ExtensionType::TransferFeeAmount,
-        ExtensionType::ImmutableOwner,
-        ExtensionType::CpiGuard,
-    ];
-    if !SUPPORTED_EXTENSIONS.contains(extension_type) {
-        msg!("Fee account cannot have the {:?} extension", extension_type);
-        false
-    } else {
-        true
-    }
-}
-
-/// Storage list for all validator stake accounts in the pool.
-#[repr(C)]
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub struct ValidatorList {
-    /// Data outside of the validator list, separated out for cheaper
-    /// deserializations
-    pub header: ValidatorListHeader,
-
-    /// List of stake info for each validator in the pool
-    pub validators: Vec<ValidatorStakeInfo>,
-}
-
-/// Helper type to deserialize just the start of a ValidatorList
-#[repr(C)]
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub struct ValidatorListHeader {
-    /// Account type, must be ValidatorList currently
-    pub account_type: AccountType,
-
-    /// Maximum allowable number of validators
-    pub max_validators: u32,
-}
-
-/// Status of the stake account in the validator list, for accounting
-#[derive(
-    ToPrimitive,
-    FromPrimitive,
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    BorshDeserialize,
-    BorshSerialize,
-    BorshSchema,
-)]
-pub enum StakeStatus {
-    /// Stake account is active, there may be a transient stake as well
-    Active,
-    /// Only transient stake account exists, when a transient stake is
-    /// deactivating during validator removal
-    DeactivatingTransient,
-    /// No more validator stake accounts exist, entry ready for removal during
-    /// `UpdateStakePoolBalance`
-    ReadyForRemoval,
-    /// Only the validator stake account is deactivating, no transient stake
-    /// account exists
-    DeactivatingValidator,
-    /// Both the transient and validator stake account are deactivating, when
-    /// a validator is removed with a transient stake active
-    DeactivatingAll,
-}
-impl Default for StakeStatus {
-    fn default() -> Self {
-        Self::Active
-    }
-}
-
-/// Wrapper struct that can be `Pod`, containing a byte that *should* be a valid
-/// `StakeStatus` underneath.
-#[repr(transparent)]
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Default,
-    PartialEq,
-    Pod,
-    Zeroable,
-    BorshDeserialize,
-    BorshSerialize,
-    BorshSchema,
-)]
-pub struct PodStakeStatus(u8);
-impl PodStakeStatus {
-    /// Downgrade the status towards ready for removal by removing the validator
-    /// stake
-    pub fn remove_validator_stake(&mut self) -> Result<(), ProgramError> {
-        let status = StakeStatus::try_from(*self)?;
-        let new_self = match status {
-            StakeStatus::Active
-            | StakeStatus::DeactivatingTransient
-            | StakeStatus::ReadyForRemoval => status,
-            StakeStatus::DeactivatingAll => StakeStatus::DeactivatingTransient,
-            StakeStatus::DeactivatingValidator => StakeStatus::ReadyForRemoval,
-        };
-        *self = new_self.into();
-        Ok(())
-    }
-    /// Downgrade the status towards ready for removal by removing the transient
-    /// stake
-    pub fn remove_transient_stake(&mut self) -> Result<(), ProgramError> {
-        let status = StakeStatus::try_from(*self)?;
-        let new_self = match status {
-            StakeStatus::Active
-            | StakeStatus::DeactivatingValidator
-            | StakeStatus::ReadyForRemoval => status,
-            StakeStatus::DeactivatingAll => StakeStatus::DeactivatingValidator,
-            StakeStatus::DeactivatingTransient => StakeStatus::ReadyForRemoval,
-        };
-        *self = new_self.into();
-        Ok(())
-    }
-}
-impl TryFrom<PodStakeStatus> for StakeStatus {
-    type Error = ProgramError;
-    fn try_from(pod: PodStakeStatus) -> Result<Self, Self::Error> {
-        FromPrimitive::from_u8(pod.0).ok_or(ProgramError::InvalidAccountData)
-    }
-}
-impl From<StakeStatus> for PodStakeStatus {
-    fn from(status: StakeStatus) -> Self {
-        // unwrap is safe here because the variants of `StakeStatus` fit very
-        // comfortably within a `u8`
-        PodStakeStatus(status.to_u8().unwrap())
-    }
-}
-
-/// Withdrawal type, figured out during process_withdraw_stake
-#[derive(Debug, PartialEq)]
-pub(crate) enum StakeWithdrawSource {
-    /// Some of an active stake account, but not all
-    Active,
-    /// Some of a transient stake account
-    Transient,
-    /// Take a whole validator stake account
-    ValidatorRemoval,
-}
-
-/// Information about a validator in the pool
-///
-/// NOTE: ORDER IS VERY IMPORTANT HERE, PLEASE DO NOT RE-ORDER THE FIELDS UNLESS
-/// THERE'S AN EXTREMELY GOOD REASON.
-///
-/// To save on BPF instructions, the serialized bytes are reinterpreted with a
-/// bytemuck transmute, which means that this structure cannot have any
-/// undeclared alignment-padding in its representation.
-#[repr(C)]
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Default,
-    PartialEq,
-    Pod,
-    Zeroable,
-    BorshDeserialize,
-    BorshSerialize,
-    BorshSchema,
-)]
-pub struct ValidatorStakeInfo {
-    /// Amount of lamports on the validator stake account, including rent
-    ///
-    /// Note that if `last_update_epoch` does not match the current epoch then
-    /// this field may not be accurate
-    pub active_stake_lamports: PodU64,
-
-    /// Amount of transient stake delegated to this validator
-    ///
-    /// Note that if `last_update_epoch` does not match the current epoch then
-    /// this field may not be accurate
-    pub transient_stake_lamports: PodU64,
-
-    /// Last epoch the active and transient stake lamports fields were updated
-    pub last_update_epoch: PodU64,
-
-    /// Transient account seed suffix, used to derive the transient stake
-    /// account address
-    pub transient_seed_suffix: PodU64,
-
-    /// Unused space, initially meant to specify the end of seed suffixes
-    pub unused: PodU32,
-
-    /// Validator account seed suffix
-    pub validator_seed_suffix: PodU32, // really `Option<NonZeroU32>` so 0 is `None`
-
-    /// Status of the validator stake account
-    pub status: PodStakeStatus,
-
-    /// Validator vote account address
-    pub vote_account_address: Pubkey,
-}
-
-impl ValidatorStakeInfo {
-    /// Get the total lamports on this validator (active and transient)
-    pub fn stake_lamports(&self) -> Result<u64, StakePoolError> {
-        u64::from(self.active_stake_lamports)
-            .checked_add(self.transient_stake_lamports.into())
-            .ok_or(StakePoolError::CalculationFailure)
-    }
-
-    /// Performs a very cheap comparison, for checking if this validator stake
-    /// info matches the vote account address
-    pub fn memcmp_pubkey(data: &[u8], vote_address: &Pubkey) -> bool {
-        sol_memcmp(
-            &data[41..41_usize.saturating_add(PUBKEY_BYTES)],
-            vote_address.as_ref(),
-            PUBKEY_BYTES,
-        ) == 0
-    }
-
-    /// Performs a comparison, used to check if this validator stake
-    /// info has more active lamports than some limit
-    pub fn active_lamports_greater_than(data: &[u8], lamports: &u64) -> bool {
-        // without this unwrap, compute usage goes up significantly
-        u64::try_from_slice(&data[0..8]).unwrap() > *lamports
-    }
-
-    /// Performs a comparison, used to check if this validator stake
-    /// info has more transient lamports than some limit
-    pub fn transient_lamports_greater_than(data: &[u8], lamports: &u64) -> bool {
-        // without this unwrap, compute usage goes up significantly
-        u64::try_from_slice(&data[8..16]).unwrap() > *lamports
-    }
-
-    /// Check that the validator stake info is valid
-    pub fn is_not_removed(data: &[u8]) -> bool {
-        FromPrimitive::from_u8(data[40]) != Some(StakeStatus::ReadyForRemoval)
-    }
-}
-
-impl Sealed for ValidatorStakeInfo {}
-
-impl Pack for ValidatorStakeInfo {
-    const LEN: usize = 73;
-    fn pack_into_slice(&self, data: &mut [u8]) {
-        let mut data = data;
-        // Removing this unwrap would require changing from `Pack` to some other
-        // trait or `bytemuck`, so it stays in for now
-        borsh::to_writer(&mut data, self).unwrap();
-    }
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let unpacked = Self::try_from_slice(src)?;
-        Ok(unpacked)
-    }
-}
-
-impl ValidatorList {
-    /// Create an empty instance containing space for `max_validators` and
-    /// preferred validator keys
-    pub fn new(max_validators: u32) -> Self {
-        Self {
-            header: ValidatorListHeader {
-                account_type: AccountType::ValidatorList,
-                max_validators,
-            },
-            validators: vec![ValidatorStakeInfo::default(); max_validators as usize],
-        }
-    }
-
-    /// Calculate the number of validator entries that fit in the provided
-    /// length
-    pub fn calculate_max_validators(buffer_length: usize) -> usize {
-        let header_size = ValidatorListHeader::LEN.saturating_add(4);
-        buffer_length
-            .saturating_sub(header_size)
-            .saturating_div(ValidatorStakeInfo::LEN)
-    }
-
-    /// Check if contains validator with particular pubkey
-    pub fn contains(&self, vote_account_address: &Pubkey) -> bool {
-        self.validators
-            .iter()
-            .any(|x| x.vote_account_address == *vote_account_address)
-    }
-
-    /// Check if contains validator with particular pubkey
-    pub fn find_mut(&mut self, vote_account_address: &Pubkey) -> Option<&mut ValidatorStakeInfo> {
-        self.validators
-            .iter_mut()
-            .find(|x| x.vote_account_address == *vote_account_address)
-    }
-    /// Check if contains validator with particular pubkey
-    pub fn find(&self, vote_account_address: &Pubkey) -> Option<&ValidatorStakeInfo> {
-        self.validators
-            .iter()
-            .find(|x| x.vote_account_address == *vote_account_address)
-    }
-
-    /// Check if the list has any active stake
-    pub fn has_active_stake(&self) -> bool {
-        self.validators
-            .iter()
-            .any(|x| u64::from(x.active_stake_lamports) > 0)
-    }
-}
-
-impl ValidatorListHeader {
-    const LEN: usize = 1 + 4;
-
-    /// Check if validator stake list is actually initialized as a validator
-    /// stake list
-    pub fn is_valid(&self) -> bool {
-        self.account_type == AccountType::ValidatorList
-    }
-
-    /// Check if the validator stake list is uninitialized
-    pub fn is_uninitialized(&self) -> bool {
-        self.account_type == AccountType::Uninitialized
-    }
-
-    /// Extracts a slice of ValidatorStakeInfo types from the vec part
-    /// of the ValidatorList
-    pub fn deserialize_mut_slice<'a>(
-        big_vec: &'a mut BigVec,
-        skip: usize,
-        len: usize,
-    ) -> Result<&'a mut [ValidatorStakeInfo], ProgramError> {
-        big_vec.deserialize_mut_slice::<ValidatorStakeInfo>(skip, len)
-    }
-
-    /// Extracts the validator list into its header and internal BigVec
-    pub fn deserialize_vec(data: &mut [u8]) -> Result<(Self, BigVec), ProgramError> {
-        let mut data_mut = data.borrow();
-        let header = ValidatorListHeader::deserialize(&mut data_mut)?;
-        let length = get_instance_packed_len(&header)?;
-
-        let big_vec = BigVec {
-            data: &mut data[length..],
-        };
-        Ok((header, big_vec))
-    }
-}
-
-/// Wrapper type that "counts down" epochs, which is Borsh-compatible with the
-/// native `Option`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
-pub enum FutureEpoch<T> {
-    /// Nothing is set
-    None,
-    /// Value is ready after the next epoch boundary
-    One(T),
-    /// Value is ready after two epoch boundaries
-    Two(T),
-}
-impl<T> Default for FutureEpoch<T> {
-    fn default() -> Self {
-        Self::None
-    }
-}
-impl<T> FutureEpoch<T> {
-    /// Create a new value to be unlocked in a two epochs
-    pub fn new(value: T) -> Self {
-        Self::Two(value)
-    }
-}
-impl<T: Clone> FutureEpoch<T> {
-    /// Update the epoch, to be done after `get`ting the underlying value
-    pub fn update_epoch(&mut self) {
-        match self {
-            Self::None => {}
-            Self::One(_) => {
-                // The value has waited its last epoch
-                *self = Self::None;
-            }
-            // The value still has to wait one more epoch after this
-            Self::Two(v) => {
-                *self = Self::One(v.clone());
-            }
-        }
-    }
-
-    /// Get the value if it's ready, which is only at `One` epoch remaining
-    pub fn get(&self) -> Option<&T> {
-        match self {
-            Self::None | Self::Two(_) => None,
-            Self::One(v) => Some(v),
-        }
-    }
-}
-impl<T> From<FutureEpoch<T>> for Option<T> {
-    fn from(v: FutureEpoch<T>) -> Option<T> {
-        match v {
-            FutureEpoch::None => None,
-            FutureEpoch::One(inner) | FutureEpoch::Two(inner) => Some(inner),
-        }
-    }
-}
-
-/// Fee rate as a ratio, minted on `UpdateStakePoolBalance` as a proportion of
-/// the rewards
-/// If either the numerator or the denominator is 0, the fee is considered to be
-/// 0
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
-pub struct Fee {
-    /// denominator of the fee ratio
-    pub denominator: u64,
-    /// numerator of the fee ratio
-    pub numerator: u64,
-}
-
-impl Fee {
-    /// Applies the Fee's rates to a given amount, `amt`
-    /// returning the amount to be subtracted from it as fees
-    /// (0 if denominator is 0 or amt is 0),
-    /// or None if overflow occurs
-    #[inline]
-    pub fn apply(&self, amt: u64) -> Option<u128> {
-        if self.denominator == 0 {
-            return Some(0);
-        }
-        let numerator = (amt as u128).checked_mul(self.numerator as u128)?;
-        // ceiling the calculation by adding (denominator - 1) to the numerator
-        let denominator = self.denominator as u128;
-        numerator
-            .checked_add(denominator)?
-            .checked_sub(1)?
-            .checked_div(denominator)
-    }
-
-    /// Withdrawal fees have some additional restrictions,
-    /// this fn checks if those are met, returning an error if not.
-    /// Does nothing and returns Ok if fee type is not withdrawal
-    pub fn check_withdrawal(&self, old_withdrawal_fee: &Fee) -> Result<(), StakePoolError> {
-        // If the previous withdrawal fee was 0, we allow the fee to be set to a
-        // maximum of (WITHDRAWAL_BASELINE_FEE * MAX_WITHDRAWAL_FEE_INCREASE)
-        let (old_num, old_denom) =
-            if old_withdrawal_fee.denominator == 0 || old_withdrawal_fee.numerator == 0 {
-                (
-                    WITHDRAWAL_BASELINE_FEE.numerator,
-                    WITHDRAWAL_BASELINE_FEE.denominator,
-                )
-            } else {
-                (old_withdrawal_fee.numerator, old_withdrawal_fee.denominator)
-            };
-
-        // Check that new_fee / old_fee <= MAX_WITHDRAWAL_FEE_INCREASE
-        // Program fails if provided numerator or denominator is too large, resulting in
-        // overflow
-        if (old_num as u128)
-            .checked_mul(self.denominator as u128)
-            .map(|x| x.checked_mul(MAX_WITHDRAWAL_FEE_INCREASE.numerator as u128))
-            .ok_or(StakePoolError::CalculationFailure)?
-            < (self.numerator as u128)
-                .checked_mul(old_denom as u128)
-                .map(|x| x.checked_mul(MAX_WITHDRAWAL_FEE_INCREASE.denominator as u128))
-                .ok_or(StakePoolError::CalculationFailure)?
-        {
-            msg!(
-                "Fee increase exceeds maximum allowed, proposed increase factor ({} / {})",
-                self.numerator.saturating_mul(old_denom),
-                old_num.saturating_mul(self.denominator),
-            );
-            return Err(StakePoolError::FeeIncreaseTooHigh);
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for Fee {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.numerator > 0 && self.denominator > 0 {
-            write!(f, "{}/{}", self.numerator, self.denominator)
-        } else {
-            write!(f, "none")
-        }
-    }
-}
-
-/// The type of fees that can be set on the stake pool
-#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub enum FeeType {
-    /// Referral fees for SOL deposits
-    SolReferral(u8),
-    /// Referral fees for stake deposits
-    StakeReferral(u8),
-    /// Management fee paid per epoch
-    Epoch(Fee),
-    /// Stake withdrawal fee
-    StakeWithdrawal(Fee),
-    /// Deposit fee for SOL deposits
-    SolDeposit(Fee),
-    /// Deposit fee for stake deposits
-    StakeDeposit(Fee),
-    /// SOL withdrawal fee
-    SolWithdrawal(Fee),
-}
-
-impl FeeType {
-    /// Checks if the provided fee is too high, returning an error if so
-    pub fn check_too_high(&self) -> Result<(), StakePoolError> {
-        let too_high = match self {
-            Self::SolReferral(pct) => *pct > 100u8,
-            Self::StakeReferral(pct) => *pct > 100u8,
-            Self::Epoch(fee) => fee.numerator > fee.denominator,
-            Self::StakeWithdrawal(fee) => fee.numerator > fee.denominator,
-            Self::SolWithdrawal(fee) => fee.numerator > fee.denominator,
-            Self::SolDeposit(fee) => fee.numerator > fee.denominator,
-            Self::StakeDeposit(fee) => fee.numerator > fee.denominator,
-        };
-        if too_high {
-            msg!("Fee greater than 100%: {:?}", self);
-            return Err(StakePoolError::FeeTooHigh);
-        }
-        Ok(())
-    }
-
-    /// Returns if the contained fee can only be updated earliest on the next
-    /// epoch
-    #[inline]
-    pub fn can_only_change_next_epoch(&self) -> bool {
-        matches!(
-            self,
-            Self::StakeWithdrawal(_) | Self::SolWithdrawal(_) | Self::Epoch(_)
-        )
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #![allow(clippy::arithmetic_side_effects)]
-    use {
-        super::*,
-        proptest::prelude::*,
-        solana_program::{
-            borsh1::{get_packed_len, try_from_slice_unchecked},
-            clock::{DEFAULT_SLOTS_PER_EPOCH, DEFAULT_S_PER_SLOT, SECONDS_PER_DAY},
-            native_token::LAMPORTS_PER_SOL,
-        },
-    };
-
-    fn uninitialized_validator_list() -> ValidatorList {
-        ValidatorList {
-            header: ValidatorListHeader {
-                account_type: AccountType::Uninitialized,
-                max_validators: 0,
-            },
-            validators: vec![],
-        }
-    }
-
-    fn test_validator_list(max_validators: u32) -> ValidatorList {
-        ValidatorList {
-            header: ValidatorListHeader {
-                account_type: AccountType::ValidatorList,
-                max_validators,
-            },
-            validators: vec![
-                ValidatorStakeInfo {
-                    status: StakeStatus::Active.into(),
-                    vote_account_address: Pubkey::new_from_array([1; 32]),
-                    active_stake_lamports: u64::from_le_bytes([255; 8]).into(),
-                    transient_stake_lamports: u64::from_le_bytes([128; 8]).into(),
-                    last_update_epoch: u64::from_le_bytes([64; 8]).into(),
-                    transient_seed_suffix: 0.into(),
-                    unused: 0.into(),
-                    validator_seed_suffix: 0.into(),
-                },
-                ValidatorStakeInfo {
-                    status: StakeStatus::DeactivatingTransient.into(),
-                    vote_account_address: Pubkey::new_from_array([2; 32]),
-                    active_stake_lamports: 998877665544.into(),
-                    transient_stake_lamports: 222222222.into(),
-                    last_update_epoch: 11223445566.into(),
-                    transient_seed_suffix: 0.into(),
-                    unused: 0.into(),
-                    validator_seed_suffix: 0.into(),
-                },
-                ValidatorStakeInfo {
-                    status: StakeStatus::ReadyForRemoval.into(),
-                    vote_account_address: Pubkey::new_from_array([3; 32]),
-                    active_stake_lamports: 0.into(),
-                    transient_stake_lamports: 0.into(),
-                    last_update_epoch: 999999999999999.into(),
-                    transient_seed_suffix: 0.into(),
-                    unused: 0.into(),
-                    validator_seed_suffix: 0.into(),
-                },
-            ],
-        }
-    }
-
-    #[test]
-    fn state_packing() {
-        let max_validators = 10_000;
-        let size = get_instance_packed_len(&ValidatorList::new(max_validators)).unwrap();
-        let stake_list = uninitialized_validator_list();
-        let mut byte_vec = vec![0u8; size];
-        let bytes = byte_vec.as_mut_slice();
-        borsh::to_writer(bytes, &stake_list).unwrap();
-        let stake_list_unpacked = try_from_slice_unchecked::<ValidatorList>(&byte_vec).unwrap();
-        assert_eq!(stake_list_unpacked, stake_list);
-
-        // Empty, one preferred key
-        let stake_list = ValidatorList {
-            header: ValidatorListHeader {
-                account_type: AccountType::ValidatorList,
-                max_validators: 0,
-            },
-            validators: vec![],
-        };
-        let mut byte_vec = vec![0u8; size];
-        let bytes = byte_vec.as_mut_slice();
-        borsh::to_writer(bytes, &stake_list).unwrap();
-        let stake_list_unpacked = try_from_slice_unchecked::<ValidatorList>(&byte_vec).unwrap();
-        assert_eq!(stake_list_unpacked, stake_list);
-
-        // With several accounts
-        let stake_list = test_validator_list(max_validators);
-        let mut byte_vec = vec![0u8; size];
-        let bytes = byte_vec.as_mut_slice();
-        borsh::to_writer(bytes, &stake_list).unwrap();
-        let stake_list_unpacked = try_from_slice_unchecked::<ValidatorList>(&byte_vec).unwrap();
-        assert_eq!(stake_list_unpacked, stake_list);
-    }
-
-    #[test]
-    fn validator_list_active_stake() {
-        let max_validators = 10_000;
-        let mut validator_list = test_validator_list(max_validators);
-        assert!(validator_list.has_active_stake());
-        for validator in validator_list.validators.iter_mut() {
-            validator.active_stake_lamports = 0.into();
-        }
-        assert!(!validator_list.has_active_stake());
-    }
-
-    #[test]
-    fn validator_list_deserialize_mut_slice() {
-        let max_validators = 10;
-        let stake_list = test_validator_list(max_validators);
-        let mut serialized = borsh::to_vec(&stake_list).unwrap();
-        let (header, mut big_vec) = ValidatorListHeader::deserialize_vec(&mut serialized).unwrap();
-        let list = ValidatorListHeader::deserialize_mut_slice(
-            &mut big_vec,
-            0,
-            stake_list.validators.len(),
-        )
-        .unwrap();
-        assert_eq!(header.account_type, AccountType::ValidatorList);
-        assert_eq!(header.max_validators, max_validators);
-        assert!(list
-            .iter()
-            .zip(stake_list.validators.iter())
-            .all(|(a, b)| a == b));
-
-        let list = ValidatorListHeader::deserialize_mut_slice(&mut big_vec, 1, 2).unwrap();
-        assert!(list
-            .iter()
-            .zip(stake_list.validators[1..].iter())
-            .all(|(a, b)| a == b));
-        let list = ValidatorListHeader::deserialize_mut_slice(&mut big_vec, 2, 1).unwrap();
-        assert!(list
-            .iter()
-            .zip(stake_list.validators[2..].iter())
-            .all(|(a, b)| a == b));
-        let list = ValidatorListHeader::deserialize_mut_slice(&mut big_vec, 0, 2).unwrap();
-        assert!(list
-            .iter()
-            .zip(stake_list.validators[..2].iter())
-            .all(|(a, b)| a == b));
-
-        assert_eq!(
-            ValidatorListHeader::deserialize_mut_slice(&mut big_vec, 0, 4).unwrap_err(),
-            ProgramError::AccountDataTooSmall
-        );
-        assert_eq!(
-            ValidatorListHeader::deserialize_mut_slice(&mut big_vec, 1, 3).unwrap_err(),
-            ProgramError::AccountDataTooSmall
-        );
-    }
-
-    #[test]
-    fn validator_list_iter() {
-        let max_validators = 10;
-        let stake_list = test_validator_list(max_validators);
-        let mut serialized = borsh::to_vec(&stake_list).unwrap();
-        let (_, big_vec) = ValidatorListHeader::deserialize_vec(&mut serialized).unwrap();
-        for (a, b) in big_vec
-            .deserialize_slice::<ValidatorStakeInfo>(0, big_vec.len() as usize)
-            .unwrap()
-            .iter()
-            .zip(stake_list.validators.iter())
-        {
-            assert_eq!(a, b);
-        }
-    }
-
-    proptest! {
-        #[test]
-        fn stake_list_size_calculation(test_amount in 0..=100_000_u32) {
-            let validators = ValidatorList::new(test_amount);
-            let size = get_instance_packed_len(&validators).unwrap();
-            assert_eq!(ValidatorList::calculate_max_validators(size), test_amount as usize);
-            assert_eq!(ValidatorList::calculate_max_validators(size.saturating_add(1)), test_amount as usize);
-            assert_eq!(ValidatorList::calculate_max_validators(size.saturating_add(get_packed_len::<ValidatorStakeInfo>())), (test_amount + 1)as usize);
-            assert_eq!(ValidatorList::calculate_max_validators(size.saturating_sub(1)), (test_amount.saturating_sub(1)) as usize);
-        }
-    }
-
-    prop_compose! {
-        fn fee()(denominator in 1..=u16::MAX)(
-            denominator in Just(denominator),
-            numerator in 0..=denominator,
-        ) -> (u64, u64) {
-            (numerator as u64, denominator as u64)
-        }
-    }
-
-    prop_compose! {
-        fn total_stake_and_rewards()(total_lamports in 1..u64::MAX)(
-            total_lamports in Just(total_lamports),
-            rewards in 0..=total_lamports,
-        ) -> (u64, u64) {
-            (total_lamports - rewards, rewards)
-        }
-    }
-
-    #[test]
-    fn specific_fee_calculation() {
-        // 10% of 10 SOL in rewards should be 1 SOL in fees
-        let epoch_fee = Fee {
-            numerator: 1,
-            denominator: 10,
-        };
-        let mut stake_pool = StakePool {
-            total_lamports: 100 * LAMPORTS_PER_SOL,
-            pool_token_supply: 100 * LAMPORTS_PER_SOL,
-            epoch_fee,
-            ..StakePool::default()
-        };
-        let reward_lamports = 10 * LAMPORTS_PER_SOL;
-        let pool_token_fee = stake_pool.calc_epoch_fee_amount(reward_lamports).unwrap();
-
-        stake_pool.total_lamports += reward_lamports;
-        stake_pool.pool_token_supply += pool_token_fee;
-
-        let fee_lamports = stake_pool
-            .calc_lamports_withdraw_amount(pool_token_fee)
-            .unwrap();
-        assert_eq!(fee_lamports, LAMPORTS_PER_SOL - 1); // off-by-one due to
-                                                        // truncation
-    }
-
-    #[test]
-    fn zero_withdraw_calculation() {
-        let epoch_fee = Fee {
-            numerator: 0,
-            denominator: 1,
-        };
-        let stake_pool = StakePool {
-            epoch_fee,
-            ..StakePool::default()
-        };
-        let fee_lamports = stake_pool.calc_lamports_withdraw_amount(0).unwrap();
-        assert_eq!(fee_lamports, 0);
-    }
-
-    #[test]
-    fn divide_by_zero_fee() {
-        let stake_pool = StakePool {
-            total_lamports: 0,
-            epoch_fee: Fee {
-                numerator: 1,
-                denominator: 10,
-            },
-            ..StakePool::default()
-        };
-        let rewards = 10;
-        let fee = stake_pool.calc_epoch_fee_amount(rewards).unwrap();
-        assert_eq!(fee, rewards);
-    }
-
-    #[test]
-    fn approximate_apr_calculation() {
-        // 8% / year means roughly .044% / epoch
-        let stake_pool = StakePool {
-            last_epoch_total_lamports: 100_000,
-            last_epoch_pool_token_supply: 100_000,
-            total_lamports: 100_044,
-            pool_token_supply: 100_000,
-            ..StakePool::default()
-        };
-        let pool_token_value =
-            stake_pool.total_lamports as f64 / stake_pool.pool_token_supply as f64;
-        let last_epoch_pool_token_value = stake_pool.last_epoch_total_lamports as f64
-            / stake_pool.last_epoch_pool_token_supply as f64;
-        let epoch_rate = pool_token_value / last_epoch_pool_token_value - 1.0;
-        const SECONDS_PER_EPOCH: f64 = DEFAULT_SLOTS_PER_EPOCH as f64 * DEFAULT_S_PER_SLOT;
-        const EPOCHS_PER_YEAR: f64 = SECONDS_PER_DAY as f64 * 365.25 / SECONDS_PER_EPOCH;
-        const EPSILON: f64 = 0.00001;
-        let yearly_rate = epoch_rate * EPOCHS_PER_YEAR;
-        assert!((yearly_rate - 0.080355).abs() < EPSILON);
-    }
-
-    proptest! {
-        #[test]
-        fn fee_calculation(
-            (numerator, denominator) in fee(),
-            (total_lamports, reward_lamports) in total_stake_and_rewards(),
-        ) {
-            let epoch_fee = Fee { denominator, numerator };
-            let mut stake_pool = StakePool {
-                total_lamports,
-                pool_token_supply: total_lamports,
-                epoch_fee,
-                ..StakePool::default()
-            };
-            let pool_token_fee = stake_pool.calc_epoch_fee_amount(reward_lamports).unwrap();
-
-            stake_pool.total_lamports += reward_lamports;
-            stake_pool.pool_token_supply += pool_token_fee;
-
-            let fee_lamports = stake_pool.calc_lamports_withdraw_amount(pool_token_fee).unwrap();
-            let max_fee_lamports = u64::try_from((reward_lamports as u128) * (epoch_fee.numerator as u128) / (epoch_fee.denominator as u128)).unwrap();
-            assert!(max_fee_lamports >= fee_lamports,
-                "Max possible fee must always be greater than or equal to what is actually withdrawn, max {} actual {}",
-                max_fee_lamports,
-                fee_lamports);
-
-            // since we do two "flooring" conversions, the max epsilon should be
-            // correct up to 2 lamports (one for each floor division), plus a
-            // correction for huge discrepancies between rewards and total stake
-            let epsilon = 2 + reward_lamports / total_lamports;
-            assert!(max_fee_lamports - fee_lamports <= epsilon,
-                "Max expected fee in lamports {}, actually receive {}, epsilon {}",
-                max_fee_lamports, fee_lamports, epsilon);
-        }
-    }
-
-    prop_compose! {
-        fn total_tokens_and_deposit()(total_lamports in 1..u64::MAX)(
-            total_lamports in Just(total_lamports),
-            pool_token_supply in 1..=total_lamports,
-            deposit_lamports in 1..total_lamports,
-        ) -> (u64, u64, u64) {
-            (total_lamports - deposit_lamports, pool_token_supply.saturating_sub(deposit_lamports).max(1), deposit_lamports)
-        }
-    }
-
-    proptest! {
-        #[test]
-        fn deposit_and_withdraw(
-            (total_lamports, pool_token_supply, deposit_stake) in total_tokens_and_deposit()
-        ) {
-            let mut stake_pool = StakePool {
-                total_lamports,
-                pool_token_supply,
-                ..StakePool::default()
-            };
-            let deposit_result = stake_pool.calc_pool_tokens_for_deposit(deposit_stake).unwrap();
-            prop_assume!(deposit_result > 0);
-            stake_pool.total_lamports += deposit_stake;
-            stake_pool.pool_token_supply += deposit_result;
-            let withdraw_result = stake_pool.calc_lamports_withdraw_amount(deposit_result).unwrap();
-            assert!(withdraw_result <= deposit_stake);
-
-            // also test splitting the withdrawal in two operations
-            if deposit_result >= 2 {
-                let first_half_deposit = deposit_result / 2;
-                let first_withdraw_result = stake_pool.calc_lamports_withdraw_amount(first_half_deposit).unwrap();
-                stake_pool.total_lamports -= first_withdraw_result;
-                stake_pool.pool_token_supply -= first_half_deposit;
-                let second_half_deposit = deposit_result - first_half_deposit; // do the whole thing
-                let second_withdraw_result = stake_pool.calc_lamports_withdraw_amount(second_half_deposit).unwrap();
-                assert!(first_withdraw_result + second_withdraw_result <= deposit_stake);
-            }
-        }
-    }
-
-    #[test]
-    fn specific_split_withdrawal() {
-        let total_lamports = 1_100_000_000_000;
-        let pool_token_supply = 1_000_000_000_000;
-        let deposit_stake = 3;
-        let mut stake_pool = StakePool {
-            total_lamports,
-            pool_token_supply,
-            ..StakePool::default()
-        };
-        let deposit_result = stake_pool
-            .calc_pool_tokens_for_deposit(deposit_stake)
-            .unwrap();
-        assert!(deposit_result > 0);
-        stake_pool.total_lamports += deposit_stake;
-        stake_pool.pool_token_supply += deposit_result;
-        let withdraw_result = stake_pool
-            .calc_lamports_withdraw_amount(deposit_result / 2)
-            .unwrap();
-        assert!(withdraw_result * 2 <= deposit_stake);
-    }
-
-    #[test]
-    fn withdraw_all() {
-        let total_lamports = 1_100_000_000_000;
-        let pool_token_supply = 1_000_000_000_000;
-        let mut stake_pool = StakePool {
-            total_lamports,
-            pool_token_supply,
-            ..StakePool::default()
-        };
-        // take everything out at once
-        let withdraw_result = stake_pool
-            .calc_lamports_withdraw_amount(pool_token_supply)
-            .unwrap();
-        assert_eq!(stake_pool.total_lamports, withdraw_result);
-
-        // take out 1, then the rest
-        let withdraw_result = stake_pool.calc_lamports_withdraw_amount(1).unwrap();
-        stake_pool.total_lamports -= withdraw_result;
-        stake_pool.pool_token_supply -= 1;
-        let withdraw_result = stake_pool
-            .calc_lamports_withdraw_amount(stake_pool.pool_token_supply)
-            .unwrap();
-        assert_eq!(stake_pool.total_lamports, withdraw_result);
-
-        // take out all except 1, then the rest
-        let mut stake_pool = StakePool {
-            total_lamports,
-            pool_token_supply,
-            ..StakePool::default()
-        };
-        let withdraw_result = stake_pool
-            .calc_lamports_withdraw_amount(pool_token_supply - 1)
-            .unwrap();
-        stake_pool.total_lamports -= withdraw_result;
-        stake_pool.pool_token_supply = 1;
-        assert_ne!(stake_pool.total_lamports, 0);
-
-        let withdraw_result = stake_pool.calc_lamports_withdraw_amount(1).unwrap();
-        assert_eq!(stake_pool.total_lamports, withdraw_result);
-    }
-}
diff --git a/stake-pool/program/tests/create_pool_token_metadata.rs b/stake-pool/program/tests/create_pool_token_metadata.rs
deleted file mode 100644
index 147e3928a07..00000000000
--- a/stake-pool/program/tests/create_pool_token_metadata.rs
+++ /dev/null
@@ -1,273 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{instruction::InstructionError, pubkey::Pubkey},
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError::{AlreadyInUse, SignatureMissing, WrongManager},
-        instruction, MINIMUM_RESERVE_LAMPORTS,
-    },
-    test_case::test_case,
-};
-
-async fn setup(token_program_id: Pubkey) -> (ProgramTestContext, StakePoolAccounts) {
-    let mut context = program_test_with_metadata_program()
-        .start_with_context()
-        .await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    (context, stake_pool_accounts)
-}
-
-#[test_case(spl_token::id(); "token")]
-//#[test_case(spl_token_2022::id(); "token-2022")] enable once metaplex supports token-2022
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    let (mut context, stake_pool_accounts) = setup(token_program_id).await;
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let metadata = get_metadata_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-
-    assert!(metadata.name.starts_with(name));
-    assert!(metadata.symbol.starts_with(symbol));
-    assert!(metadata.uri.starts_with(uri));
-}
-
-#[tokio::test]
-async fn fail_manager_did_not_sign() {
-    let (mut context, stake_pool_accounts) = setup(spl_token::id()).await;
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let mut ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-    ix.accounts[1].is_signer = false;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while manager signature missing"),
-    }
-}
-
-#[tokio::test]
-async fn fail_wrong_manager_signed() {
-    let (mut context, stake_pool_accounts) = setup(spl_token::id()).await;
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let random_keypair = Keypair::new();
-    let ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &random_keypair.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &random_keypair],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_wrong_mpl_metadata_program() {
-    let (mut context, stake_pool_accounts) = setup(spl_token::id()).await;
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let random_keypair = Keypair::new();
-    let mut ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &random_keypair.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-    ix.accounts[7].pubkey = Pubkey::new_unique();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &random_keypair],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, error) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to create metadata with wrong mpl token metadata program ID"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_create_metadata_twice() {
-    let (mut context, stake_pool_accounts) = setup(spl_token::id()).await;
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix.clone()],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-
-    let latest_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-    let transaction_2 = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        latest_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction_2)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = AlreadyInUse as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while trying to create pool token metadata twice"),
-    }
-}
diff --git a/stake-pool/program/tests/decrease.rs b/stake-pool/program/tests/decrease.rs
deleted file mode 100644
index 2e31c644844..00000000000
--- a/stake-pool/program/tests/decrease.rs
+++ /dev/null
@@ -1,667 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    assert_matches::assert_matches,
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{clock::Epoch, instruction::InstructionError, pubkey::Pubkey, stake},
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_ephemeral_stake_program_address,
-        find_transient_stake_program_address, id, instruction, MINIMUM_RESERVE_LAMPORTS,
-    },
-    test_case::test_case,
-};
-
-async fn setup() -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    DepositStakeAccount,
-    u64,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let reserve_lamports = MINIMUM_RESERVE_LAMPORTS + stake_rent + current_minimum_delegation;
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            reserve_lamports,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let decrease_lamports = (current_minimum_delegation + stake_rent) * 3;
-    let deposit_info = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake_account,
-        decrease_lamports,
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        decrease_lamports,
-        reserve_lamports + stake_rent,
-    )
-}
-
-#[test_case(DecreaseInstruction::Additional; "additional")]
-#[test_case(DecreaseInstruction::Reserve; "reserve")]
-#[test_case(DecreaseInstruction::Deprecated; "deprecated")]
-#[tokio::test]
-async fn success(instruction_type: DecreaseInstruction) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        _deposit_info,
-        decrease_lamports,
-        reserve_lamports,
-    ) = setup().await;
-
-    // Save validator stake
-    let pre_validator_stake_account =
-        get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-
-    // Check no transient stake
-    let transient_account = context
-        .banks_client
-        .get_account(validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(transient_account.is_none());
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            decrease_lamports,
-            validator_stake.transient_stake_seed,
-            instruction_type,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check validator stake account balance
-    let validator_stake_account =
-        get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-    let validator_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&validator_stake_account.data).unwrap();
-    assert_eq!(
-        pre_validator_stake_account.lamports - decrease_lamports,
-        validator_stake_account.lamports
-    );
-    assert_eq!(
-        validator_stake_state
-            .delegation()
-            .unwrap()
-            .deactivation_epoch,
-        Epoch::MAX
-    );
-
-    // Check transient stake account state and balance
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let transient_stake_account = get_account(
-        &mut context.banks_client,
-        &validator_stake.transient_stake_account,
-    )
-    .await;
-    let transient_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&transient_stake_account.data).unwrap();
-    let transient_lamports = decrease_lamports + stake_rent;
-    assert_eq!(transient_stake_account.lamports, transient_lamports);
-    let reserve_lamports = if instruction_type == DecreaseInstruction::Deprecated {
-        reserve_lamports
-    } else {
-        reserve_lamports - stake_rent
-    };
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(reserve_stake_account.lamports, reserve_lamports);
-    assert_ne!(
-        transient_stake_state
-            .delegation()
-            .unwrap()
-            .deactivation_epoch,
-        Epoch::MAX
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (mut context, stake_pool_accounts, validator_stake, _deposit_info, decrease_lamports, _) =
-        setup().await;
-
-    let wrong_authority = Pubkey::new_unique();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::decrease_validator_stake_with_reserve(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &wrong_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            decrease_lamports,
-            validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidProgramAddress as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list() {
-    let (
-        mut context,
-        mut stake_pool_accounts,
-        validator_stake,
-        _deposit_info,
-        decrease_lamports,
-        _,
-    ) = setup().await;
-
-    stake_pool_accounts.validator_list = Keypair::new();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::decrease_validator_stake_with_reserve(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            decrease_lamports,
-            validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidValidatorStakeList as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_unknown_validator() {
-    let (mut context, stake_pool_accounts, _validator_stake, _deposit_info, decrease_lamports, _) =
-        setup().await;
-
-    let unknown_stake = create_unknown_validator_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        0,
-    )
-    .await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::decrease_validator_stake_with_reserve(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &unknown_stake.stake_account,
-            &unknown_stake.transient_stake_account,
-            decrease_lamports,
-            unknown_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-}
-
-#[test_case(DecreaseInstruction::Additional; "additional")]
-#[test_case(DecreaseInstruction::Reserve; "reserve")]
-#[test_case(DecreaseInstruction::Deprecated; "deprecated")]
-#[tokio::test]
-async fn fail_twice_diff_seed(instruction_type: DecreaseInstruction) {
-    let (mut context, stake_pool_accounts, validator_stake, _deposit_info, decrease_lamports, _) =
-        setup().await;
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            decrease_lamports / 3,
-            validator_stake.transient_stake_seed,
-            instruction_type,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let transient_stake_seed = validator_stake.transient_stake_seed * 100;
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &validator_stake.vote.pubkey(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &transient_stake_address,
-            decrease_lamports / 2,
-            transient_stake_seed,
-            instruction_type,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    if instruction_type == DecreaseInstruction::Additional {
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-        );
-    } else {
-        assert_matches!(
-            error,
-            TransactionError::InstructionError(
-                _,
-                InstructionError::Custom(code)
-            ) if code == StakePoolError::TransientAccountInUse as u32
-        );
-    }
-}
-
-#[test_case(true, DecreaseInstruction::Additional, DecreaseInstruction::Additional; "success-all-additional")]
-#[test_case(true, DecreaseInstruction::Reserve, DecreaseInstruction::Additional; "success-with-additional")]
-#[test_case(false, DecreaseInstruction::Additional, DecreaseInstruction::Reserve; "fail-without-additional")]
-#[test_case(false, DecreaseInstruction::Reserve, DecreaseInstruction::Reserve; "fail-no-additional")]
-#[tokio::test]
-async fn twice(
-    success: bool,
-    first_instruction: DecreaseInstruction,
-    second_instruction: DecreaseInstruction,
-) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        _deposit_info,
-        decrease_lamports,
-        reserve_lamports,
-    ) = setup().await;
-
-    let pre_stake_account =
-        get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let first_decrease = decrease_lamports / 3;
-    let second_decrease = decrease_lamports / 2;
-    let total_decrease = first_decrease + second_decrease;
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            first_decrease,
-            validator_stake.transient_stake_seed,
-            first_instruction,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            second_decrease,
-            validator_stake.transient_stake_seed,
-            second_instruction,
-        )
-        .await;
-
-    if success {
-        assert!(error.is_none(), "{:?}", error);
-        // no ephemeral account
-        let ephemeral_stake = find_ephemeral_stake_program_address(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            0,
-        )
-        .0;
-        let ephemeral_account = context
-            .banks_client
-            .get_account(ephemeral_stake)
-            .await
-            .unwrap();
-        assert!(ephemeral_account.is_none());
-
-        // Check validator stake account balance
-        let stake_account =
-            get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-        let stake_state = deserialize::<stake::state::StakeStateV2>(&stake_account.data).unwrap();
-        assert_eq!(
-            pre_stake_account.lamports - total_decrease,
-            stake_account.lamports
-        );
-        assert_eq!(
-            stake_state.delegation().unwrap().deactivation_epoch,
-            Epoch::MAX
-        );
-
-        // Check transient stake account state and balance
-        let transient_stake_account = get_account(
-            &mut context.banks_client,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-        let transient_stake_state =
-            deserialize::<stake::state::StakeStateV2>(&transient_stake_account.data).unwrap();
-        let mut transient_lamports = total_decrease + stake_rent;
-        if second_instruction == DecreaseInstruction::Additional {
-            transient_lamports += stake_rent;
-        }
-        assert_eq!(transient_stake_account.lamports, transient_lamports);
-        assert_ne!(
-            transient_stake_state
-                .delegation()
-                .unwrap()
-                .deactivation_epoch,
-            Epoch::MAX
-        );
-
-        // marked correctly in the list
-        let validator_list = stake_pool_accounts
-            .get_validator_list(&mut context.banks_client)
-            .await;
-        let entry = validator_list.find(&validator_stake.vote.pubkey()).unwrap();
-        assert_eq!(
-            u64::from(entry.transient_stake_lamports),
-            transient_lamports
-        );
-
-        // reserve deducted properly
-        let mut reserve_lamports = reserve_lamports - stake_rent;
-        if second_instruction == DecreaseInstruction::Additional {
-            reserve_lamports -= stake_rent;
-        }
-        let reserve_stake_account = get_account(
-            &mut context.banks_client,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-        )
-        .await;
-        assert_eq!(reserve_stake_account.lamports, reserve_lamports);
-    } else {
-        let error = error.unwrap().unwrap();
-        assert_matches!(
-            error,
-            TransactionError::InstructionError(
-                _,
-                InstructionError::Custom(code)
-            ) if code == StakePoolError::TransientAccountInUse as u32
-        );
-    }
-}
-
-#[test_case(DecreaseInstruction::Additional; "additional")]
-#[test_case(DecreaseInstruction::Reserve; "reserve")]
-#[test_case(DecreaseInstruction::Deprecated; "deprecated")]
-#[tokio::test]
-async fn fail_with_small_lamport_amount(instruction_type: DecreaseInstruction) {
-    let (mut context, stake_pool_accounts, validator_stake, _deposit_info, _decrease_lamports, _) =
-        setup().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let lamports = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            lamports,
-            validator_stake.transient_stake_seed,
-            instruction_type,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_matches!(
-        error,
-        TransactionError::InstructionError(_, InstructionError::AccountNotRentExempt)
-    );
-}
-
-#[test_case(DecreaseInstruction::Additional; "additional")]
-#[test_case(DecreaseInstruction::Reserve; "reserve")]
-#[test_case(DecreaseInstruction::Deprecated; "deprecated")]
-#[tokio::test]
-async fn fail_big_overdraw(instruction_type: DecreaseInstruction) {
-    let (mut context, stake_pool_accounts, validator_stake, deposit_info, _decrease_lamports, _) =
-        setup().await;
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports * 1_000_000,
-            validator_stake.transient_stake_seed,
-            instruction_type,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_matches!(
-        error,
-        TransactionError::InstructionError(_, InstructionError::InsufficientFunds)
-    );
-}
-
-#[test_case(DecreaseInstruction::Additional; "additional")]
-#[test_case(DecreaseInstruction::Reserve; "reserve")]
-#[test_case(DecreaseInstruction::Deprecated; "deprecated")]
-#[tokio::test]
-async fn fail_overdraw(instruction_type: DecreaseInstruction) {
-    let (mut context, stake_pool_accounts, validator_stake, deposit_info, _decrease_lamports, _) =
-        setup().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports + stake_rent + 1,
-            validator_stake.transient_stake_seed,
-            instruction_type,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_matches!(
-        error,
-        TransactionError::InstructionError(_, InstructionError::InsufficientFunds)
-    );
-}
-
-#[tokio::test]
-async fn fail_additional_with_increasing() {
-    let (mut context, stake_pool_accounts, validator_stake, _, decrease_lamports, _) =
-        setup().await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    // warp forward to activation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            current_minimum_delegation,
-            validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            decrease_lamports / 2,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Additional,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_matches!(
-        error,
-        TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(code)
-        ) if code == StakePoolError::WrongStakeStake as u32
-    );
-}
diff --git a/stake-pool/program/tests/deposit.rs b/stake-pool/program/tests/deposit.rs
deleted file mode 100644
index 0b333e47cfc..00000000000
--- a/stake-pool/program/tests/deposit.rs
+++ /dev/null
@@ -1,905 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-        stake, sysvar,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{error::StakePoolError, id, instruction, state, MINIMUM_RESERVE_LAMPORTS},
-    spl_token::error as token_error,
-    test_case::test_case,
-};
-
-async fn setup(
-    token_program_id: Pubkey,
-) -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    Keypair,
-    Pubkey,
-    Pubkey,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let user = Keypair::new();
-    // make stake account
-    let deposit_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-
-    let stake_lamports = create_independent_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake,
-        &authorized,
-        &lockup,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake.pubkey(),
-        &user,
-        &validator_stake_account.vote.pubkey(),
-    )
-    .await;
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    // make pool token account
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake.pubkey(),
-        pool_token_account.pubkey(),
-        stake_lamports,
-    )
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        stake_lamports,
-    ) = setup(token_program_id).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // Save stake pool state before depositing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    // Save validator stake account record before depositing
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let pre_validator_stake_item = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-
-    // Save reserve state before depositing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Original stake account should be drained
-    assert!(context
-        .banks_client
-        .get_account(deposit_stake)
-        .await
-        .expect("get_account")
-        .is_none());
-
-    let tokens_issued = stake_lamports; // For now tokens are 1:1 to stake
-
-    // Stake pool should add its balance to the pool balance
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports + stake_lamports
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply + tokens_issued
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    let tokens_issued_user = tokens_issued
-        - post_stake_pool
-            .calc_pool_tokens_sol_deposit_fee(stake_rent)
-            .unwrap()
-        - post_stake_pool
-            .calc_pool_tokens_stake_deposit_fee(stake_lamports - stake_rent)
-            .unwrap();
-    assert_eq!(user_token_balance, tokens_issued_user);
-
-    // Check balances in validator stake account list storage
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let post_validator_stake_item = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        post_validator_stake_item.stake_lamports().unwrap(),
-        pre_validator_stake_item.stake_lamports().unwrap() + stake_lamports - stake_rent,
-    );
-
-    // Check validator stake account actual SOL balance
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &validator_stake_account.stake_account,
-    )
-    .await;
-    assert_eq!(
-        validator_stake_account.lamports,
-        post_validator_stake_item.stake_lamports().unwrap()
-    );
-    assert_eq!(
-        u64::from(post_validator_stake_item.transient_stake_lamports),
-        0
-    );
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(post_reserve_lamports, pre_reserve_lamports + stake_rent);
-}
-
-#[tokio::test]
-async fn success_with_extra_stake_lamports() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let extra_lamports = TEST_STAKE_AMOUNT * 3 + 1;
-
-    transfer(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake,
-        extra_lamports,
-    )
-    .await;
-
-    let referrer = Keypair::new();
-    let referrer_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &referrer_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &referrer,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let referrer_balance_pre =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-
-    let manager_pool_balance_pre = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // Save stake pool state before depositing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    // Save validator stake account record before depositing
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let pre_validator_stake_item = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-
-    // Save reserve state before depositing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let error = stake_pool_accounts
-        .deposit_stake_with_referral(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-            &referrer_token_account.pubkey(),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Original stake account should be drained
-    assert!(context
-        .banks_client
-        .get_account(deposit_stake)
-        .await
-        .expect("get_account")
-        .is_none());
-
-    let tokens_issued = stake_lamports + extra_lamports;
-    // For now tokens are 1:1 to stake
-
-    // Stake pool should add its balance to the pool balance
-
-    // The extra lamports will not get recorded in total stake lamports unless
-    // update_stake_pool_balance is called
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports + extra_lamports + stake_lamports
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply + tokens_issued
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-
-    let fee_tokens = post_stake_pool
-        .calc_pool_tokens_sol_deposit_fee(extra_lamports + stake_rent)
-        .unwrap()
-        + post_stake_pool
-            .calc_pool_tokens_stake_deposit_fee(stake_lamports - stake_rent)
-            .unwrap();
-    let tokens_issued_user = tokens_issued - fee_tokens;
-    assert_eq!(user_token_balance, tokens_issued_user);
-
-    let referrer_balance_post =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-
-    let referral_fee = stake_pool_accounts.calculate_referral_fee(fee_tokens);
-    let manager_fee = fee_tokens - referral_fee;
-
-    assert_eq!(referrer_balance_post - referrer_balance_pre, referral_fee);
-
-    let manager_pool_balance_post = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-    assert_eq!(
-        manager_pool_balance_post - manager_pool_balance_pre,
-        manager_fee
-    );
-
-    // Check balances in validator stake account list storage
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let post_validator_stake_item = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        post_validator_stake_item.stake_lamports().unwrap(),
-        pre_validator_stake_item.stake_lamports().unwrap() + stake_lamports - stake_rent,
-    );
-
-    // Check validator stake account actual SOL balance
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &validator_stake_account.stake_account,
-    )
-    .await;
-    assert_eq!(
-        validator_stake_account.lamports,
-        post_validator_stake_item.stake_lamports().unwrap()
-    );
-    assert_eq!(
-        u64::from(post_validator_stake_item.transient_stake_lamports),
-        0
-    );
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports + stake_rent + extra_lamports
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_stake_program_id() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        _user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let wrong_stake_program = Pubkey::new_unique();
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.stake_deposit_authority, false),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(deposit_stake, false),
-        AccountMeta::new(validator_stake_account.stake_account, false),
-        AccountMeta::new(stake_pool_accounts.reserve_stake.pubkey(), false),
-        AccountMeta::new(pool_token_account, false),
-        AccountMeta::new(stake_pool_accounts.pool_fee_account.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.pool_fee_account.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.pool_mint.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-        AccountMeta::new_readonly(wrong_stake_program, false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::DepositStake).unwrap(),
-    };
-
-    let mut transaction =
-        Transaction::new_with_payer(&[instruction], Some(&context.payer.pubkey()));
-    transaction.sign(&[&context.payer], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong stake program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_token_program_id() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let wrong_token_program = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &instruction::deposit_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &deposit_stake,
-            &user.pubkey(),
-            &validator_stake_account.stake_account,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &wrong_token_program.pubkey(),
-        ),
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer, &user], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong token program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list_account() {
-    let (
-        mut context,
-        mut stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let wrong_validator_list = Keypair::new();
-    stake_pool_accounts.validator_list = wrong_validator_list;
-
-    let transaction_error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        ) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_unknown_validator() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let unknown_stake = create_unknown_validator_stake(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        0,
-    )
-    .await;
-
-    let user = Keypair::new();
-    let user_pool_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &user_pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    // make stake account
-    let user_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-    create_independent_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake,
-        &authorized,
-        &lockup,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-    delegate_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake.pubkey(),
-        &user,
-        &unknown_stake.vote.pubkey(),
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_stake.pubkey(),
-            &user_pool_account.pubkey(),
-            &unknown_stake.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (
-        mut context,
-        mut stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    stake_pool_accounts.withdraw_authority = Pubkey::new_unique();
-
-    let transaction_error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong withdraw authority"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_mint_for_receiver_acc() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        _pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let outside_mint = Keypair::new();
-    let outside_withdraw_auth = Keypair::new();
-    let outside_manager = Keypair::new();
-    let outside_pool_fee_acc = Keypair::new();
-
-    create_mint(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &outside_mint,
-        &outside_withdraw_auth.pubkey(),
-        0,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &outside_pool_fee_acc,
-        &outside_mint.pubkey(),
-        &outside_manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let transaction_error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &outside_pool_fee_acc.pubkey(),
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = token_error::TokenError::MintMismatch as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => {
-            panic!("Wrong error occurs while try to deposit with wrong mint from receiver account")
-        }
-    }
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success_with_slippage(token_program_id: Pubkey) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        stake_lamports,
-    ) = setup(token_program_id).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // Save stake pool state before depositing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    let tokens_issued = stake_lamports; // For now tokens are 1:1 to stake
-    let tokens_issued_user = tokens_issued
-        - pre_stake_pool
-            .calc_pool_tokens_sol_deposit_fee(stake_rent)
-            .unwrap()
-        - pre_stake_pool
-            .calc_pool_tokens_stake_deposit_fee(stake_lamports - stake_rent)
-            .unwrap();
-
-    let error = stake_pool_accounts
-        .deposit_stake_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-            tokens_issued_user + 1,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(StakePoolError::ExceededSlippage as u32)
-        )
-    );
-
-    let error = stake_pool_accounts
-        .deposit_stake_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake_account.stake_account,
-            &user,
-            tokens_issued_user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Original stake account should be drained
-    assert!(context
-        .banks_client
-        .get_account(deposit_stake)
-        .await
-        .expect("get_account")
-        .is_none());
-
-    // Stake pool should add its balance to the pool balance
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports + stake_lamports
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply + tokens_issued
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    assert_eq!(user_token_balance, tokens_issued_user);
-}
diff --git a/stake-pool/program/tests/deposit_authority.rs b/stake-pool/program/tests/deposit_authority.rs
deleted file mode 100644
index e5e46a7ea12..00000000000
--- a/stake-pool/program/tests/deposit_authority.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{instruction::InstructionError, stake},
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        signature::{Keypair, Signer},
-        transaction::TransactionError,
-    },
-    spl_stake_pool::{error::StakePoolError, state::StakePool, MINIMUM_RESERVE_LAMPORTS},
-};
-
-#[tokio::test]
-async fn success_initialize() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let deposit_authority = Keypair::new();
-    let stake_pool_accounts = StakePoolAccounts::new_with_deposit_authority(deposit_authority);
-    let deposit_authority = stake_pool_accounts.stake_deposit_authority;
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    // Stake pool now exists
-    let stake_pool_account =
-        get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<StakePool>(stake_pool_account.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_deposit_authority, deposit_authority);
-    assert_eq!(stake_pool.sol_deposit_authority.unwrap(), deposit_authority);
-}
-
-#[tokio::test]
-async fn success_deposit() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_deposit_authority = Keypair::new();
-    let stake_pool_accounts =
-        StakePoolAccounts::new_with_deposit_authority(stake_deposit_authority);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        stake_pool_accounts.stake_deposit_authority_keypair.as_ref(),
-    )
-    .await;
-
-    let user = Keypair::new();
-    let user_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-
-    let _stake_lamports = create_independent_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake,
-        &authorized,
-        &lockup,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake.pubkey(),
-        &user,
-        &validator_stake_account.vote.pubkey(),
-    )
-    .await;
-
-    // make pool token account
-    let user_pool_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &user_pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_stake.pubkey(),
-            &user_pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_deposit_without_authority_signature() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_deposit_authority = Keypair::new();
-    let mut stake_pool_accounts =
-        StakePoolAccounts::new_with_deposit_authority(stake_deposit_authority);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        stake_pool_accounts.stake_deposit_authority_keypair.as_ref(),
-    )
-    .await;
-
-    let user = Keypair::new();
-    let user_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-
-    let _stake_lamports = create_independent_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake,
-        &authorized,
-        &lockup,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &user_stake.pubkey(),
-        &user,
-        &validator_stake_account.vote.pubkey(),
-    )
-    .await;
-
-    // make pool token account
-    let user_pool_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &user_pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let wrong_depositor = Keypair::new();
-    stake_pool_accounts.stake_deposit_authority = wrong_depositor.pubkey();
-    stake_pool_accounts.stake_deposit_authority_keypair = Some(wrong_depositor);
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_stake.pubkey(),
-            &user_pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            assert_eq!(
-                error_index,
-                StakePoolError::InvalidStakeDepositAuthority as u32
-            );
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong stake program ID"),
-    }
-}
diff --git a/stake-pool/program/tests/deposit_edge_cases.rs b/stake-pool/program/tests/deposit_edge_cases.rs
deleted file mode 100644
index 510e2f94d52..00000000000
--- a/stake-pool/program/tests/deposit_edge_cases.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked, instruction::InstructionError, pubkey::Pubkey, stake,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{error::StakePoolError, id, instruction, state, MINIMUM_RESERVE_LAMPORTS},
-};
-
-async fn setup(
-    token_program_id: Pubkey,
-) -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    Keypair,
-    Pubkey,
-    Pubkey,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let user = Keypair::new();
-    // make stake account
-    let deposit_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-
-    let stake_lamports = create_independent_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake,
-        &authorized,
-        &lockup,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake.pubkey(),
-        &user,
-        &validator_stake_account.vote.pubkey(),
-    )
-    .await;
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    // make pool token account
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake.pubkey(),
-        pool_token_account.pubkey(),
-        stake_lamports,
-    )
-}
-
-#[tokio::test]
-async fn success_with_preferred_deposit() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Deposit,
-            Some(validator_stake.vote.pubkey()),
-        )
-        .await;
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake.stake_account,
-            &user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_with_wrong_preferred_deposit() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Deposit,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &deposit_stake,
-            &pool_token_account,
-            &validator_stake.stake_account,
-            &user,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            assert_eq!(
-                error_index,
-                StakePoolError::IncorrectDepositVoteAddress as u32
-            );
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong stake program ID"),
-    }
-}
-
-#[tokio::test]
-async fn success_with_referral_fee() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let referrer = Keypair::new();
-    let referrer_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &referrer_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &referrer,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let referrer_balance_pre =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &instruction::deposit_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &deposit_stake,
-            &user.pubkey(),
-            &validator_stake_account.stake_account,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &referrer_token_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &spl_token::id(),
-        ),
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer, &user], context.last_blockhash);
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let referrer_balance_post =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let fee_tokens = stake_pool
-        .calc_pool_tokens_sol_deposit_fee(stake_rent)
-        .unwrap()
-        + stake_pool
-            .calc_pool_tokens_stake_deposit_fee(stake_lamports - stake_rent)
-            .unwrap();
-    let referral_fee = stake_pool_accounts.calculate_referral_fee(fee_tokens);
-    assert!(referral_fee > 0);
-    assert_eq!(referrer_balance_pre + referral_fee, referrer_balance_post);
-}
-
-#[tokio::test]
-async fn fail_with_invalid_referrer() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        user,
-        deposit_stake,
-        pool_token_account,
-        _stake_lamports,
-    ) = setup(spl_token::id()).await;
-
-    let invalid_token_account = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &instruction::deposit_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &deposit_stake,
-            &user.pubkey(),
-            &validator_stake_account.stake_account,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &invalid_token_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &spl_token::id(),
-        ),
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer, &user], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::InvalidAccountData) => (),
-        _ => panic!(
-            "Wrong error occurs while try to make a deposit with an invalid referrer account"
-        ),
-    }
-}
diff --git a/stake-pool/program/tests/deposit_sol.rs b/stake-pool/program/tests/deposit_sol.rs
deleted file mode 100644
index fa7ef355966..00000000000
--- a/stake-pool/program/tests/deposit_sol.rs
+++ /dev/null
@@ -1,607 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked, instruction::InstructionError, pubkey::Pubkey,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{
-        error, id,
-        instruction::{self, FundingType},
-        state, MINIMUM_RESERVE_LAMPORTS,
-    },
-    spl_token::error as token_error,
-    test_case::test_case,
-};
-
-async fn setup(
-    token_program_id: Pubkey,
-) -> (ProgramTestContext, StakePoolAccounts, Keypair, Pubkey) {
-    let mut context = program_test().start_with_context().await;
-
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let user = Keypair::new();
-
-    // make pool token account for user
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        user,
-        pool_token_account.pubkey(),
-    )
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    let (mut context, stake_pool_accounts, _user, pool_token_account) =
-        setup(token_program_id).await;
-
-    // Save stake pool state before depositing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    // Save reserve state before depositing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &pool_token_account,
-            TEST_STAKE_AMOUNT,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let tokens_issued = TEST_STAKE_AMOUNT; // For now tokens are 1:1 to stake
-
-    // Stake pool should add its balance to the pool balance
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports + TEST_STAKE_AMOUNT
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply + tokens_issued
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    let tokens_issued_user =
-        tokens_issued - stake_pool_accounts.calculate_sol_deposit_fee(tokens_issued);
-    assert_eq!(user_token_balance, tokens_issued_user);
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports + TEST_STAKE_AMOUNT
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_token_program_id() {
-    let (mut context, stake_pool_accounts, _user, pool_token_account) =
-        setup(spl_token::id()).await;
-
-    let wrong_token_program = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::deposit_sol(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &context.payer.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &wrong_token_program.pubkey(),
-            TEST_STAKE_AMOUNT,
-        )],
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong token program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (mut context, mut stake_pool_accounts, _user, pool_token_account) =
-        setup(spl_token::id()).await;
-
-    stake_pool_accounts.withdraw_authority = Pubkey::new_unique();
-
-    let transaction_error = stake_pool_accounts
-        .deposit_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &pool_token_account,
-            TEST_STAKE_AMOUNT,
-            None,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to make a deposit with wrong withdraw authority"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_mint_for_receiver_acc() {
-    let (mut context, stake_pool_accounts, _user, _pool_token_account) =
-        setup(spl_token::id()).await;
-
-    let outside_mint = Keypair::new();
-    let outside_withdraw_auth = Keypair::new();
-    let outside_manager = Keypair::new();
-    let outside_pool_fee_acc = Keypair::new();
-
-    create_mint(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &outside_mint,
-        &outside_withdraw_auth.pubkey(),
-        0,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &outside_pool_fee_acc,
-        &outside_mint.pubkey(),
-        &outside_manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let transaction_error = stake_pool_accounts
-        .deposit_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &outside_pool_fee_acc.pubkey(),
-            TEST_STAKE_AMOUNT,
-            None,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = token_error::TokenError::MintMismatch as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => {
-            panic!("Wrong error occurs while try to deposit with wrong mint from receiver account")
-        }
-    }
-}
-
-#[tokio::test]
-async fn success_with_sol_deposit_authority() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let user = Keypair::new();
-
-    // make pool token account
-    let user_pool_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &user_pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_pool_account.pubkey(),
-            TEST_STAKE_AMOUNT,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let sol_deposit_authority = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&sol_deposit_authority.pubkey()),
-            FundingType::SolDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_pool_account.pubkey(),
-            TEST_STAKE_AMOUNT,
-            Some(&sol_deposit_authority),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_without_sol_deposit_authority_signature() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let sol_deposit_authority = Keypair::new();
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let user = Keypair::new();
-
-    // make pool token account
-    let user_pool_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &user_pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&sol_deposit_authority.pubkey()),
-            FundingType::SolDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let wrong_depositor = Keypair::new();
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &user_pool_account.pubkey(),
-            TEST_STAKE_AMOUNT,
-            Some(&wrong_depositor),
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            assert_eq!(
-                error_index,
-                error::StakePoolError::InvalidSolDepositAuthority as u32
-            );
-        }
-        _ => panic!("Wrong error occurs while trying to make a deposit without SOL deposit authority signature"),
-    }
-}
-
-#[tokio::test]
-async fn success_with_referral_fee() {
-    let (mut context, stake_pool_accounts, _user, pool_token_account) =
-        setup(spl_token::id()).await;
-
-    let referrer = Keypair::new();
-    let referrer_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &referrer_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &referrer,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let referrer_balance_pre =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::deposit_sol(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &context.payer.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &referrer_token_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &spl_token::id(),
-            TEST_STAKE_AMOUNT,
-        )],
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer], context.last_blockhash);
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let referrer_balance_post =
-        get_token_balance(&mut context.banks_client, &referrer_token_account.pubkey()).await;
-    let referral_fee = stake_pool_accounts.calculate_sol_referral_fee(
-        stake_pool_accounts.calculate_sol_deposit_fee(TEST_STAKE_AMOUNT),
-    );
-    assert!(referral_fee > 0);
-    assert_eq!(referrer_balance_pre + referral_fee, referrer_balance_post);
-}
-
-#[tokio::test]
-async fn fail_with_invalid_referrer() {
-    let (mut context, stake_pool_accounts, _user, pool_token_account) =
-        setup(spl_token::id()).await;
-
-    let invalid_token_account = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::deposit_sol(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &context.payer.pubkey(),
-            &pool_token_account,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &invalid_token_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &spl_token::id(),
-            TEST_STAKE_AMOUNT,
-        )],
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match transaction_error {
-        TransactionError::InstructionError(_, InstructionError::InvalidAccountData) => (),
-        _ => panic!(
-            "Wrong error occurs while try to make a deposit with an invalid referrer account"
-        ),
-    }
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success_with_slippage(token_program_id: Pubkey) {
-    let (mut context, stake_pool_accounts, _user, pool_token_account) =
-        setup(token_program_id).await;
-
-    // Save stake pool state before depositing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    // Save reserve state before depositing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let new_pool_tokens = pre_stake_pool
-        .calc_pool_tokens_for_deposit(TEST_STAKE_AMOUNT)
-        .unwrap();
-    let pool_tokens_sol_deposit_fee = pre_stake_pool
-        .calc_pool_tokens_sol_deposit_fee(new_pool_tokens)
-        .unwrap();
-    let tokens_issued = new_pool_tokens - pool_tokens_sol_deposit_fee;
-
-    // Fail with 1 more token in slippage
-    let error = stake_pool_accounts
-        .deposit_sol_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &pool_token_account,
-            TEST_STAKE_AMOUNT,
-            tokens_issued + 1,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(error::StakePoolError::ExceededSlippage as u32)
-        )
-    );
-
-    // Succeed with exact return amount
-    let error = stake_pool_accounts
-        .deposit_sol_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &pool_token_account,
-            TEST_STAKE_AMOUNT,
-            tokens_issued,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Stake pool should add its balance to the pool balance
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports + TEST_STAKE_AMOUNT
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply + new_pool_tokens
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    assert_eq!(user_token_balance, tokens_issued);
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports + TEST_STAKE_AMOUNT
-    );
-}
diff --git a/stake-pool/program/tests/fixtures/mpl_token_metadata.so b/stake-pool/program/tests/fixtures/mpl_token_metadata.so
deleted file mode 100755
index 399c584c5c1..00000000000
Binary files a/stake-pool/program/tests/fixtures/mpl_token_metadata.so and /dev/null differ
diff --git a/stake-pool/program/tests/force_destake.rs b/stake-pool/program/tests/force_destake.rs
deleted file mode 100644
index bab4003ad44..00000000000
--- a/stake-pool/program/tests/force_destake.rs
+++ /dev/null
@@ -1,343 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        stake::{
-            self,
-            stake_flags::StakeFlags,
-            state::{Authorized, Delegation, Lockup, Meta, Stake, StakeStateV2},
-        },
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        account::{Account, WritableAccount},
-        clock::Epoch,
-        signature::Signer,
-        transaction::TransactionError,
-    },
-    spl_stake_pool::{
-        error::StakePoolError,
-        find_stake_program_address, find_transient_stake_program_address, id,
-        state::{AccountType, StakeStatus, ValidatorList, ValidatorListHeader, ValidatorStakeInfo},
-        MINIMUM_ACTIVE_STAKE,
-    },
-    std::num::NonZeroU32,
-};
-
-async fn setup(
-    stake_pool_accounts: &StakePoolAccounts,
-    forced_stake: &StakeStateV2,
-    voter_pubkey: &Pubkey,
-) -> (ProgramTestContext, Option<NonZeroU32>) {
-    let mut program_test = program_test();
-
-    let stake_pool_pubkey = stake_pool_accounts.stake_pool.pubkey();
-    let (mut stake_pool, mut validator_list) = stake_pool_accounts.state();
-
-    let _ = add_vote_account_with_pubkey(voter_pubkey, &mut program_test);
-    let mut data = vec![0; std::mem::size_of::<StakeStateV2>()];
-    bincode::serialize_into(&mut data[..], forced_stake).unwrap();
-
-    let stake_account = Account::create(
-        TEST_STAKE_AMOUNT + STAKE_ACCOUNT_RENT_EXEMPTION,
-        data,
-        stake::program::id(),
-        false,
-        Epoch::default(),
-    );
-
-    let raw_validator_seed = 42;
-    let validator_seed = NonZeroU32::new(raw_validator_seed);
-    let (stake_address, _) =
-        find_stake_program_address(&id(), voter_pubkey, &stake_pool_pubkey, validator_seed);
-    program_test.add_account(stake_address, stake_account);
-    let active_stake_lamports = TEST_STAKE_AMOUNT - MINIMUM_ACTIVE_STAKE;
-    // add to validator list
-    validator_list.validators.push(ValidatorStakeInfo {
-        status: StakeStatus::Active.into(),
-        vote_account_address: *voter_pubkey,
-        active_stake_lamports: active_stake_lamports.into(),
-        transient_stake_lamports: 0.into(),
-        last_update_epoch: 0.into(),
-        transient_seed_suffix: 0.into(),
-        unused: 0.into(),
-        validator_seed_suffix: raw_validator_seed.into(),
-    });
-
-    stake_pool.total_lamports += active_stake_lamports;
-    stake_pool.pool_token_supply += active_stake_lamports;
-
-    add_reserve_stake_account(
-        &mut program_test,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        TEST_STAKE_AMOUNT,
-    );
-    add_stake_pool_account(
-        &mut program_test,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool,
-    );
-    add_validator_list_account(
-        &mut program_test,
-        &stake_pool_accounts.validator_list.pubkey(),
-        &validator_list,
-        stake_pool_accounts.max_validators,
-    );
-
-    add_mint_account(
-        &mut program_test,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool.pool_token_supply,
-    );
-    add_token_account(
-        &mut program_test,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-    );
-
-    let context = program_test.start_with_context().await;
-    (context, validator_seed)
-}
-
-#[tokio::test]
-async fn success_update() {
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let meta = Meta {
-        rent_exempt_reserve: STAKE_ACCOUNT_RENT_EXEMPTION,
-        authorized: Authorized {
-            staker: stake_pool_accounts.withdraw_authority,
-            withdrawer: stake_pool_accounts.withdraw_authority,
-        },
-        lockup: Lockup::default(),
-    };
-    let voter_pubkey = Pubkey::new_unique();
-    let (mut context, validator_seed) = setup(
-        &stake_pool_accounts,
-        &StakeStateV2::Initialized(meta),
-        &voter_pubkey,
-    )
-    .await;
-    let pre_reserve_lamports = context
-        .banks_client
-        .get_account(stake_pool_accounts.reserve_stake.pubkey())
-        .await
-        .unwrap()
-        .unwrap()
-        .lamports;
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &voter_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        validator_seed,
-    );
-    let validator_stake_lamports = context
-        .banks_client
-        .get_account(stake_address)
-        .await
-        .unwrap()
-        .unwrap()
-        .lamports;
-    // update should merge the destaked validator stake account into the reserve
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-    let post_reserve_lamports = context
-        .banks_client
-        .get_account(stake_pool_accounts.reserve_stake.pubkey())
-        .await
-        .unwrap()
-        .unwrap()
-        .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports + validator_stake_lamports
-    );
-    // test no more validator stake account
-    assert!(context
-        .banks_client
-        .get_account(stake_address)
-        .await
-        .unwrap()
-        .is_none());
-}
-
-#[tokio::test]
-async fn fail_increase() {
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let meta = Meta {
-        rent_exempt_reserve: STAKE_ACCOUNT_RENT_EXEMPTION,
-        authorized: Authorized {
-            staker: stake_pool_accounts.withdraw_authority,
-            withdrawer: stake_pool_accounts.withdraw_authority,
-        },
-        lockup: Lockup::default(),
-    };
-    let voter_pubkey = Pubkey::new_unique();
-    let (mut context, validator_seed) = setup(
-        &stake_pool_accounts,
-        &StakeStateV2::Initialized(meta),
-        &voter_pubkey,
-    )
-    .await;
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &voter_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        validator_seed,
-    );
-    let transient_stake_seed = 0;
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &voter_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &transient_stake_address,
-            &stake_address,
-            &voter_pubkey,
-            MINIMUM_ACTIVE_STAKE,
-            transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::WrongStakeStake as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_remove_validator() {
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let meta = Meta {
-        rent_exempt_reserve: STAKE_ACCOUNT_RENT_EXEMPTION,
-        authorized: Authorized {
-            staker: stake_pool_accounts.withdraw_authority,
-            withdrawer: stake_pool_accounts.withdraw_authority,
-        },
-        lockup: Lockup::default(),
-    };
-    let voter_pubkey = Pubkey::new_unique();
-    let stake = Stake {
-        delegation: Delegation {
-            voter_pubkey,
-            stake: TEST_STAKE_AMOUNT,
-            activation_epoch: 0,
-            deactivation_epoch: 0,
-            ..Delegation::default()
-        },
-        credits_observed: 1,
-    };
-    let (mut context, validator_seed) = setup(
-        &stake_pool_accounts,
-        &StakeStateV2::Stake(meta, stake, StakeFlags::empty()),
-        &voter_pubkey,
-    )
-    .await;
-
-    // move forward to after deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &voter_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        validator_seed,
-    );
-    let transient_stake_seed = 0;
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &voter_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    )
-    .0;
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_address,
-            &transient_stake_address,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Get a new blockhash for the next update to work
-    context.get_new_latest_blockhash().await.unwrap();
-
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check if account was removed from the list of stake accounts
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(
-        validator_list,
-        ValidatorList {
-            header: ValidatorListHeader {
-                account_type: AccountType::ValidatorList,
-                max_validators: stake_pool_accounts.max_validators,
-            },
-            validators: vec![]
-        }
-    );
-
-    // Check stake account no longer exists
-    let account = context
-        .banks_client
-        .get_account(stake_address)
-        .await
-        .unwrap();
-    assert!(account.is_none());
-}
diff --git a/stake-pool/program/tests/helpers/mod.rs b/stake-pool/program/tests/helpers/mod.rs
deleted file mode 100644
index eb785ff6384..00000000000
--- a/stake-pool/program/tests/helpers/mod.rs
+++ /dev/null
@@ -1,2726 +0,0 @@
-#![allow(dead_code)]
-
-use {
-    borsh::BorshDeserialize,
-    solana_program::{
-        borsh1::{get_instance_packed_len, get_packed_len, try_from_slice_unchecked},
-        hash::Hash,
-        instruction::Instruction,
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        stake, system_instruction, system_program,
-    },
-    solana_program_test::{processor, BanksClient, ProgramTest, ProgramTestContext},
-    solana_sdk::{
-        account::{Account as SolanaAccount, WritableAccount},
-        clock::{Clock, Epoch},
-        compute_budget::ComputeBudgetInstruction,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-        transport::TransportError,
-    },
-    solana_vote_program::{
-        self, vote_instruction,
-        vote_state::{VoteInit, VoteState, VoteStateVersions},
-    },
-    spl_stake_pool::{
-        find_deposit_authority_program_address, find_ephemeral_stake_program_address,
-        find_stake_program_address, find_transient_stake_program_address,
-        find_withdraw_authority_program_address, id,
-        inline_mpl_token_metadata::{self, pda::find_metadata_account},
-        instruction, minimum_delegation,
-        processor::Processor,
-        state::{self, FeeType, FutureEpoch, StakePool, ValidatorList},
-        MAX_VALIDATORS_TO_UPDATE, MINIMUM_RESERVE_LAMPORTS,
-    },
-    spl_token_2022::{
-        extension::{ExtensionType, StateWithExtensionsOwned},
-        native_mint,
-        state::{Account, Mint},
-    },
-    std::{convert::TryInto, num::NonZeroU32},
-};
-
-pub const FIRST_NORMAL_EPOCH: u64 = 15;
-pub const TEST_STAKE_AMOUNT: u64 = 1_500_000_000;
-pub const MAX_TEST_VALIDATORS: u32 = 10_000;
-pub const DEFAULT_VALIDATOR_STAKE_SEED: Option<NonZeroU32> = NonZeroU32::new(1_010);
-pub const DEFAULT_TRANSIENT_STAKE_SEED: u64 = 42;
-pub const STAKE_ACCOUNT_RENT_EXEMPTION: u64 = 2_282_880;
-const ACCOUNT_RENT_EXEMPTION: u64 = 1_000_000_000; // go with something big to be safe
-
-pub fn program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::new("spl_stake_pool", id(), processor!(Processor::process));
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(spl_token_2022::processor::Processor::process),
-    );
-    program_test
-}
-
-pub fn program_test_with_metadata_program() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program("spl_stake_pool", id(), processor!(Processor::process));
-    program_test.add_program("mpl_token_metadata", inline_mpl_token_metadata::id(), None);
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(spl_token_2022::processor::Processor::process),
-    );
-    program_test
-}
-
-pub async fn get_account(banks_client: &mut BanksClient, pubkey: &Pubkey) -> SolanaAccount {
-    banks_client
-        .get_account(*pubkey)
-        .await
-        .expect("client error")
-        .expect("account not found")
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn create_mint(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    pool_mint: &Keypair,
-    manager: &Pubkey,
-    decimals: u8,
-    extension_types: &[ExtensionType],
-) -> Result<(), TransportError> {
-    assert!(extension_types.is_empty() || program_id != &spl_token::id());
-    let rent = banks_client.get_rent().await.unwrap();
-    let space = ExtensionType::try_calculate_account_len::<Mint>(extension_types).unwrap();
-    let mint_rent = rent.minimum_balance(space);
-    let mint_pubkey = pool_mint.pubkey();
-
-    let mut instructions = vec![system_instruction::create_account(
-        &payer.pubkey(),
-        &mint_pubkey,
-        mint_rent,
-        space as u64,
-        program_id,
-    )];
-    for extension_type in extension_types {
-        let instruction = match extension_type {
-            ExtensionType::MintCloseAuthority =>
-                spl_token_2022::instruction::initialize_mint_close_authority(
-                    program_id,
-                    &mint_pubkey,
-                    Some(manager),
-                ),
-            ExtensionType::DefaultAccountState =>
-                spl_token_2022::extension::default_account_state::instruction::initialize_default_account_state(
-                    program_id,
-                    &mint_pubkey,
-                    &spl_token_2022::state::AccountState::Initialized,
-                ),
-            ExtensionType::TransferFeeConfig => spl_token_2022::extension::transfer_fee::instruction::initialize_transfer_fee_config(
-                program_id,
-                &mint_pubkey,
-                Some(manager),
-                Some(manager),
-                100,
-                1_000_000,
-            ),
-            ExtensionType::InterestBearingConfig => spl_token_2022::extension::interest_bearing_mint::instruction::initialize(
-                program_id,
-                &mint_pubkey,
-                Some(*manager),
-                600,
-            ),
-            ExtensionType::NonTransferable =>
-                spl_token_2022::instruction::initialize_non_transferable_mint(program_id, &mint_pubkey),
-            _ => unimplemented!(),
-        };
-        instructions.push(instruction.unwrap());
-    }
-    instructions.push(
-        spl_token_2022::instruction::initialize_mint(
-            program_id,
-            &pool_mint.pubkey(),
-            manager,
-            None,
-            decimals,
-        )
-        .unwrap(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &[payer, pool_mint],
-        *recent_blockhash,
-    );
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-pub async fn transfer(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    recipient: &Pubkey,
-    amount: u64,
-) {
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::transfer(
-            &payer.pubkey(),
-            recipient,
-            amount,
-        )],
-        Some(&payer.pubkey()),
-        &[payer],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn transfer_spl_tokens(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    source: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-    decimals: u8,
-) {
-    let transaction = Transaction::new_signed_with_payer(
-        &[spl_token_2022::instruction::transfer_checked(
-            program_id,
-            source,
-            mint,
-            destination,
-            &authority.pubkey(),
-            &[],
-            amount,
-            decimals,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn create_token_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    account: &Keypair,
-    pool_mint: &Pubkey,
-    authority: &Keypair,
-    extensions: &[ExtensionType],
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let space = ExtensionType::try_calculate_account_len::<Account>(extensions).unwrap();
-    let account_rent = rent.minimum_balance(space);
-
-    let mut instructions = vec![system_instruction::create_account(
-        &payer.pubkey(),
-        &account.pubkey(),
-        account_rent,
-        space as u64,
-        program_id,
-    )];
-
-    for extension in extensions {
-        match extension {
-            ExtensionType::ImmutableOwner => instructions.push(
-                spl_token_2022::instruction::initialize_immutable_owner(
-                    program_id,
-                    &account.pubkey(),
-                )
-                .unwrap(),
-            ),
-            ExtensionType::TransferFeeAmount
-            | ExtensionType::MemoTransfer
-            | ExtensionType::CpiGuard
-            | ExtensionType::NonTransferableAccount => (),
-            _ => unimplemented!(),
-        };
-    }
-
-    instructions.push(
-        spl_token_2022::instruction::initialize_account(
-            program_id,
-            &account.pubkey(),
-            pool_mint,
-            &authority.pubkey(),
-        )
-        .unwrap(),
-    );
-
-    let mut signers = vec![payer, account];
-    for extension in extensions {
-        match extension {
-            ExtensionType::MemoTransfer => {
-                signers.push(authority);
-                instructions.push(
-                spl_token_2022::extension::memo_transfer::instruction::enable_required_transfer_memos(
-                    program_id,
-                    &account.pubkey(),
-                    &authority.pubkey(),
-                    &[],
-                )
-                .unwrap()
-                )
-            }
-            ExtensionType::CpiGuard => {
-                signers.push(authority);
-                instructions.push(
-                    spl_token_2022::extension::cpi_guard::instruction::enable_cpi_guard(
-                        program_id,
-                        &account.pubkey(),
-                        &authority.pubkey(),
-                        &[],
-                    )
-                    .unwrap(),
-                )
-            }
-            ExtensionType::ImmutableOwner
-            | ExtensionType::TransferFeeAmount
-            | ExtensionType::NonTransferableAccount => (),
-            _ => unimplemented!(),
-        }
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &signers,
-        *recent_blockhash,
-    );
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-pub async fn close_token_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    account: &Pubkey,
-    lamports_destination: &Pubkey,
-    manager: &Keypair,
-) -> Result<(), TransportError> {
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_token_2022::instruction::close_account(
-            program_id,
-            account,
-            lamports_destination,
-            &manager.pubkey(),
-            &[],
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[payer, manager], *recent_blockhash);
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-pub async fn freeze_token_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    account: &Pubkey,
-    pool_mint: &Pubkey,
-    manager: &Keypair,
-) -> Result<(), TransportError> {
-    let mut transaction = Transaction::new_with_payer(
-        &[spl_token_2022::instruction::freeze_account(
-            program_id,
-            account,
-            pool_mint,
-            &manager.pubkey(),
-            &[],
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[payer, manager], *recent_blockhash);
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn mint_tokens(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    mint: &Pubkey,
-    account: &Pubkey,
-    mint_authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[spl_token_2022::instruction::mint_to(
-            program_id,
-            mint,
-            account,
-            &mint_authority.pubkey(),
-            &[],
-            amount,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, mint_authority],
-        *recent_blockhash,
-    );
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn burn_tokens(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    mint: &Pubkey,
-    account: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[spl_token_2022::instruction::burn(
-            program_id,
-            account,
-            mint,
-            &authority.pubkey(),
-            &[],
-            amount,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        *recent_blockhash,
-    );
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-pub async fn get_token_balance(banks_client: &mut BanksClient, token: &Pubkey) -> u64 {
-    let token_account = banks_client.get_account(*token).await.unwrap().unwrap();
-    let account_info = StateWithExtensionsOwned::<Account>::unpack(token_account.data).unwrap();
-    account_info.base.amount
-}
-
-#[derive(Clone, BorshDeserialize, Debug, PartialEq, Eq)]
-pub struct Metadata {
-    pub key: u8,
-    pub update_authority: Pubkey,
-    pub mint: Pubkey,
-    pub name: String,
-    pub symbol: String,
-    pub uri: String,
-    pub seller_fee_basis_points: u16,
-    pub creators: Option<Vec<u8>>,
-    pub primary_sale_happened: bool,
-    pub is_mutable: bool,
-}
-
-pub async fn get_metadata_account(banks_client: &mut BanksClient, token_mint: &Pubkey) -> Metadata {
-    let (token_metadata, _) = find_metadata_account(token_mint);
-    let token_metadata_account = banks_client
-        .get_account(token_metadata)
-        .await
-        .unwrap()
-        .unwrap();
-    try_from_slice_unchecked(token_metadata_account.data.as_slice()).unwrap()
-}
-
-pub async fn get_token_supply(banks_client: &mut BanksClient, mint: &Pubkey) -> u64 {
-    let mint_account = banks_client.get_account(*mint).await.unwrap().unwrap();
-    let account_info = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data).unwrap();
-    account_info.base.supply
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn delegate_tokens(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    account: &Pubkey,
-    manager: &Keypair,
-    delegate: &Pubkey,
-    amount: u64,
-) {
-    let transaction = Transaction::new_signed_with_payer(
-        &[spl_token_2022::instruction::approve(
-            program_id,
-            account,
-            delegate,
-            &manager.pubkey(),
-            &[],
-            amount,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, manager],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub async fn revoke_tokens(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    program_id: &Pubkey,
-    account: &Pubkey,
-    manager: &Keypair,
-) {
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            spl_token_2022::instruction::revoke(program_id, account, &manager.pubkey(), &[])
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, manager],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn create_stake_pool(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake_pool: &Keypair,
-    validator_list: &Keypair,
-    reserve_stake: &Pubkey,
-    token_program_id: &Pubkey,
-    pool_mint: &Pubkey,
-    pool_token_account: &Pubkey,
-    manager: &Keypair,
-    staker: &Pubkey,
-    withdraw_authority: &Pubkey,
-    stake_deposit_authority: &Option<Keypair>,
-    epoch_fee: &state::Fee,
-    withdrawal_fee: &state::Fee,
-    deposit_fee: &state::Fee,
-    referral_fee: u8,
-    sol_deposit_fee: &state::Fee,
-    sol_referral_fee: u8,
-    max_validators: u32,
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size =
-        get_instance_packed_len(&state::ValidatorList::new(max_validators)).unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool.pubkey(),
-                &manager.pubkey(),
-                staker,
-                withdraw_authority,
-                &validator_list.pubkey(),
-                reserve_stake,
-                pool_mint,
-                pool_token_account,
-                token_program_id,
-                stake_deposit_authority.as_ref().map(|k| k.pubkey()),
-                *epoch_fee,
-                *withdrawal_fee,
-                *deposit_fee,
-                referral_fee,
-                max_validators,
-            ),
-            instruction::set_fee(
-                &id(),
-                &stake_pool.pubkey(),
-                &manager.pubkey(),
-                FeeType::SolDeposit(*sol_deposit_fee),
-            ),
-            instruction::set_fee(
-                &id(),
-                &stake_pool.pubkey(),
-                &manager.pubkey(),
-                FeeType::SolReferral(sol_referral_fee),
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    let mut signers = vec![payer, stake_pool, validator_list, manager];
-    if let Some(stake_deposit_authority) = stake_deposit_authority.as_ref() {
-        signers.push(stake_deposit_authority);
-    }
-    transaction.sign(&signers, *recent_blockhash);
-    banks_client
-        .process_transaction(transaction)
-        .await
-        .map_err(|e| e.into())
-}
-
-pub async fn create_vote(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    validator: &Keypair,
-    vote: &Keypair,
-) {
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_voter = rent.minimum_balance(VoteState::size_of());
-
-    let mut instructions = vec![system_instruction::create_account(
-        &payer.pubkey(),
-        &validator.pubkey(),
-        rent.minimum_balance(0),
-        0,
-        &system_program::id(),
-    )];
-    instructions.append(&mut vote_instruction::create_account_with_config(
-        &payer.pubkey(),
-        &vote.pubkey(),
-        &VoteInit {
-            node_pubkey: validator.pubkey(),
-            authorized_voter: validator.pubkey(),
-            ..VoteInit::default()
-        },
-        rent_voter,
-        vote_instruction::CreateVoteAccountConfig {
-            space: VoteState::size_of() as u64,
-            ..Default::default()
-        },
-    ));
-
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &[validator, vote, payer],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub async fn create_independent_stake_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Keypair,
-    authorized: &stake::state::Authorized,
-    lockup: &stake::state::Lockup,
-    stake_amount: u64,
-) -> u64 {
-    let rent = banks_client.get_rent().await.unwrap();
-    let lamports =
-        rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>()) + stake_amount;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &stake::instruction::create_account(
-            &payer.pubkey(),
-            &stake.pubkey(),
-            authorized,
-            lockup,
-            lamports,
-        ),
-        Some(&payer.pubkey()),
-        &[payer, stake],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    lamports
-}
-
-pub async fn create_blank_stake_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Keypair,
-) -> u64 {
-    let rent = banks_client.get_rent().await.unwrap();
-    let lamports = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &stake.pubkey(),
-            lamports,
-            std::mem::size_of::<stake::state::StakeStateV2>() as u64,
-            &stake::program::id(),
-        )],
-        Some(&payer.pubkey()),
-        &[payer, stake],
-        *recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    lamports
-}
-
-pub async fn delegate_stake_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Pubkey,
-    authorized: &Keypair,
-    vote: &Pubkey,
-) {
-    let mut transaction = Transaction::new_with_payer(
-        &[stake::instruction::delegate_stake(
-            stake,
-            &authorized.pubkey(),
-            vote,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[payer, authorized], *recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub async fn stake_get_minimum_delegation(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-) -> u64 {
-    let transaction = Transaction::new_signed_with_payer(
-        &[stake::instruction::get_minimum_delegation()],
-        Some(&payer.pubkey()),
-        &[payer],
-        *recent_blockhash,
-    );
-    let mut data = banks_client
-        .simulate_transaction(transaction)
-        .await
-        .unwrap()
-        .simulation_details
-        .unwrap()
-        .return_data
-        .unwrap()
-        .data;
-    data.resize(8, 0);
-    data.try_into().map(u64::from_le_bytes).unwrap()
-}
-
-pub async fn stake_pool_get_minimum_delegation(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-) -> u64 {
-    let stake_minimum = stake_get_minimum_delegation(banks_client, payer, recent_blockhash).await;
-    minimum_delegation(stake_minimum)
-}
-
-pub async fn authorize_stake_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake: &Pubkey,
-    authorized: &Keypair,
-    new_authorized: &Pubkey,
-    stake_authorize: stake::state::StakeAuthorize,
-) {
-    let mut transaction = Transaction::new_with_payer(
-        &[stake::instruction::authorize(
-            stake,
-            &authorized.pubkey(),
-            new_authorized,
-            stake_authorize,
-            None,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[payer, authorized], *recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-pub async fn create_unknown_validator_stake(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake_pool: &Pubkey,
-    lamports: u64,
-) -> ValidatorStakeAccount {
-    let mut unknown_stake = ValidatorStakeAccount::new(stake_pool, NonZeroU32::new(1), 222);
-    create_vote(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &unknown_stake.validator,
-        &unknown_stake.vote,
-    )
-    .await;
-    let user = Keypair::new();
-    let fake_validator_stake = Keypair::new();
-    let stake_minimum_delegation =
-        stake_get_minimum_delegation(banks_client, payer, recent_blockhash).await;
-    let current_minimum_delegation = minimum_delegation(stake_minimum_delegation);
-    create_independent_stake_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &fake_validator_stake,
-        &stake::state::Authorized {
-            staker: user.pubkey(),
-            withdrawer: user.pubkey(),
-        },
-        &stake::state::Lockup::default(),
-        current_minimum_delegation + lamports,
-    )
-    .await;
-    delegate_stake_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &fake_validator_stake.pubkey(),
-        &user,
-        &unknown_stake.vote.pubkey(),
-    )
-    .await;
-    unknown_stake.stake_account = fake_validator_stake.pubkey();
-    unknown_stake
-}
-
-pub struct ValidatorStakeAccount {
-    pub stake_account: Pubkey,
-    pub transient_stake_account: Pubkey,
-    pub transient_stake_seed: u64,
-    pub validator_stake_seed: Option<NonZeroU32>,
-    pub vote: Keypair,
-    pub validator: Keypair,
-    pub stake_pool: Pubkey,
-}
-
-impl ValidatorStakeAccount {
-    pub fn new(
-        stake_pool: &Pubkey,
-        validator_stake_seed: Option<NonZeroU32>,
-        transient_stake_seed: u64,
-    ) -> Self {
-        let validator = Keypair::new();
-        let vote = Keypair::new();
-        let (stake_account, _) =
-            find_stake_program_address(&id(), &vote.pubkey(), stake_pool, validator_stake_seed);
-        let (transient_stake_account, _) = find_transient_stake_program_address(
-            &id(),
-            &vote.pubkey(),
-            stake_pool,
-            transient_stake_seed,
-        );
-        ValidatorStakeAccount {
-            stake_account,
-            transient_stake_account,
-            transient_stake_seed,
-            validator_stake_seed,
-            vote,
-            validator,
-            stake_pool: *stake_pool,
-        }
-    }
-}
-
-pub struct StakePoolAccounts {
-    pub stake_pool: Keypair,
-    pub validator_list: Keypair,
-    pub reserve_stake: Keypair,
-    pub token_program_id: Pubkey,
-    pub pool_mint: Keypair,
-    pub pool_fee_account: Keypair,
-    pub pool_decimals: u8,
-    pub manager: Keypair,
-    pub staker: Keypair,
-    pub withdraw_authority: Pubkey,
-    pub stake_deposit_authority: Pubkey,
-    pub stake_deposit_authority_keypair: Option<Keypair>,
-    pub epoch_fee: state::Fee,
-    pub withdrawal_fee: state::Fee,
-    pub deposit_fee: state::Fee,
-    pub referral_fee: u8,
-    pub sol_deposit_fee: state::Fee,
-    pub sol_referral_fee: u8,
-    pub max_validators: u32,
-    pub compute_unit_limit: Option<u32>,
-}
-
-impl StakePoolAccounts {
-    pub fn new_with_deposit_authority(stake_deposit_authority: Keypair) -> Self {
-        Self {
-            stake_deposit_authority: stake_deposit_authority.pubkey(),
-            stake_deposit_authority_keypair: Some(stake_deposit_authority),
-            ..Default::default()
-        }
-    }
-
-    pub fn new_with_token_program(token_program_id: Pubkey) -> Self {
-        Self {
-            token_program_id,
-            ..Default::default()
-        }
-    }
-
-    pub fn calculate_fee(&self, amount: u64) -> u64 {
-        (amount * self.epoch_fee.numerator + self.epoch_fee.denominator - 1)
-            / self.epoch_fee.denominator
-    }
-
-    pub fn calculate_withdrawal_fee(&self, pool_tokens: u64) -> u64 {
-        (pool_tokens * self.withdrawal_fee.numerator + self.withdrawal_fee.denominator - 1)
-            / self.withdrawal_fee.denominator
-    }
-
-    pub fn calculate_inverse_withdrawal_fee(&self, pool_tokens: u64) -> u64 {
-        (pool_tokens * self.withdrawal_fee.denominator + self.withdrawal_fee.denominator - 1)
-            / (self.withdrawal_fee.denominator - self.withdrawal_fee.numerator)
-    }
-
-    pub fn calculate_referral_fee(&self, deposit_fee_collected: u64) -> u64 {
-        deposit_fee_collected * self.referral_fee as u64 / 100
-    }
-
-    pub fn calculate_sol_deposit_fee(&self, pool_tokens: u64) -> u64 {
-        (pool_tokens * self.sol_deposit_fee.numerator + self.sol_deposit_fee.denominator - 1)
-            / self.sol_deposit_fee.denominator
-    }
-
-    pub fn calculate_sol_referral_fee(&self, deposit_fee_collected: u64) -> u64 {
-        deposit_fee_collected * self.sol_referral_fee as u64 / 100
-    }
-
-    pub async fn initialize_stake_pool(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        reserve_lamports: u64,
-    ) -> Result<(), TransportError> {
-        create_mint(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.token_program_id,
-            &self.pool_mint,
-            &self.withdraw_authority,
-            self.pool_decimals,
-            &[],
-        )
-        .await?;
-        create_token_account(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.token_program_id,
-            &self.pool_fee_account,
-            &self.pool_mint.pubkey(),
-            &self.manager,
-            &[],
-        )
-        .await?;
-        create_independent_stake_account(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.reserve_stake,
-            &stake::state::Authorized {
-                staker: self.withdraw_authority,
-                withdrawer: self.withdraw_authority,
-            },
-            &stake::state::Lockup::default(),
-            reserve_lamports,
-        )
-        .await;
-        create_stake_pool(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.stake_pool,
-            &self.validator_list,
-            &self.reserve_stake.pubkey(),
-            &self.token_program_id,
-            &self.pool_mint.pubkey(),
-            &self.pool_fee_account.pubkey(),
-            &self.manager,
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.stake_deposit_authority_keypair,
-            &self.epoch_fee,
-            &self.withdrawal_fee,
-            &self.deposit_fee,
-            self.referral_fee,
-            &self.sol_deposit_fee,
-            self.sol_referral_fee,
-            self.max_validators,
-        )
-        .await?;
-
-        Ok(())
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn deposit_stake_with_slippage(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake: &Pubkey,
-        pool_account: &Pubkey,
-        validator_stake_account: &Pubkey,
-        current_staker: &Keypair,
-        minimum_pool_tokens_out: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = instruction::deposit_stake_with_slippage(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.validator_list.pubkey(),
-            &self.withdraw_authority,
-            stake,
-            &current_staker.pubkey(),
-            validator_stake_account,
-            &self.reserve_stake.pubkey(),
-            pool_account,
-            &self.pool_fee_account.pubkey(),
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-            minimum_pool_tokens_out,
-        );
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, current_staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn deposit_stake(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake: &Pubkey,
-        pool_account: &Pubkey,
-        validator_stake_account: &Pubkey,
-        current_staker: &Keypair,
-    ) -> Option<TransportError> {
-        self.deposit_stake_with_referral(
-            banks_client,
-            payer,
-            recent_blockhash,
-            stake,
-            pool_account,
-            validator_stake_account,
-            current_staker,
-            &self.pool_fee_account.pubkey(),
-        )
-        .await
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn deposit_stake_with_referral(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake: &Pubkey,
-        pool_account: &Pubkey,
-        validator_stake_account: &Pubkey,
-        current_staker: &Keypair,
-        referrer: &Pubkey,
-    ) -> Option<TransportError> {
-        let mut signers = vec![payer, current_staker];
-        let mut instructions =
-            if let Some(stake_deposit_authority) = self.stake_deposit_authority_keypair.as_ref() {
-                signers.push(stake_deposit_authority);
-                instruction::deposit_stake_with_authority(
-                    &id(),
-                    &self.stake_pool.pubkey(),
-                    &self.validator_list.pubkey(),
-                    &self.stake_deposit_authority,
-                    &self.withdraw_authority,
-                    stake,
-                    &current_staker.pubkey(),
-                    validator_stake_account,
-                    &self.reserve_stake.pubkey(),
-                    pool_account,
-                    &self.pool_fee_account.pubkey(),
-                    referrer,
-                    &self.pool_mint.pubkey(),
-                    &self.token_program_id,
-                )
-            } else {
-                instruction::deposit_stake(
-                    &id(),
-                    &self.stake_pool.pubkey(),
-                    &self.validator_list.pubkey(),
-                    &self.withdraw_authority,
-                    stake,
-                    &current_staker.pubkey(),
-                    validator_stake_account,
-                    &self.reserve_stake.pubkey(),
-                    pool_account,
-                    &self.pool_fee_account.pubkey(),
-                    referrer,
-                    &self.pool_mint.pubkey(),
-                    &self.token_program_id,
-                )
-            };
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &signers,
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn deposit_sol(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        pool_account: &Pubkey,
-        amount: u64,
-        sol_deposit_authority: Option<&Keypair>,
-    ) -> Option<TransportError> {
-        let mut signers = vec![payer];
-        let instruction = if let Some(sol_deposit_authority) = sol_deposit_authority {
-            signers.push(sol_deposit_authority);
-            instruction::deposit_sol_with_authority(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &sol_deposit_authority.pubkey(),
-                &self.withdraw_authority,
-                &self.reserve_stake.pubkey(),
-                &payer.pubkey(),
-                pool_account,
-                &self.pool_fee_account.pubkey(),
-                &self.pool_fee_account.pubkey(),
-                &self.pool_mint.pubkey(),
-                &self.token_program_id,
-                amount,
-            )
-        } else {
-            instruction::deposit_sol(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.withdraw_authority,
-                &self.reserve_stake.pubkey(),
-                &payer.pubkey(),
-                pool_account,
-                &self.pool_fee_account.pubkey(),
-                &self.pool_fee_account.pubkey(),
-                &self.pool_mint.pubkey(),
-                &self.token_program_id,
-                amount,
-            )
-        };
-        let mut instructions = vec![instruction];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &signers,
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn deposit_sol_with_slippage(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        pool_account: &Pubkey,
-        lamports_in: u64,
-        minimum_pool_tokens_out: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::deposit_sol_with_slippage(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.withdraw_authority,
-            &self.reserve_stake.pubkey(),
-            &payer.pubkey(),
-            pool_account,
-            &self.pool_fee_account.pubkey(),
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-            lamports_in,
-            minimum_pool_tokens_out,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn withdraw_stake_with_slippage(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake_recipient: &Pubkey,
-        user_transfer_authority: &Keypair,
-        pool_account: &Pubkey,
-        validator_stake_account: &Pubkey,
-        recipient_new_authority: &Pubkey,
-        pool_tokens_in: u64,
-        minimum_lamports_out: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::withdraw_stake_with_slippage(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.validator_list.pubkey(),
-            &self.withdraw_authority,
-            validator_stake_account,
-            stake_recipient,
-            recipient_new_authority,
-            &user_transfer_authority.pubkey(),
-            pool_account,
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-            pool_tokens_in,
-            minimum_lamports_out,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, user_transfer_authority],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn withdraw_stake(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake_recipient: &Pubkey,
-        user_transfer_authority: &Keypair,
-        pool_account: &Pubkey,
-        validator_stake_account: &Pubkey,
-        recipient_new_authority: &Pubkey,
-        amount: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::withdraw_stake(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.validator_list.pubkey(),
-            &self.withdraw_authority,
-            validator_stake_account,
-            stake_recipient,
-            recipient_new_authority,
-            &user_transfer_authority.pubkey(),
-            pool_account,
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-            amount,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, user_transfer_authority],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn withdraw_sol_with_slippage(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        user: &Keypair,
-        pool_account: &Pubkey,
-        amount_in: u64,
-        minimum_lamports_out: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::withdraw_sol_with_slippage(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.withdraw_authority,
-            &user.pubkey(),
-            pool_account,
-            &self.reserve_stake.pubkey(),
-            &user.pubkey(),
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-            amount_in,
-            minimum_lamports_out,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, user],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn withdraw_sol(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        user: &Keypair,
-        pool_account: &Pubkey,
-        amount: u64,
-        sol_withdraw_authority: Option<&Keypair>,
-    ) -> Option<TransportError> {
-        let mut signers = vec![payer, user];
-        let instruction = if let Some(sol_withdraw_authority) = sol_withdraw_authority {
-            signers.push(sol_withdraw_authority);
-            instruction::withdraw_sol_with_authority(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &sol_withdraw_authority.pubkey(),
-                &self.withdraw_authority,
-                &user.pubkey(),
-                pool_account,
-                &self.reserve_stake.pubkey(),
-                &user.pubkey(),
-                &self.pool_fee_account.pubkey(),
-                &self.pool_mint.pubkey(),
-                &self.token_program_id,
-                amount,
-            )
-        } else {
-            instruction::withdraw_sol(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.withdraw_authority,
-                &user.pubkey(),
-                pool_account,
-                &self.reserve_stake.pubkey(),
-                &user.pubkey(),
-                &self.pool_fee_account.pubkey(),
-                &self.pool_mint.pubkey(),
-                &self.token_program_id,
-                amount,
-            )
-        };
-        let mut instructions = vec![instruction];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &signers,
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn get_stake_pool(&self, banks_client: &mut BanksClient) -> StakePool {
-        let stake_pool_account = get_account(banks_client, &self.stake_pool.pubkey()).await;
-        try_from_slice_unchecked::<StakePool>(stake_pool_account.data.as_slice()).unwrap()
-    }
-
-    pub async fn get_validator_list(&self, banks_client: &mut BanksClient) -> ValidatorList {
-        let validator_list_account = get_account(banks_client, &self.validator_list.pubkey()).await;
-        try_from_slice_unchecked::<ValidatorList>(validator_list_account.data.as_slice()).unwrap()
-    }
-
-    pub async fn update_validator_list_balance(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        len: usize,
-        no_merge: bool,
-    ) -> Option<TransportError> {
-        let validator_list = self.get_validator_list(banks_client).await;
-        let mut instructions = vec![instruction::update_validator_list_balance_chunk(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            &validator_list,
-            len,
-            0,
-            no_merge,
-        )
-        .unwrap()];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn update_stake_pool_balance(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::update_stake_pool_balance(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            &self.pool_fee_account.pubkey(),
-            &self.pool_mint.pubkey(),
-            &self.token_program_id,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn cleanup_removed_validator_entries(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::cleanup_removed_validator_entries(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.validator_list.pubkey(),
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn update_all(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        no_merge: bool,
-    ) -> Option<TransportError> {
-        let validator_list = self.get_validator_list(banks_client).await;
-        let mut instructions = vec![];
-        for (i, chunk) in validator_list
-            .validators
-            .chunks(MAX_VALIDATORS_TO_UPDATE)
-            .enumerate()
-        {
-            instructions.push(
-                instruction::update_validator_list_balance_chunk(
-                    &id(),
-                    &self.stake_pool.pubkey(),
-                    &self.withdraw_authority,
-                    &self.validator_list.pubkey(),
-                    &self.reserve_stake.pubkey(),
-                    &validator_list,
-                    chunk.len(),
-                    i * MAX_VALIDATORS_TO_UPDATE,
-                    no_merge,
-                )
-                .unwrap(),
-            );
-        }
-        instructions.extend([
-            instruction::update_stake_pool_balance(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.withdraw_authority,
-                &self.validator_list.pubkey(),
-                &self.reserve_stake.pubkey(),
-                &self.pool_fee_account.pubkey(),
-                &self.pool_mint.pubkey(),
-                &self.token_program_id,
-            ),
-            instruction::cleanup_removed_validator_entries(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.validator_list.pubkey(),
-            ),
-        ]);
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn add_validator_to_pool(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake: &Pubkey,
-        validator: &Pubkey,
-        seed: Option<NonZeroU32>,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::add_validator_to_pool(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.reserve_stake.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            stake,
-            validator,
-            seed,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn remove_validator_from_pool(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_stake: &Pubkey,
-        transient_stake: &Pubkey,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::remove_validator_from_pool(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            validator_stake,
-            transient_stake,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn decrease_validator_stake_deprecated(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_stake: &Pubkey,
-        transient_stake: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-    ) -> Option<TransportError> {
-        #[allow(deprecated)]
-        let mut instructions = vec![
-            system_instruction::transfer(
-                &payer.pubkey(),
-                transient_stake,
-                STAKE_ACCOUNT_RENT_EXEMPTION,
-            ),
-            instruction::decrease_validator_stake(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.staker.pubkey(),
-                &self.withdraw_authority,
-                &self.validator_list.pubkey(),
-                validator_stake,
-                transient_stake,
-                lamports,
-                transient_stake_seed,
-            ),
-        ];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn decrease_validator_stake_with_reserve(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_stake: &Pubkey,
-        transient_stake: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::decrease_validator_stake_with_reserve(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            validator_stake,
-            transient_stake,
-            lamports,
-            transient_stake_seed,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn decrease_additional_validator_stake(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_stake: &Pubkey,
-        ephemeral_stake: &Pubkey,
-        transient_stake: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-        ephemeral_stake_seed: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::decrease_additional_validator_stake(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            validator_stake,
-            ephemeral_stake,
-            transient_stake,
-            lamports,
-            transient_stake_seed,
-            ephemeral_stake_seed,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn decrease_validator_stake_either(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_stake: &Pubkey,
-        transient_stake: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-        instruction_type: DecreaseInstruction,
-    ) -> Option<TransportError> {
-        match instruction_type {
-            DecreaseInstruction::Additional => {
-                let ephemeral_stake_seed = 0;
-                let ephemeral_stake = find_ephemeral_stake_program_address(
-                    &id(),
-                    &self.stake_pool.pubkey(),
-                    ephemeral_stake_seed,
-                )
-                .0;
-                self.decrease_additional_validator_stake(
-                    banks_client,
-                    payer,
-                    recent_blockhash,
-                    validator_stake,
-                    &ephemeral_stake,
-                    transient_stake,
-                    lamports,
-                    transient_stake_seed,
-                    ephemeral_stake_seed,
-                )
-                .await
-            }
-            DecreaseInstruction::Reserve => {
-                self.decrease_validator_stake_with_reserve(
-                    banks_client,
-                    payer,
-                    recent_blockhash,
-                    validator_stake,
-                    transient_stake,
-                    lamports,
-                    transient_stake_seed,
-                )
-                .await
-            }
-            DecreaseInstruction::Deprecated =>
-            {
-                #[allow(deprecated)]
-                self.decrease_validator_stake_deprecated(
-                    banks_client,
-                    payer,
-                    recent_blockhash,
-                    validator_stake,
-                    transient_stake,
-                    lamports,
-                    transient_stake_seed,
-                )
-                .await
-            }
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn increase_validator_stake(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        transient_stake: &Pubkey,
-        validator_stake: &Pubkey,
-        validator: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::increase_validator_stake(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            transient_stake,
-            validator_stake,
-            validator,
-            lamports,
-            transient_stake_seed,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn increase_additional_validator_stake(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        ephemeral_stake: &Pubkey,
-        transient_stake: &Pubkey,
-        validator_stake: &Pubkey,
-        validator: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-        ephemeral_stake_seed: u64,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::increase_additional_validator_stake(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.withdraw_authority,
-            &self.validator_list.pubkey(),
-            &self.reserve_stake.pubkey(),
-            ephemeral_stake,
-            transient_stake,
-            validator_stake,
-            validator,
-            lamports,
-            transient_stake_seed,
-            ephemeral_stake_seed,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn increase_validator_stake_either(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        transient_stake: &Pubkey,
-        validator_stake: &Pubkey,
-        validator: &Pubkey,
-        lamports: u64,
-        transient_stake_seed: u64,
-        use_additional_instruction: bool,
-    ) -> Option<TransportError> {
-        if use_additional_instruction {
-            let ephemeral_stake_seed = 0;
-            let ephemeral_stake = find_ephemeral_stake_program_address(
-                &id(),
-                &self.stake_pool.pubkey(),
-                ephemeral_stake_seed,
-            )
-            .0;
-            self.increase_additional_validator_stake(
-                banks_client,
-                payer,
-                recent_blockhash,
-                &ephemeral_stake,
-                transient_stake,
-                validator_stake,
-                validator,
-                lamports,
-                transient_stake_seed,
-                ephemeral_stake_seed,
-            )
-            .await
-        } else {
-            self.increase_validator_stake(
-                banks_client,
-                payer,
-                recent_blockhash,
-                transient_stake,
-                validator_stake,
-                validator,
-                lamports,
-                transient_stake_seed,
-            )
-            .await
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn redelegate(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        source_validator_stake: &Pubkey,
-        source_transient_stake: &Pubkey,
-        ephemeral_stake: &Pubkey,
-        destination_transient_stake: &Pubkey,
-        destination_validator_stake: &Pubkey,
-        validator: &Pubkey,
-        lamports: u64,
-        source_transient_stake_seed: u64,
-        ephemeral_stake_seed: u64,
-        destination_transient_stake_seed: u64,
-    ) -> Option<TransportError> {
-        let transaction = Transaction::new_signed_with_payer(
-            &[instruction::redelegate(
-                &id(),
-                &self.stake_pool.pubkey(),
-                &self.staker.pubkey(),
-                &self.withdraw_authority,
-                &self.validator_list.pubkey(),
-                &self.reserve_stake.pubkey(),
-                source_validator_stake,
-                source_transient_stake,
-                ephemeral_stake,
-                destination_transient_stake,
-                destination_validator_stake,
-                validator,
-                lamports,
-                source_transient_stake_seed,
-                ephemeral_stake_seed,
-                destination_transient_stake_seed,
-            )],
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        #[allow(clippy::useless_conversion)] // Remove during upgrade to 1.10
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub async fn set_preferred_validator(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        validator_type: instruction::PreferredValidatorType,
-        validator: Option<Pubkey>,
-    ) -> Option<TransportError> {
-        let mut instructions = vec![instruction::set_preferred_validator(
-            &id(),
-            &self.stake_pool.pubkey(),
-            &self.staker.pubkey(),
-            &self.validator_list.pubkey(),
-            validator_type,
-            validator,
-        )];
-        self.maybe_add_compute_budget_instruction(&mut instructions);
-        let transaction = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&payer.pubkey()),
-            &[payer, &self.staker],
-            *recent_blockhash,
-        );
-        banks_client
-            .process_transaction(transaction)
-            .await
-            .map_err(|e| e.into())
-            .err()
-    }
-
-    pub fn state(&self) -> (state::StakePool, state::ValidatorList) {
-        let (_, stake_withdraw_bump_seed) =
-            find_withdraw_authority_program_address(&id(), &self.stake_pool.pubkey());
-        let stake_pool = state::StakePool {
-            account_type: state::AccountType::StakePool,
-            manager: self.manager.pubkey(),
-            staker: self.staker.pubkey(),
-            stake_deposit_authority: self.stake_deposit_authority,
-            stake_withdraw_bump_seed,
-            validator_list: self.validator_list.pubkey(),
-            reserve_stake: self.reserve_stake.pubkey(),
-            pool_mint: self.pool_mint.pubkey(),
-            manager_fee_account: self.pool_fee_account.pubkey(),
-            token_program_id: self.token_program_id,
-            total_lamports: 0,
-            pool_token_supply: 0,
-            last_update_epoch: 0,
-            lockup: stake::state::Lockup::default(),
-            epoch_fee: self.epoch_fee,
-            next_epoch_fee: FutureEpoch::None,
-            preferred_deposit_validator_vote_address: None,
-            preferred_withdraw_validator_vote_address: None,
-            stake_deposit_fee: state::Fee::default(),
-            sol_deposit_fee: state::Fee::default(),
-            stake_withdrawal_fee: state::Fee::default(),
-            next_stake_withdrawal_fee: FutureEpoch::None,
-            stake_referral_fee: 0,
-            sol_referral_fee: 0,
-            sol_deposit_authority: None,
-            sol_withdraw_authority: None,
-            sol_withdrawal_fee: state::Fee::default(),
-            next_sol_withdrawal_fee: FutureEpoch::None,
-            last_epoch_pool_token_supply: 0,
-            last_epoch_total_lamports: 0,
-        };
-        let mut validator_list = ValidatorList::new(self.max_validators);
-        validator_list.validators = vec![];
-        (stake_pool, validator_list)
-    }
-
-    pub fn maybe_add_compute_budget_instruction(&self, instructions: &mut Vec<Instruction>) {
-        if let Some(compute_unit_limit) = self.compute_unit_limit {
-            instructions.insert(
-                0,
-                ComputeBudgetInstruction::set_compute_unit_limit(compute_unit_limit),
-            );
-        }
-    }
-}
-impl Default for StakePoolAccounts {
-    fn default() -> Self {
-        let stake_pool = Keypair::new();
-        let validator_list = Keypair::new();
-        let stake_pool_address = &stake_pool.pubkey();
-        let (stake_deposit_authority, _) =
-            find_deposit_authority_program_address(&id(), stake_pool_address);
-        let (withdraw_authority, _) =
-            find_withdraw_authority_program_address(&id(), stake_pool_address);
-        let reserve_stake = Keypair::new();
-        let pool_mint = Keypair::new();
-        let pool_fee_account = Keypair::new();
-        let manager = Keypair::new();
-        let staker = Keypair::new();
-
-        Self {
-            stake_pool,
-            validator_list,
-            reserve_stake,
-            token_program_id: spl_token::id(),
-            pool_mint,
-            pool_fee_account,
-            pool_decimals: native_mint::DECIMALS,
-            manager,
-            staker,
-            withdraw_authority,
-            stake_deposit_authority,
-            stake_deposit_authority_keypair: None,
-            epoch_fee: state::Fee {
-                numerator: 1,
-                denominator: 100,
-            },
-            withdrawal_fee: state::Fee {
-                numerator: 3,
-                denominator: 1000,
-            },
-            deposit_fee: state::Fee {
-                numerator: 1,
-                denominator: 1000,
-            },
-            referral_fee: 25,
-            sol_deposit_fee: state::Fee {
-                numerator: 3,
-                denominator: 100,
-            },
-            sol_referral_fee: 50,
-            max_validators: MAX_TEST_VALIDATORS,
-            compute_unit_limit: None,
-        }
-    }
-}
-
-pub async fn simple_add_validator_to_pool(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake_pool_accounts: &StakePoolAccounts,
-    sol_deposit_authority: Option<&Keypair>,
-) -> ValidatorStakeAccount {
-    let validator_stake = ValidatorStakeAccount::new(
-        &stake_pool_accounts.stake_pool.pubkey(),
-        DEFAULT_VALIDATOR_STAKE_SEED,
-        DEFAULT_TRANSIENT_STAKE_SEED,
-    );
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation =
-        stake_pool_get_minimum_delegation(banks_client, payer, recent_blockhash).await;
-
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        payer,
-        &[],
-    )
-    .await
-    .unwrap();
-    let error = stake_pool_accounts
-        .deposit_sol(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &pool_token_account.pubkey(),
-            stake_rent + current_minimum_delegation,
-            sol_deposit_authority,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    create_vote(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    validator_stake
-}
-
-#[derive(Debug)]
-pub struct DepositStakeAccount {
-    pub authority: Keypair,
-    pub stake: Keypair,
-    pub pool_account: Keypair,
-    pub stake_lamports: u64,
-    pub pool_tokens: u64,
-    pub vote_account: Pubkey,
-    pub validator_stake_account: Pubkey,
-}
-
-impl DepositStakeAccount {
-    pub fn new_with_vote(
-        vote_account: Pubkey,
-        validator_stake_account: Pubkey,
-        stake_lamports: u64,
-    ) -> Self {
-        let authority = Keypair::new();
-        let stake = Keypair::new();
-        let pool_account = Keypair::new();
-        Self {
-            authority,
-            stake,
-            pool_account,
-            vote_account,
-            validator_stake_account,
-            stake_lamports,
-            pool_tokens: 0,
-        }
-    }
-
-    pub async fn create_and_delegate(
-        &self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-    ) {
-        let lockup = stake::state::Lockup::default();
-        let authorized = stake::state::Authorized {
-            staker: self.authority.pubkey(),
-            withdrawer: self.authority.pubkey(),
-        };
-        create_independent_stake_account(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.stake,
-            &authorized,
-            &lockup,
-            self.stake_lamports,
-        )
-        .await;
-        delegate_stake_account(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &self.stake.pubkey(),
-            &self.authority,
-            &self.vote_account,
-        )
-        .await;
-    }
-
-    pub async fn deposit_stake(
-        &mut self,
-        banks_client: &mut BanksClient,
-        payer: &Keypair,
-        recent_blockhash: &Hash,
-        stake_pool_accounts: &StakePoolAccounts,
-    ) {
-        // make pool token account
-        create_token_account(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &stake_pool_accounts.token_program_id,
-            &self.pool_account,
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &self.authority,
-            &[],
-        )
-        .await
-        .unwrap();
-
-        let error = stake_pool_accounts
-            .deposit_stake(
-                banks_client,
-                payer,
-                recent_blockhash,
-                &self.stake.pubkey(),
-                &self.pool_account.pubkey(),
-                &self.validator_stake_account,
-                &self.authority,
-            )
-            .await;
-        self.pool_tokens = get_token_balance(banks_client, &self.pool_account.pubkey()).await;
-        assert!(error.is_none(), "{:?}", error);
-    }
-}
-
-pub async fn simple_deposit_stake(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake_pool_accounts: &StakePoolAccounts,
-    validator_stake_account: &ValidatorStakeAccount,
-    stake_lamports: u64,
-) -> Option<DepositStakeAccount> {
-    let authority = Keypair::new();
-    // make stake account
-    let stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-    let authorized = stake::state::Authorized {
-        staker: authority.pubkey(),
-        withdrawer: authority.pubkey(),
-    };
-    create_independent_stake_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake,
-        &authorized,
-        &lockup,
-        stake_lamports,
-    )
-    .await;
-    let vote_account = validator_stake_account.vote.pubkey();
-    delegate_stake_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake.pubkey(),
-        &authority,
-        &vote_account,
-    )
-    .await;
-    // make pool token account
-    let pool_account = Keypair::new();
-    create_token_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &authority,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let validator_stake_account = validator_stake_account.stake_account;
-    let error = stake_pool_accounts
-        .deposit_stake(
-            banks_client,
-            payer,
-            recent_blockhash,
-            &stake.pubkey(),
-            &pool_account.pubkey(),
-            &validator_stake_account,
-            &authority,
-        )
-        .await;
-    // backwards, but oh well!
-    if error.is_some() {
-        return None;
-    }
-
-    let pool_tokens = get_token_balance(banks_client, &pool_account.pubkey()).await;
-
-    Some(DepositStakeAccount {
-        authority,
-        stake,
-        pool_account,
-        stake_lamports,
-        pool_tokens,
-        vote_account,
-        validator_stake_account,
-    })
-}
-
-pub async fn get_validator_list_sum(
-    banks_client: &mut BanksClient,
-    reserve_stake: &Pubkey,
-    validator_list: &Pubkey,
-) -> u64 {
-    let validator_list = banks_client
-        .get_account(*validator_list)
-        .await
-        .unwrap()
-        .unwrap();
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let reserve_stake = banks_client
-        .get_account(*reserve_stake)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let validator_sum: u64 = validator_list
-        .validators
-        .iter()
-        .map(|info| info.stake_lamports().unwrap())
-        .sum();
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    validator_sum + reserve_stake.lamports - rent - MINIMUM_RESERVE_LAMPORTS
-}
-
-pub fn add_vote_account_with_pubkey(
-    voter_pubkey: &Pubkey,
-    program_test: &mut ProgramTest,
-) -> Pubkey {
-    let authorized_voter = Pubkey::new_unique();
-    let authorized_withdrawer = Pubkey::new_unique();
-    let commission = 1;
-
-    // create vote account
-    let node_pubkey = Pubkey::new_unique();
-    let vote_state = VoteStateVersions::new_current(VoteState::new(
-        &VoteInit {
-            node_pubkey,
-            authorized_voter,
-            authorized_withdrawer,
-            commission,
-        },
-        &Clock::default(),
-    ));
-    let vote_account = SolanaAccount::create(
-        ACCOUNT_RENT_EXEMPTION,
-        bincode::serialize::<VoteStateVersions>(&vote_state).unwrap(),
-        solana_vote_program::id(),
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*voter_pubkey, vote_account);
-    *voter_pubkey
-}
-
-pub fn add_vote_account(program_test: &mut ProgramTest) -> Pubkey {
-    let voter_pubkey = Pubkey::new_unique();
-    add_vote_account_with_pubkey(&voter_pubkey, program_test)
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn add_validator_stake_account(
-    program_test: &mut ProgramTest,
-    stake_pool: &mut state::StakePool,
-    validator_list: &mut state::ValidatorList,
-    stake_pool_pubkey: &Pubkey,
-    withdraw_authority: &Pubkey,
-    voter_pubkey: &Pubkey,
-    stake_amount: u64,
-    status: state::StakeStatus,
-) {
-    let meta = stake::state::Meta {
-        rent_exempt_reserve: STAKE_ACCOUNT_RENT_EXEMPTION,
-        authorized: stake::state::Authorized {
-            staker: *withdraw_authority,
-            withdrawer: *withdraw_authority,
-        },
-        lockup: stake_pool.lockup,
-    };
-
-    // create validator stake account
-    let stake = stake::state::Stake {
-        delegation: stake::state::Delegation {
-            voter_pubkey: *voter_pubkey,
-            stake: stake_amount,
-            activation_epoch: FIRST_NORMAL_EPOCH,
-            deactivation_epoch: u64::MAX,
-            ..Default::default()
-        },
-        credits_observed: 0,
-    };
-
-    let mut data = vec![0u8; std::mem::size_of::<stake::state::StakeStateV2>()];
-    let stake_data = bincode::serialize(&stake::state::StakeStateV2::Stake(
-        meta,
-        stake,
-        stake::stake_flags::StakeFlags::empty(),
-    ))
-    .unwrap();
-    data[..stake_data.len()].copy_from_slice(&stake_data);
-    let stake_account = SolanaAccount::create(
-        stake_amount + STAKE_ACCOUNT_RENT_EXEMPTION,
-        data,
-        stake::program::id(),
-        false,
-        Epoch::default(),
-    );
-
-    let raw_suffix = 0;
-    let validator_seed_suffix = NonZeroU32::new(raw_suffix);
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        voter_pubkey,
-        stake_pool_pubkey,
-        validator_seed_suffix,
-    );
-    program_test.add_account(stake_address, stake_account);
-
-    let active_stake_lamports = stake_amount + STAKE_ACCOUNT_RENT_EXEMPTION;
-
-    validator_list.validators.push(state::ValidatorStakeInfo {
-        status: status.into(),
-        vote_account_address: *voter_pubkey,
-        active_stake_lamports: active_stake_lamports.into(),
-        transient_stake_lamports: 0.into(),
-        last_update_epoch: FIRST_NORMAL_EPOCH.into(),
-        transient_seed_suffix: 0.into(),
-        unused: 0.into(),
-        validator_seed_suffix: raw_suffix.into(),
-    });
-
-    stake_pool.total_lamports += active_stake_lamports;
-    stake_pool.pool_token_supply += active_stake_lamports;
-}
-
-pub fn add_reserve_stake_account(
-    program_test: &mut ProgramTest,
-    reserve_stake: &Pubkey,
-    withdraw_authority: &Pubkey,
-    stake_amount: u64,
-) {
-    let meta = stake::state::Meta {
-        rent_exempt_reserve: STAKE_ACCOUNT_RENT_EXEMPTION,
-        authorized: stake::state::Authorized {
-            staker: *withdraw_authority,
-            withdrawer: *withdraw_authority,
-        },
-        lockup: stake::state::Lockup::default(),
-    };
-    let reserve_stake_account = SolanaAccount::create(
-        stake_amount + STAKE_ACCOUNT_RENT_EXEMPTION,
-        bincode::serialize::<stake::state::StakeStateV2>(&stake::state::StakeStateV2::Initialized(
-            meta,
-        ))
-        .unwrap(),
-        stake::program::id(),
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*reserve_stake, reserve_stake_account);
-}
-
-pub fn add_stake_pool_account(
-    program_test: &mut ProgramTest,
-    stake_pool_pubkey: &Pubkey,
-    stake_pool: &state::StakePool,
-) {
-    let mut stake_pool_bytes = borsh::to_vec(&stake_pool).unwrap();
-    // more room for optionals
-    stake_pool_bytes.extend_from_slice(Pubkey::default().as_ref());
-    stake_pool_bytes.extend_from_slice(Pubkey::default().as_ref());
-    let stake_pool_account = SolanaAccount::create(
-        ACCOUNT_RENT_EXEMPTION,
-        stake_pool_bytes,
-        id(),
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*stake_pool_pubkey, stake_pool_account);
-}
-
-pub fn add_validator_list_account(
-    program_test: &mut ProgramTest,
-    validator_list_pubkey: &Pubkey,
-    validator_list: &state::ValidatorList,
-    max_validators: u32,
-) {
-    let mut validator_list_bytes = borsh::to_vec(&validator_list).unwrap();
-    // add extra room if needed
-    for _ in validator_list.validators.len()..max_validators as usize {
-        validator_list_bytes
-            .append(&mut borsh::to_vec(&state::ValidatorStakeInfo::default()).unwrap());
-    }
-    let validator_list_account = SolanaAccount::create(
-        ACCOUNT_RENT_EXEMPTION,
-        validator_list_bytes,
-        id(),
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*validator_list_pubkey, validator_list_account);
-}
-
-pub fn add_mint_account(
-    program_test: &mut ProgramTest,
-    program_id: &Pubkey,
-    mint_key: &Pubkey,
-    mint_authority: &Pubkey,
-    supply: u64,
-) {
-    let mut mint_vec = vec![0u8; Mint::LEN];
-    let mint = Mint {
-        mint_authority: COption::Some(*mint_authority),
-        supply,
-        decimals: 9,
-        is_initialized: true,
-        freeze_authority: COption::None,
-    };
-    Pack::pack(mint, &mut mint_vec).unwrap();
-    let stake_pool_mint = SolanaAccount::create(
-        ACCOUNT_RENT_EXEMPTION,
-        mint_vec,
-        *program_id,
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*mint_key, stake_pool_mint);
-}
-
-pub fn add_token_account(
-    program_test: &mut ProgramTest,
-    program_id: &Pubkey,
-    account_key: &Pubkey,
-    mint_key: &Pubkey,
-    owner: &Pubkey,
-) {
-    let mut fee_account_vec = vec![0u8; Account::LEN];
-    let fee_account_data = Account {
-        mint: *mint_key,
-        owner: *owner,
-        amount: 0,
-        delegate: COption::None,
-        state: spl_token_2022::state::AccountState::Initialized,
-        is_native: COption::None,
-        delegated_amount: 0,
-        close_authority: COption::None,
-    };
-    Pack::pack(fee_account_data, &mut fee_account_vec).unwrap();
-    let fee_account = SolanaAccount::create(
-        ACCOUNT_RENT_EXEMPTION,
-        fee_account_vec,
-        *program_id,
-        false,
-        Epoch::default(),
-    );
-    program_test.add_account(*account_key, fee_account);
-}
-
-pub async fn setup_for_withdraw(
-    token_program_id: Pubkey,
-    reserve_lamports: u64,
-) -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    DepositStakeAccount,
-    Keypair,
-    Keypair,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            reserve_lamports,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let deposit_info = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake_account,
-        current_minimum_delegation * 3,
-    )
-    .await
-    .unwrap();
-
-    let tokens_to_withdraw = deposit_info.pool_tokens;
-
-    // Delegate tokens for withdrawing
-    let user_transfer_authority = Keypair::new();
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-        &user_transfer_authority.pubkey(),
-        tokens_to_withdraw,
-    )
-    .await;
-
-    // Create stake account to withdraw to
-    let user_stake_recipient = Keypair::new();
-    create_blank_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &user_stake_recipient,
-    )
-    .await;
-
-    (
-        context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    )
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum DecreaseInstruction {
-    Additional,
-    Reserve,
-    Deprecated,
-}
diff --git a/stake-pool/program/tests/huge_pool.rs b/stake-pool/program/tests/huge_pool.rs
deleted file mode 100644
index 52662095bed..00000000000
--- a/stake-pool/program/tests/huge_pool.rs
+++ /dev/null
@@ -1,710 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{borsh1::try_from_slice_unchecked, pubkey::Pubkey, stake},
-    solana_program_test::*,
-    solana_sdk::{
-        native_token::LAMPORTS_PER_SOL,
-        signature::{Keypair, Signer},
-        transaction::Transaction,
-    },
-    spl_stake_pool::{
-        find_stake_program_address, find_transient_stake_program_address, id,
-        instruction::{self, PreferredValidatorType},
-        state::{StakePool, StakeStatus, ValidatorList},
-        MAX_VALIDATORS_TO_UPDATE,
-    },
-    test_case::test_case,
-};
-
-// Note: this is not the real max! The testing framework starts to blow out
-// because the test require so many helper accounts.
-// 20k is also a very safe number for the current upper bound of the network.
-const MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS: u32 = 20_000;
-const MAX_POOL_SIZE: u32 = 3_000;
-const STAKE_AMOUNT: u64 = 200_000_000_000;
-
-async fn setup(
-    max_validators: u32,
-    num_validators: u32,
-    stake_amount: u64,
-) -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    Vec<Pubkey>,
-    Pubkey,
-    Keypair,
-    Pubkey,
-    Pubkey,
-) {
-    let mut program_test = program_test();
-    let mut vote_account_pubkeys = vec![];
-    let mut stake_pool_accounts = StakePoolAccounts {
-        max_validators,
-        ..Default::default()
-    };
-    if max_validators > MAX_POOL_SIZE {
-        stake_pool_accounts.compute_unit_limit = Some(1_400_000);
-    }
-
-    let stake_pool_pubkey = stake_pool_accounts.stake_pool.pubkey();
-    let (mut stake_pool, mut validator_list) = stake_pool_accounts.state();
-    stake_pool.last_update_epoch = FIRST_NORMAL_EPOCH;
-
-    for _ in 0..max_validators {
-        vote_account_pubkeys.push(add_vote_account(&mut program_test));
-    }
-
-    for vote_account_address in vote_account_pubkeys.iter().take(num_validators as usize) {
-        add_validator_stake_account(
-            &mut program_test,
-            &mut stake_pool,
-            &mut validator_list,
-            &stake_pool_pubkey,
-            &stake_pool_accounts.withdraw_authority,
-            vote_account_address,
-            stake_amount,
-            StakeStatus::Active,
-        );
-    }
-
-    add_reserve_stake_account(
-        &mut program_test,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        stake_amount,
-    );
-    add_stake_pool_account(
-        &mut program_test,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool,
-    );
-    add_validator_list_account(
-        &mut program_test,
-        &stake_pool_accounts.validator_list.pubkey(),
-        &validator_list,
-        max_validators,
-    );
-
-    add_mint_account(
-        &mut program_test,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool.pool_token_supply,
-    );
-    add_token_account(
-        &mut program_test,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-    );
-
-    let mut context = program_test.start_with_context().await;
-    let epoch_schedule = &context.genesis_config().epoch_schedule;
-    let slot = epoch_schedule.first_normal_slot + epoch_schedule.slots_per_epoch + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    let vote_pubkey = vote_account_pubkeys[max_validators as usize - 1];
-    // make stake account
-    let user = Keypair::new();
-    let deposit_stake = Keypair::new();
-    let lockup = stake::state::Lockup::default();
-
-    let authorized = stake::state::Authorized {
-        staker: user.pubkey(),
-        withdrawer: user.pubkey(),
-    };
-
-    let _stake_lamports = create_independent_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake,
-        &authorized,
-        &lockup,
-        stake_amount,
-    )
-    .await;
-
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &deposit_stake.pubkey(),
-        &user,
-        &vote_pubkey,
-    )
-    .await;
-
-    // make pool token account
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        vote_account_pubkeys,
-        vote_pubkey,
-        user,
-        deposit_stake.pubkey(),
-        pool_token_account.pubkey(),
-    )
-}
-
-#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn update(max_validators: u32) {
-    let (mut context, stake_pool_accounts, _, _, _, _, _) =
-        setup(max_validators, max_validators, STAKE_AMOUNT).await;
-
-    let error = stake_pool_accounts
-        .update_validator_list_balance(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MAX_VALIDATORS_TO_UPDATE,
-            false, /* no_merge */
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .cleanup_removed_validator_entries(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-//#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn remove_validator_from_pool(max_validators: u32) {
-    let (mut context, stake_pool_accounts, vote_account_pubkeys, _, _, _, _) =
-        setup(max_validators, max_validators, LAMPORTS_PER_SOL).await;
-
-    let first_vote = vote_account_pubkeys[0];
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &first_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-    let transient_stake_seed = u64::MAX;
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        &id(),
-        &first_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    );
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_address,
-            &transient_stake_address,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let middle_index = max_validators as usize / 2;
-    let middle_vote = vote_account_pubkeys[middle_index];
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &middle_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        &id(),
-        &middle_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    );
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_address,
-            &transient_stake_address,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let last_index = max_validators as usize - 1;
-    let last_vote = vote_account_pubkeys[last_index];
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &last_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        &id(),
-        &last_vote,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    );
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_address,
-            &transient_stake_address,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let first_element = &validator_list.validators[0];
-    assert_eq!(
-        first_element.status,
-        StakeStatus::DeactivatingValidator.into()
-    );
-    assert_eq!(
-        u64::from(first_element.active_stake_lamports),
-        LAMPORTS_PER_SOL + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(u64::from(first_element.transient_stake_lamports), 0);
-
-    let middle_element = &validator_list.validators[middle_index];
-    assert_eq!(
-        middle_element.status,
-        StakeStatus::DeactivatingValidator.into()
-    );
-    assert_eq!(
-        u64::from(middle_element.active_stake_lamports),
-        LAMPORTS_PER_SOL + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(u64::from(middle_element.transient_stake_lamports), 0);
-
-    let last_element = &validator_list.validators[last_index];
-    assert_eq!(
-        last_element.status,
-        StakeStatus::DeactivatingValidator.into()
-    );
-    assert_eq!(
-        u64::from(last_element.active_stake_lamports),
-        LAMPORTS_PER_SOL + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(u64::from(last_element.transient_stake_lamports), 0);
-
-    let error = stake_pool_accounts
-        .update_validator_list_balance(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            1,
-            false, /* no_merge */
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let mut instructions = vec![instruction::update_validator_list_balance_chunk(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &stake_pool_accounts.validator_list.pubkey(),
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &validator_list,
-        1,
-        middle_index,
-        /* no_merge = */ false,
-    )
-    .unwrap()];
-    stake_pool_accounts.maybe_add_compute_budget_instruction(&mut instructions);
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err();
-    assert!(error.is_none(), "{:?}", error);
-
-    let mut instructions = vec![instruction::update_validator_list_balance_chunk(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &stake_pool_accounts.validator_list.pubkey(),
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &validator_list,
-        1,
-        last_index,
-        /* no_merge = */ false,
-    )
-    .unwrap()];
-    stake_pool_accounts.maybe_add_compute_budget_instruction(&mut instructions);
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err();
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .cleanup_removed_validator_entries(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(validator_list.validators.len() as u32, max_validators - 3);
-    // assert they're gone
-    assert!(!validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == first_vote));
-    assert!(!validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == middle_vote));
-    assert!(!validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == last_vote));
-
-    // but that we didn't remove too many
-    assert!(validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == vote_account_pubkeys[1]));
-    assert!(validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == vote_account_pubkeys[middle_index - 1]));
-    assert!(validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == vote_account_pubkeys[middle_index + 1]));
-    assert!(validator_list
-        .validators
-        .iter()
-        .any(|x| x.vote_account_address == vote_account_pubkeys[last_index - 1]));
-}
-
-//#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn add_validator_to_pool(max_validators: u32) {
-    let (mut context, stake_pool_accounts, _, test_vote_address, _, _, _) =
-        setup(max_validators, max_validators - 1, STAKE_AMOUNT).await;
-
-    let last_index = max_validators as usize - 1;
-    let stake_pool_pubkey = stake_pool_accounts.stake_pool.pubkey();
-    let (stake_address, _) =
-        find_stake_program_address(&id(), &test_vote_address, &stake_pool_pubkey, None);
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_address,
-            &test_vote_address,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(validator_list.validators.len(), last_index + 1);
-    let last_element = validator_list.validators[last_index];
-    assert_eq!(last_element.status, StakeStatus::Active.into());
-    assert_eq!(
-        u64::from(last_element.active_stake_lamports),
-        LAMPORTS_PER_SOL + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(u64::from(last_element.transient_stake_lamports), 0);
-    assert_eq!(last_element.vote_account_address, test_vote_address);
-
-    let transient_stake_seed = u64::MAX;
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        &id(),
-        &test_vote_address,
-        &stake_pool_pubkey,
-        transient_stake_seed,
-    );
-    let increase_amount = LAMPORTS_PER_SOL;
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &transient_stake_address,
-            &stake_address,
-            &test_vote_address,
-            increase_amount,
-            transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let last_element = validator_list.validators[last_index];
-    assert_eq!(last_element.status, StakeStatus::Active.into());
-    assert_eq!(
-        u64::from(last_element.active_stake_lamports),
-        LAMPORTS_PER_SOL + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(
-        u64::from(last_element.transient_stake_lamports),
-        increase_amount + STAKE_ACCOUNT_RENT_EXEMPTION
-    );
-    assert_eq!(last_element.vote_account_address, test_vote_address);
-}
-
-//#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn set_preferred(max_validators: u32) {
-    let (mut context, stake_pool_accounts, _, vote_account_address, _, _, _) =
-        setup(max_validators, max_validators, STAKE_AMOUNT).await;
-
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            PreferredValidatorType::Deposit,
-            Some(vote_account_address),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            PreferredValidatorType::Withdraw,
-            Some(vote_account_address),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.preferred_deposit_validator_vote_address,
-        Some(vote_account_address)
-    );
-    assert_eq!(
-        stake_pool.preferred_withdraw_validator_vote_address,
-        Some(vote_account_address)
-    );
-}
-
-#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn deposit_stake(max_validators: u32) {
-    let (mut context, stake_pool_accounts, _, vote_pubkey, user, stake_pubkey, pool_account_pubkey) =
-        setup(max_validators, max_validators, STAKE_AMOUNT).await;
-
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &vote_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pubkey,
-            &pool_account_pubkey,
-            &stake_address,
-            &user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn withdraw(max_validators: u32) {
-    let (mut context, stake_pool_accounts, _, vote_pubkey, user, stake_pubkey, pool_account_pubkey) =
-        setup(max_validators, max_validators, STAKE_AMOUNT).await;
-
-    let (stake_address, _) = find_stake_program_address(
-        &id(),
-        &vote_pubkey,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-
-    let error = stake_pool_accounts
-        .deposit_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pubkey,
-            &pool_account_pubkey,
-            &stake_address,
-            &user,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Create stake account to withdraw to
-    let user_stake_recipient = Keypair::new();
-    create_blank_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &user_stake_recipient,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user,
-            &pool_account_pubkey,
-            &stake_address,
-            &user.pubkey(),
-            TEST_STAKE_AMOUNT,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-//#[test_case(MAX_POOL_SIZE_WITH_REQUESTED_COMPUTE_UNITS; "compute-budget")]
-#[test_case(MAX_POOL_SIZE; "no-compute-budget")]
-#[tokio::test]
-async fn cleanup_all(max_validators: u32) {
-    let mut program_test = program_test();
-    let mut vote_account_pubkeys = vec![];
-    let mut stake_pool_accounts = StakePoolAccounts {
-        max_validators,
-        ..Default::default()
-    };
-    if max_validators > MAX_POOL_SIZE {
-        stake_pool_accounts.compute_unit_limit = Some(1_400_000);
-    }
-
-    let stake_pool_pubkey = stake_pool_accounts.stake_pool.pubkey();
-    let (mut stake_pool, mut validator_list) = stake_pool_accounts.state();
-
-    for _ in 0..max_validators {
-        vote_account_pubkeys.push(add_vote_account(&mut program_test));
-    }
-
-    for vote_account_address in vote_account_pubkeys.iter() {
-        add_validator_stake_account(
-            &mut program_test,
-            &mut stake_pool,
-            &mut validator_list,
-            &stake_pool_pubkey,
-            &stake_pool_accounts.withdraw_authority,
-            vote_account_address,
-            STAKE_AMOUNT,
-            StakeStatus::ReadyForRemoval,
-        );
-    }
-
-    add_stake_pool_account(
-        &mut program_test,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool,
-    );
-    add_validator_list_account(
-        &mut program_test,
-        &stake_pool_accounts.validator_list.pubkey(),
-        &validator_list,
-        max_validators,
-    );
-    let mut context = program_test.start_with_context().await;
-
-    let error = stake_pool_accounts
-        .cleanup_removed_validator_entries(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
diff --git a/stake-pool/program/tests/increase.rs b/stake-pool/program/tests/increase.rs
deleted file mode 100644
index 67fac5f119b..00000000000
--- a/stake-pool/program/tests/increase.rs
+++ /dev/null
@@ -1,595 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{clock::Epoch, instruction::InstructionError, pubkey::Pubkey, stake},
-    solana_program_test::*,
-    solana_sdk::{
-        signature::Signer,
-        stake::instruction::StakeError,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_ephemeral_stake_program_address,
-        find_transient_stake_program_address, id, instruction, MINIMUM_RESERVE_LAMPORTS,
-    },
-    test_case::test_case,
-};
-
-async fn setup() -> (
-    ProgramTestContext,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let reserve_lamports = 100_000_000_000 + MINIMUM_RESERVE_LAMPORTS;
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            reserve_lamports,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let _deposit_info = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake_account,
-        current_minimum_delegation * 2 + stake_rent,
-    )
-    .await
-    .unwrap();
-
-    (
-        context,
-        stake_pool_accounts,
-        validator_stake_account,
-        reserve_lamports,
-    )
-}
-
-#[test_case(true; "additional")]
-#[test_case(false; "non-additional")]
-#[tokio::test]
-async fn success(use_additional_instruction: bool) {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    // Save reserve stake
-    let pre_reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-
-    // Check no transient stake
-    let transient_account = context
-        .banks_client
-        .get_account(validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(transient_account.is_none());
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let increase_amount = reserve_lamports - stake_rent - MINIMUM_RESERVE_LAMPORTS;
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            increase_amount,
-            validator_stake.transient_stake_seed,
-            use_additional_instruction,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check reserve stake account balance
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    let reserve_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&reserve_stake_account.data).unwrap();
-    assert_eq!(
-        pre_reserve_stake_account.lamports - increase_amount - stake_rent,
-        reserve_stake_account.lamports
-    );
-    assert!(reserve_stake_state.delegation().is_none());
-
-    // Check transient stake account state and balance
-    let transient_stake_account = get_account(
-        &mut context.banks_client,
-        &validator_stake.transient_stake_account,
-    )
-    .await;
-    let transient_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&transient_stake_account.data).unwrap();
-    assert_eq!(
-        transient_stake_account.lamports,
-        increase_amount + stake_rent
-    );
-    assert_ne!(
-        transient_stake_state.delegation().unwrap().activation_epoch,
-        Epoch::MAX
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let wrong_authority = Pubkey::new_unique();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::increase_validator_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &wrong_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            reserve_lamports / 2,
-            validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list() {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let wrong_validator_list = Pubkey::new_unique();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::increase_validator_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &wrong_validator_list,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            reserve_lamports / 2,
-            validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_unknown_validator() {
-    let (mut context, stake_pool_accounts, _validator_stake, reserve_lamports) = setup().await;
-
-    let unknown_stake = create_unknown_validator_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        0,
-    )
-    .await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::increase_validator_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &unknown_stake.transient_stake_account,
-            &unknown_stake.stake_account,
-            &unknown_stake.vote.pubkey(),
-            reserve_lamports / 2,
-            unknown_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-}
-
-#[test_case(true; "additional")]
-#[test_case(false; "non-additional")]
-#[tokio::test]
-async fn fail_twice_diff_seed(use_additional_instruction: bool) {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let first_increase = reserve_lamports / 3;
-    let second_increase = reserve_lamports / 4;
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            first_increase,
-            validator_stake.transient_stake_seed,
-            use_additional_instruction,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let transient_stake_seed = validator_stake.transient_stake_seed * 100;
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &validator_stake.vote.pubkey(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &transient_stake_address,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            second_increase,
-            transient_stake_seed,
-            use_additional_instruction,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    if use_additional_instruction {
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(0, InstructionError::InvalidSeeds)
-        );
-    } else {
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(StakePoolError::TransientAccountInUse as u32)
-            )
-        );
-    }
-}
-
-#[test_case(true, true, true; "success-all-additional")]
-#[test_case(true, false, true; "success-with-additional")]
-#[test_case(false, true, false; "fail-without-additional")]
-#[test_case(false, false, false; "fail-no-additional")]
-#[tokio::test]
-async fn twice(success: bool, use_additional_first_time: bool, use_additional_second_time: bool) {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let pre_reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-
-    let first_increase = reserve_lamports / 3;
-    let second_increase = reserve_lamports / 4;
-    let total_increase = first_increase + second_increase;
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            first_increase,
-            validator_stake.transient_stake_seed,
-            use_additional_first_time,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            second_increase,
-            validator_stake.transient_stake_seed,
-            use_additional_second_time,
-        )
-        .await;
-
-    if success {
-        assert!(error.is_none(), "{:?}", error);
-        let rent = context.banks_client.get_rent().await.unwrap();
-        let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-        // no ephemeral account
-        let ephemeral_stake = find_ephemeral_stake_program_address(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            0,
-        )
-        .0;
-        let ephemeral_account = context
-            .banks_client
-            .get_account(ephemeral_stake)
-            .await
-            .unwrap();
-        assert!(ephemeral_account.is_none());
-        // Check reserve stake account balance
-        let reserve_stake_account = get_account(
-            &mut context.banks_client,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-        )
-        .await;
-        let reserve_stake_state =
-            deserialize::<stake::state::StakeStateV2>(&reserve_stake_account.data).unwrap();
-        assert_eq!(
-            pre_reserve_stake_account.lamports - total_increase - stake_rent * 2,
-            reserve_stake_account.lamports
-        );
-        assert!(reserve_stake_state.delegation().is_none());
-
-        // Check transient stake account state and balance
-        let transient_stake_account = get_account(
-            &mut context.banks_client,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-        let transient_stake_state =
-            deserialize::<stake::state::StakeStateV2>(&transient_stake_account.data).unwrap();
-        assert_eq!(
-            transient_stake_account.lamports,
-            total_increase + stake_rent * 2
-        );
-        assert_ne!(
-            transient_stake_state.delegation().unwrap().activation_epoch,
-            Epoch::MAX
-        );
-
-        // marked correctly in the list
-        let validator_list = stake_pool_accounts
-            .get_validator_list(&mut context.banks_client)
-            .await;
-        let entry = validator_list.find(&validator_stake.vote.pubkey()).unwrap();
-        assert_eq!(
-            u64::from(entry.transient_stake_lamports),
-            total_increase + stake_rent * 2
-        );
-    } else {
-        let error = error.unwrap().unwrap();
-        match error {
-            TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-                let program_error = StakePoolError::TransientAccountInUse as u32;
-                assert_eq!(error_index, program_error);
-            }
-            _ => panic!("Wrong error"),
-        }
-    }
-}
-
-#[test_case(true; "additional")]
-#[test_case(false; "non-additional")]
-#[tokio::test]
-async fn fail_with_small_lamport_amount(use_additional_instruction: bool) {
-    let (mut context, stake_pool_accounts, validator_stake, _reserve_lamports) = setup().await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            current_minimum_delegation - 1,
-            validator_stake.transient_stake_seed,
-            use_additional_instruction,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = StakeError::InsufficientDelegation as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error"),
-    }
-}
-
-#[test_case(true; "additional")]
-#[test_case(false; "non-additional")]
-#[tokio::test]
-async fn fail_overdraw_reserve(use_additional_instruction: bool) {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            reserve_lamports,
-            validator_stake.transient_stake_seed,
-            use_additional_instruction,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::InsufficientFunds) => {}
-        _ => panic!("Wrong error occurs while overdrawing reserve stake"),
-    }
-}
-
-#[tokio::test]
-async fn fail_additional_with_decreasing() {
-    let (mut context, stake_pool_accounts, validator_stake, reserve_lamports) = setup().await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // warp forward to activation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            current_minimum_delegation + stake_rent,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .increase_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            reserve_lamports / 2,
-            validator_stake.transient_stake_seed,
-            true,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::WrongStakeStake as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_force_destaked_validator() {}
diff --git a/stake-pool/program/tests/initialize.rs b/stake-pool/program/tests/initialize.rs
deleted file mode 100644
index fa65c709908..00000000000
--- a/stake-pool/program/tests/initialize.rs
+++ /dev/null
@@ -1,1632 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::{get_instance_packed_len, get_packed_len, try_from_slice_unchecked},
-        hash::Hash,
-        instruction::{AccountMeta, Instruction},
-        program_pack::Pack,
-        pubkey::Pubkey,
-        stake, system_instruction, sysvar,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{error, id, instruction, state, MINIMUM_RESERVE_LAMPORTS},
-    spl_token_2022::extension::ExtensionType,
-    test_case::test_case,
-};
-
-async fn create_required_accounts(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: &Hash,
-    stake_pool_accounts: &StakePoolAccounts,
-    mint_extensions: &[ExtensionType],
-) {
-    create_mint(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint,
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool_accounts.pool_decimals,
-        mint_extensions,
-    )
-    .await
-    .unwrap();
-
-    let required_extensions = ExtensionType::get_required_init_account_extensions(mint_extensions);
-    create_token_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &required_extensions,
-    )
-    .await
-    .unwrap();
-
-    create_independent_stake_account(
-        banks_client,
-        payer,
-        recent_blockhash,
-        &stake_pool_accounts.reserve_stake,
-        &stake::state::Authorized {
-            staker: stake_pool_accounts.withdraw_authority,
-            withdrawer: stake_pool_accounts.withdraw_authority,
-        },
-        &stake::state::Lockup::default(),
-        MINIMUM_RESERVE_LAMPORTS,
-    )
-    .await;
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    // Stake pool now exists
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    assert_eq!(stake_pool.data.len(), get_packed_len::<state::StakePool>());
-    assert_eq!(stake_pool.owner, id());
-
-    // Validator stake list storage initialized
-    let validator_list = get_account(
-        &mut banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert!(validator_list.header.is_valid());
-}
-
-#[tokio::test]
-async fn fail_double_initialize() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let latest_blockhash = banks_client.get_latest_blockhash().await.unwrap();
-
-    let second_stake_pool_accounts = StakePoolAccounts {
-        stake_pool: stake_pool_accounts.stake_pool,
-        ..Default::default()
-    };
-
-    let transaction_error = second_stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &latest_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .err()
-        .unwrap();
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::AlreadyInUse as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize already initialized stake pool"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_already_initialized_validator_list() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let latest_blockhash = banks_client.get_latest_blockhash().await.unwrap();
-
-    let second_stake_pool_accounts = StakePoolAccounts {
-        validator_list: stake_pool_accounts.validator_list,
-        ..Default::default()
-    };
-
-    let transaction_error = second_stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &latest_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .err()
-        .unwrap();
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::AlreadyInUse as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize stake pool with already initialized stake list storage"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_high_fee() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts {
-        epoch_fee: state::Fee {
-            numerator: 100_001,
-            denominator: 100_000,
-        },
-        ..Default::default()
-    };
-
-    let transaction_error = stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .err()
-        .unwrap();
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize stake pool with high fee"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_high_withdrawal_fee() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts {
-        withdrawal_fee: state::Fee {
-            numerator: 100_001,
-            denominator: 100_000,
-        },
-        ..Default::default()
-    };
-
-    let transaction_error = stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .err()
-        .unwrap();
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => {
-            panic!("Wrong error occurs while try to initialize stake pool with high withdrawal fee")
-        }
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_max_validators() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators - 1,
-    ))
-    .unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.manager.pubkey(),
-                &stake_pool_accounts.staker.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &spl_token::id(),
-                None,
-                stake_pool_accounts.epoch_fee,
-                stake_pool_accounts.withdrawal_fee,
-                stake_pool_accounts.deposit_fee,
-                stake_pool_accounts.referral_fee,
-                stake_pool_accounts.max_validators,
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &stake_pool_accounts.manager,
-        ],
-        recent_blockhash,
-    );
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::UnexpectedValidatorListAccountSize as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize stake pool with high fee"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_mint_authority() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let wrong_mint = Keypair::new();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    // create wrong mint
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &wrong_mint,
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool_accounts.pool_decimals,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let transaction_error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &wrong_mint.pubkey(),
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::InvalidFeeAccount as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize stake pool with wrong mint authority of pool fee account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_freeze_authority() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    // create mint with freeze authority
-    let wrong_mint = Keypair::new();
-    let rent = banks_client.get_rent().await.unwrap();
-    let mint_rent = rent.minimum_balance(spl_token::state::Mint::LEN);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &wrong_mint.pubkey(),
-                mint_rent,
-                spl_token::state::Mint::LEN as u64,
-                &spl_token::id(),
-            ),
-            spl_token::instruction::initialize_mint(
-                &spl_token::id(),
-                &wrong_mint.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                Some(&stake_pool_accounts.withdraw_authority),
-                stake_pool_accounts.pool_decimals,
-            )
-            .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[&payer, &wrong_mint],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let pool_fee_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_fee_account,
-        &wrong_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &wrong_mint.pubkey(),
-        &pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap()
-    .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(error::StakePoolError::InvalidMintFreezeAuthority as u32),
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_with_supported_extensions() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(spl_token_2022::id());
-
-    let mint_extensions = vec![ExtensionType::TransferFeeConfig];
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &mint_extensions,
-    )
-    .await;
-
-    let mut account_extensions =
-        ExtensionType::get_required_init_account_extensions(&mint_extensions);
-    account_extensions.push(ExtensionType::CpiGuard);
-    let pool_fee_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &account_extensions,
-    )
-    .await
-    .unwrap();
-
-    create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn fail_with_unsupported_mint_extension() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(spl_token_2022::id());
-
-    let mint_extensions = vec![ExtensionType::NonTransferable];
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &mint_extensions,
-    )
-    .await;
-
-    let required_extensions = ExtensionType::get_required_init_account_extensions(&mint_extensions);
-    let pool_fee_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &required_extensions,
-    )
-    .await
-    .unwrap();
-
-    let error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap()
-    .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(error::StakePoolError::UnsupportedMintExtension as u32),
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_unsupported_account_extension() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(spl_token_2022::id());
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    let extensions = vec![ExtensionType::MemoTransfer];
-    let pool_fee_account = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &extensions,
-    )
-    .await
-    .unwrap();
-
-    let error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap()
-    .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(error::StakePoolError::UnsupportedFeeAccountExtension as u32),
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_token_program_id() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    let wrong_token_program = Keypair::new();
-
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint,
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool_accounts.pool_decimals,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators,
-    ))
-    .unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.manager.pubkey(),
-                &stake_pool_accounts.staker.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &wrong_token_program.pubkey(),
-                None,
-                stake_pool_accounts.epoch_fee,
-                stake_pool_accounts.withdrawal_fee,
-                stake_pool_accounts.deposit_fee,
-                stake_pool_accounts.referral_fee,
-                stake_pool_accounts.max_validators,
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &stake_pool_accounts.manager,
-        ],
-        recent_blockhash,
-    );
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to initialize stake pool with wrong token program ID"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_fee_owned_by_wrong_token_program_id() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    let wrong_token_program = Keypair::new();
-
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint,
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool_accounts.pool_decimals,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let rent = banks_client.get_rent().await.unwrap();
-
-    let account_rent = rent.minimum_balance(spl_token::state::Account::LEN);
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            account_rent,
-            spl_token::state::Account::LEN as u64,
-            &wrong_token_program.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &stake_pool_accounts.pool_fee_account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators,
-    ))
-    .unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.manager.pubkey(),
-                &stake_pool_accounts.staker.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &wrong_token_program.pubkey(),
-                None,
-                stake_pool_accounts.epoch_fee,
-                stake_pool_accounts.withdrawal_fee,
-                stake_pool_accounts.deposit_fee,
-                stake_pool_accounts.referral_fee,
-                stake_pool_accounts.max_validators,
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &stake_pool_accounts.manager,
-        ],
-        recent_blockhash,
-    );
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to initialize stake pool with wrong token program ID"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_fee_account() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint,
-        &stake_pool_accounts.withdraw_authority,
-        stake_pool_accounts.pool_decimals,
-        &[],
-    )
-    .await
-    .unwrap();
-    let rent = banks_client.get_rent().await.unwrap();
-    let account_rent = rent.minimum_balance(spl_token::state::Account::LEN);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            account_rent,
-            spl_token::state::Account::LEN as u64,
-            &Keypair::new().pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[&payer, &stake_pool_accounts.pool_fee_account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let transaction_error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap()
-    .unwrap();
-
-    assert_eq!(
-        transaction_error,
-        TransactionError::InstructionError(2, InstructionError::UninitializedAccount)
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts {
-        withdraw_authority: Keypair::new().pubkey(),
-        ..Default::default()
-    };
-
-    let transaction_error = stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .err()
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to initialize stake pool with wrong withdraw authority"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_not_rent_exempt_pool() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators,
-    ))
-    .unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                1,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.manager.pubkey(),
-                &stake_pool_accounts.staker.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &spl_token::id(),
-                None,
-                stake_pool_accounts.epoch_fee,
-                stake_pool_accounts.withdrawal_fee,
-                stake_pool_accounts.deposit_fee,
-                stake_pool_accounts.referral_fee,
-                stake_pool_accounts.max_validators,
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &stake_pool_accounts.manager,
-        ],
-        recent_blockhash,
-    );
-    let result = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert!(
-        result == TransactionError::InstructionError(2, InstructionError::InvalidError,)
-            || result
-                == TransactionError::InstructionError(2, InstructionError::AccountNotRentExempt,)
-    );
-}
-
-#[tokio::test]
-async fn fail_with_not_rent_exempt_validator_list() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators,
-    ))
-    .unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                1,
-                validator_list_size as u64,
-                &id(),
-            ),
-            instruction::initialize(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.manager.pubkey(),
-                &stake_pool_accounts.staker.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &spl_token::id(),
-                None,
-                stake_pool_accounts.epoch_fee,
-                stake_pool_accounts.withdrawal_fee,
-                stake_pool_accounts.deposit_fee,
-                stake_pool_accounts.referral_fee,
-                stake_pool_accounts.max_validators,
-            ),
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &stake_pool_accounts.manager,
-        ],
-        recent_blockhash,
-    );
-
-    let result = banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-
-    assert!(
-        result == TransactionError::InstructionError(2, InstructionError::InvalidError,)
-            || result
-                == TransactionError::InstructionError(2, InstructionError::AccountNotRentExempt,)
-    );
-}
-
-#[tokio::test]
-async fn fail_without_manager_signature() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let rent_stake_pool = rent.minimum_balance(get_packed_len::<state::StakePool>());
-    let validator_list_size = get_instance_packed_len(&state::ValidatorList::new(
-        stake_pool_accounts.max_validators,
-    ))
-    .unwrap();
-    let rent_validator_list = rent.minimum_balance(validator_list_size);
-
-    let init_data = instruction::StakePoolInstruction::Initialize {
-        fee: stake_pool_accounts.epoch_fee,
-        withdrawal_fee: stake_pool_accounts.withdrawal_fee,
-        deposit_fee: stake_pool_accounts.deposit_fee,
-        referral_fee: stake_pool_accounts.referral_fee,
-        max_validators: stake_pool_accounts.max_validators,
-    };
-    let data = borsh::to_vec(&init_data).unwrap();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), true),
-        AccountMeta::new_readonly(stake_pool_accounts.manager.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.reserve_stake.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.pool_mint.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.pool_fee_account.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-    ];
-    let stake_pool_init_instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data,
-    };
-
-    let mut transaction = Transaction::new_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                rent_stake_pool,
-                get_packed_len::<state::StakePool>() as u64,
-                &id(),
-            ),
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-                rent_validator_list,
-                validator_list_size as u64,
-                &id(),
-            ),
-            stake_pool_init_instruction,
-        ],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[
-            &payer,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-        ],
-        recent_blockhash,
-    );
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to initialize stake pool without manager's signature"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_pre_minted_pool_tokens() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let mint_authority = Keypair::new();
-
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint,
-        &mint_authority.pubkey(),
-        stake_pool_accounts.pool_decimals,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    mint_tokens(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &mint_authority,
-        1,
-    )
-    .await
-    .unwrap();
-
-    let transaction_error = create_stake_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.stake_pool,
-        &stake_pool_accounts.validator_list,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &stake_pool_accounts.staker.pubkey(),
-        &stake_pool_accounts.withdraw_authority,
-        &None,
-        &stake_pool_accounts.epoch_fee,
-        &stake_pool_accounts.withdrawal_fee,
-        &stake_pool_accounts.deposit_fee,
-        stake_pool_accounts.referral_fee,
-        &stake_pool_accounts.sol_deposit_fee,
-        stake_pool_accounts.sol_referral_fee,
-        stake_pool_accounts.max_validators,
-    )
-    .await
-    .err()
-    .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::NonZeroPoolTokenSupply as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to initialize stake pool with wrong mint authority of pool fee account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_bad_reserve() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let wrong_authority = Pubkey::new_unique();
-
-    create_required_accounts(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        &[],
-    )
-    .await;
-
-    {
-        let bad_stake = Keypair::new();
-        create_independent_stake_account(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &bad_stake,
-            &stake::state::Authorized {
-                staker: wrong_authority,
-                withdrawer: stake_pool_accounts.withdraw_authority,
-            },
-            &stake::state::Lockup::default(),
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await;
-
-        let error = create_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &bad_stake.pubkey(),
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.manager,
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &None,
-            &stake_pool_accounts.epoch_fee,
-            &stake_pool_accounts.withdrawal_fee,
-            &stake_pool_accounts.deposit_fee,
-            stake_pool_accounts.referral_fee,
-            &stake_pool_accounts.sol_deposit_fee,
-            stake_pool_accounts.sol_referral_fee,
-            stake_pool_accounts.max_validators,
-        )
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(error::StakePoolError::WrongStakeStake as u32),
-            )
-        );
-    }
-
-    {
-        let bad_stake = Keypair::new();
-        create_independent_stake_account(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &bad_stake,
-            &stake::state::Authorized {
-                staker: stake_pool_accounts.withdraw_authority,
-                withdrawer: wrong_authority,
-            },
-            &stake::state::Lockup::default(),
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await;
-
-        let error = create_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &bad_stake.pubkey(),
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.manager,
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &None,
-            &stake_pool_accounts.epoch_fee,
-            &stake_pool_accounts.withdrawal_fee,
-            &stake_pool_accounts.deposit_fee,
-            stake_pool_accounts.referral_fee,
-            &stake_pool_accounts.sol_deposit_fee,
-            stake_pool_accounts.sol_referral_fee,
-            stake_pool_accounts.max_validators,
-        )
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(error::StakePoolError::WrongStakeStake as u32),
-            )
-        );
-    }
-
-    {
-        let bad_stake = Keypair::new();
-        create_independent_stake_account(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &bad_stake,
-            &stake::state::Authorized {
-                staker: stake_pool_accounts.withdraw_authority,
-                withdrawer: stake_pool_accounts.withdraw_authority,
-            },
-            &stake::state::Lockup {
-                custodian: wrong_authority,
-                ..stake::state::Lockup::default()
-            },
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await;
-
-        let error = create_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &bad_stake.pubkey(),
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.manager,
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &None,
-            &stake_pool_accounts.epoch_fee,
-            &stake_pool_accounts.withdrawal_fee,
-            &stake_pool_accounts.deposit_fee,
-            stake_pool_accounts.referral_fee,
-            &stake_pool_accounts.sol_deposit_fee,
-            stake_pool_accounts.sol_referral_fee,
-            stake_pool_accounts.max_validators,
-        )
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(error::StakePoolError::WrongStakeStake as u32),
-            )
-        );
-    }
-
-    {
-        let bad_stake = Keypair::new();
-        let rent = banks_client.get_rent().await.unwrap();
-        let lamports = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>())
-            + MINIMUM_RESERVE_LAMPORTS;
-
-        let transaction = Transaction::new_signed_with_payer(
-            &[system_instruction::create_account(
-                &payer.pubkey(),
-                &bad_stake.pubkey(),
-                lamports,
-                std::mem::size_of::<stake::state::StakeStateV2>() as u64,
-                &stake::program::id(),
-            )],
-            Some(&payer.pubkey()),
-            &[&payer, &bad_stake],
-            recent_blockhash,
-        );
-        banks_client.process_transaction(transaction).await.unwrap();
-
-        let error = create_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &stake_pool_accounts.stake_pool,
-            &stake_pool_accounts.validator_list,
-            &bad_stake.pubkey(),
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.manager,
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &None,
-            &stake_pool_accounts.epoch_fee,
-            &stake_pool_accounts.withdrawal_fee,
-            &stake_pool_accounts.deposit_fee,
-            stake_pool_accounts.referral_fee,
-            &stake_pool_accounts.sol_deposit_fee,
-            stake_pool_accounts.sol_referral_fee,
-            stake_pool_accounts.max_validators,
-        )
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(error::StakePoolError::WrongStakeStake as u32),
-            )
-        );
-    }
-}
-
-#[tokio::test]
-async fn success_with_extra_reserve_lamports() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    let init_lamports = 1_000_000_000_000;
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS + init_lamports,
-        )
-        .await
-        .unwrap();
-
-    let init_pool_tokens = get_token_balance(
-        &mut banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-    assert_eq!(init_pool_tokens, init_lamports);
-}
-
-#[tokio::test]
-async fn fail_with_incorrect_mint_decimals() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts {
-        pool_decimals: 8,
-        ..Default::default()
-    };
-    let error = stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap_err()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            2,
-            InstructionError::Custom(error::StakePoolError::IncorrectMintDecimals as u32),
-        )
-    );
-}
diff --git a/stake-pool/program/tests/redelegate.rs b/stake-pool/program/tests/redelegate.rs
deleted file mode 100644
index 3256eef1155..00000000000
--- a/stake-pool/program/tests/redelegate.rs
+++ /dev/null
@@ -1,1213 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{
-        clock::Epoch, hash::Hash, instruction::InstructionError, pubkey::Pubkey, stake,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        stake::instruction::StakeError,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_ephemeral_stake_program_address,
-        find_transient_stake_program_address, id, instruction, MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup(
-    do_warp: bool,
-) -> (
-    ProgramTestContext,
-    Hash,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-    ValidatorStakeAccount,
-    u64,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS + current_minimum_delegation + stake_rent * 2,
-        )
-        .await
-        .unwrap();
-
-    let source_validator_stake = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let destination_validator_stake = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let minimum_redelegate_lamports = current_minimum_delegation + stake_rent;
-    simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &source_validator_stake,
-        minimum_redelegate_lamports,
-    )
-    .await
-    .unwrap();
-
-    let mut slot = 1;
-    if do_warp {
-        slot += context.genesis_config().epoch_schedule.first_normal_slot;
-        context.warp_to_slot(slot).unwrap();
-        stake_pool_accounts
-            .update_all(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-                false,
-            )
-            .await;
-    }
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    (
-        context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        minimum_redelegate_lamports,
-        slot,
-    )
-}
-
-#[tokio::test]
-async fn success() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        mut slot,
-    ) = setup(true).await;
-
-    // Save validator stake
-    let pre_validator_stake_account = get_account(
-        &mut context.banks_client,
-        &source_validator_stake.stake_account,
-    )
-    .await;
-
-    // Save validator stake
-    let pre_destination_validator_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.stake_account,
-    )
-    .await;
-
-    // Check no transient stake
-    let transient_account = context
-        .banks_client
-        .get_account(source_validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(transient_account.is_none());
-
-    let ephemeral_stake_seed = 100;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check validator stake account balance
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &source_validator_stake.stake_account,
-    )
-    .await;
-    let validator_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&validator_stake_account.data).unwrap();
-    assert_eq!(
-        pre_validator_stake_account.lamports - redelegate_lamports,
-        validator_stake_account.lamports
-    );
-    assert_eq!(
-        validator_stake_state
-            .delegation()
-            .unwrap()
-            .deactivation_epoch,
-        Epoch::MAX
-    );
-
-    // Check source transient stake account state and balance
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let source_transient_stake_account = get_account(
-        &mut context.banks_client,
-        &source_validator_stake.transient_stake_account,
-    )
-    .await;
-    let transient_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&source_transient_stake_account.data).unwrap();
-    assert_eq!(source_transient_stake_account.lamports, stake_rent);
-    let transient_delegation = transient_stake_state.delegation().unwrap();
-    assert_ne!(transient_delegation.deactivation_epoch, Epoch::MAX);
-    assert_eq!(transient_delegation.stake, redelegate_lamports);
-
-    // Check reserve stake
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-    )
-    .await;
-    let reserve_lamports = MINIMUM_RESERVE_LAMPORTS + current_minimum_delegation + stake_rent * 2;
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(reserve_stake_account.lamports, reserve_lamports);
-
-    // Check ephemeral account doesn't exist
-    let maybe_account = context
-        .banks_client
-        .get_account(ephemeral_stake)
-        .await
-        .unwrap();
-    assert!(maybe_account.is_none());
-
-    // Check destination transient stake account
-    let destination_transient_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.transient_stake_account,
-    )
-    .await;
-    let transient_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&destination_transient_stake_account.data)
-            .unwrap();
-    assert_eq!(
-        destination_transient_stake_account.lamports,
-        redelegate_lamports
-    );
-    let transient_delegation = transient_stake_state.delegation().unwrap();
-    assert_eq!(transient_delegation.deactivation_epoch, Epoch::MAX);
-    assert_ne!(transient_delegation.activation_epoch, Epoch::MAX);
-    assert_eq!(transient_delegation.stake, redelegate_lamports - stake_rent);
-
-    // Check validator list
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let source_item = validator_list
-        .find(&source_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        u64::from(source_item.active_stake_lamports),
-        validator_stake_account.lamports
-    );
-    assert_eq!(
-        u64::from(source_item.transient_stake_lamports),
-        source_transient_stake_account.lamports
-    );
-    assert_eq!(
-        u64::from(source_item.transient_seed_suffix),
-        source_validator_stake.transient_stake_seed
-    );
-
-    let destination_item = validator_list
-        .find(&destination_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        u64::from(destination_item.transient_stake_lamports),
-        destination_transient_stake_account.lamports
-    );
-    assert_eq!(
-        u64::from(destination_item.transient_seed_suffix),
-        destination_validator_stake.transient_stake_seed
-    );
-
-    // Warp forward and merge all
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    // Check transient accounts are gone
-    let maybe_account = context
-        .banks_client
-        .get_account(destination_validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(maybe_account.is_none());
-    let maybe_account = context
-        .banks_client
-        .get_account(source_validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(maybe_account.is_none());
-
-    // Check validator list
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let source_item = validator_list
-        .find(&source_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        u64::from(source_item.active_stake_lamports),
-        validator_stake_account.lamports
-    );
-    assert_eq!(u64::from(source_item.transient_stake_lamports), 0);
-
-    let destination_item = validator_list
-        .find(&destination_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(u64::from(destination_item.transient_stake_lamports), 0);
-    assert_eq!(
-        u64::from(destination_item.active_stake_lamports),
-        pre_destination_validator_stake_account.lamports + redelegate_lamports - stake_rent
-    );
-    let post_destination_validator_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.stake_account,
-    )
-    .await;
-    assert_eq!(
-        post_destination_validator_stake_account.lamports,
-        pre_destination_validator_stake_account.lamports + redelegate_lamports - stake_rent
-    );
-
-    // Check reserve stake, which has claimed back all rent-exempt reserves
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(
-        reserve_stake_account.lamports,
-        reserve_lamports + stake_rent * 2
-    );
-}
-
-#[tokio::test]
-async fn success_with_increasing_stake() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        mut slot,
-    ) = setup(true).await;
-
-    // Save validator stake
-    let pre_validator_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.stake_account,
-    )
-    .await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-    )
-    .await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            current_minimum_delegation,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let destination_item = validator_list
-        .find(&destination_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        u64::from(destination_item.transient_stake_lamports),
-        current_minimum_delegation + stake_rent
-    );
-    let pre_transient_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.transient_stake_account,
-    )
-    .await;
-    assert_eq!(
-        pre_transient_stake_account.lamports,
-        current_minimum_delegation + stake_rent
-    );
-
-    let ephemeral_stake_seed = 10;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    // fail with incorrect transient stake derivation
-    let wrong_transient_stake_seed = destination_validator_stake
-        .transient_stake_seed
-        .wrapping_add(1);
-    let (wrong_transient_stake_account, _) = find_transient_stake_program_address(
-        &id(),
-        &destination_validator_stake.vote.pubkey(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        wrong_transient_stake_seed,
-    );
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &wrong_transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            wrong_transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidStakeAccountAddress as u32)
-        )
-    );
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check destination transient stake account
-    let destination_transient_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.transient_stake_account,
-    )
-    .await;
-    let transient_stake_state =
-        deserialize::<stake::state::StakeStateV2>(&destination_transient_stake_account.data)
-            .unwrap();
-    assert_eq!(
-        destination_transient_stake_account.lamports,
-        redelegate_lamports + current_minimum_delegation + stake_rent
-    );
-
-    let transient_delegation = transient_stake_state.delegation().unwrap();
-    assert_eq!(transient_delegation.deactivation_epoch, Epoch::MAX);
-    assert_ne!(transient_delegation.activation_epoch, Epoch::MAX);
-    assert_eq!(
-        transient_delegation.stake,
-        redelegate_lamports + current_minimum_delegation
-    );
-
-    // Check reserve stake
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(reserve_stake_account.lamports, stake_rent);
-
-    // Check validator list
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let destination_item = validator_list
-        .find(&destination_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        u64::from(destination_item.transient_stake_lamports),
-        destination_transient_stake_account.lamports
-    );
-    assert_eq!(
-        u64::from(destination_item.transient_seed_suffix),
-        destination_validator_stake.transient_stake_seed
-    );
-
-    // Warp forward and merge all
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    // Check transient account is gone
-    let maybe_account = context
-        .banks_client
-        .get_account(destination_validator_stake.transient_stake_account)
-        .await
-        .unwrap();
-    assert!(maybe_account.is_none());
-
-    // Check validator list
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let destination_item = validator_list
-        .find(&destination_validator_stake.vote.pubkey())
-        .unwrap();
-    assert_eq!(u64::from(destination_item.transient_stake_lamports), 0);
-    // redelegate is smart enough to activate *everything*, so there's no
-    // rent-exemption worth of inactive stake!
-    assert_eq!(
-        u64::from(destination_item.active_stake_lamports),
-        pre_validator_stake_account.lamports + redelegate_lamports + current_minimum_delegation
-    );
-    let post_validator_stake_account = get_account(
-        &mut context.banks_client,
-        &destination_validator_stake.stake_account,
-    )
-    .await;
-    assert_eq!(
-        post_validator_stake_account.lamports,
-        pre_validator_stake_account.lamports + redelegate_lamports + current_minimum_delegation
-    );
-
-    // Check reserve has claimed back rent-exempt reserve from both transient
-    // accounts
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(reserve_stake_account.lamports, stake_rent * 3);
-}
-
-#[tokio::test]
-async fn fail_with_decreasing_stake() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        mut slot,
-    ) = setup(false).await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-    )
-    .await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let minimum_decrease_lamports = current_minimum_delegation + stake_rent;
-
-    simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        &destination_validator_stake,
-        redelegate_lamports,
-    )
-    .await
-    .unwrap();
-
-    slot += context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.transient_stake_account,
-            minimum_decrease_lamports,
-            destination_validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let ephemeral_stake_seed = 20;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::WrongStakeStake as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let ephemeral_stake_seed = 2;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let wrong_withdraw_authority = Pubkey::new_unique();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::redelegate(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &wrong_withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidProgramAddress as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let ephemeral_stake_seed = 2;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let wrong_validator_list = Pubkey::new_unique();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::redelegate(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &wrong_validator_list,
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidValidatorStakeList as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_reserve() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let ephemeral_stake_seed = 2;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let wrong_reserve = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::redelegate(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &wrong_reserve.pubkey(),
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.staker],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidProgramAddress as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_staker() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let ephemeral_stake_seed = 2;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let wrong_staker = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::redelegate(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_staker],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::WrongStaker as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_unknown_validator() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let unknown_validator_stake = create_unknown_validator_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        redelegate_lamports,
-    )
-    .await;
-
-    let ephemeral_stake_seed = 42;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &unknown_validator_stake.transient_stake_account,
-            &unknown_validator_stake.stake_account,
-            &unknown_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            unknown_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &unknown_validator_stake.stake_account,
-            &unknown_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            unknown_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_redelegate_twice() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        mut slot,
-    ) = setup(false).await;
-
-    simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        &source_validator_stake,
-        redelegate_lamports,
-    )
-    .await
-    .unwrap();
-
-    slot += context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let ephemeral_stake_seed = 100;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::TransientAccountInUse as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_with_small_lamport_amount() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        redelegate_lamports,
-        _,
-    ) = setup(true).await;
-
-    let ephemeral_stake_seed = 7_000;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            redelegate_lamports - 1,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakeError::InsufficientDelegation as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_drain_source_account() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        source_validator_stake,
-        destination_validator_stake,
-        _,
-        _,
-    ) = setup(true).await;
-
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &source_validator_stake.stake_account,
-    )
-    .await;
-
-    let ephemeral_stake_seed = 2;
-    let ephemeral_stake = find_ephemeral_stake_program_address(
-        &id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        ephemeral_stake_seed,
-    )
-    .0;
-
-    let error = stake_pool_accounts
-        .redelegate(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &source_validator_stake.stake_account,
-            &source_validator_stake.transient_stake_account,
-            &ephemeral_stake,
-            &destination_validator_stake.transient_stake_account,
-            &destination_validator_stake.stake_account,
-            &destination_validator_stake.vote.pubkey(),
-            validator_stake_account.lamports,
-            source_validator_stake.transient_stake_seed,
-            ephemeral_stake_seed,
-            destination_validator_stake.transient_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::InsufficientFunds)
-    );
-}
diff --git a/stake-pool/program/tests/set_deposit_fee.rs b/stake-pool/program/tests/set_deposit_fee.rs
deleted file mode 100644
index ba62838421b..00000000000
--- a/stake-pool/program/tests/set_deposit_fee.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error, id, instruction,
-        state::{Fee, FeeType, StakePool},
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup(fee: Option<Fee>) -> (ProgramTestContext, StakePoolAccounts, Fee) {
-    let mut context = program_test().start_with_context().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    if let Some(fee) = fee {
-        stake_pool_accounts.deposit_fee = fee;
-    }
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_deposit_fee = Fee {
-        numerator: 823,
-        denominator: 1000,
-    };
-
-    (context, stake_pool_accounts, new_deposit_fee)
-}
-
-#[tokio::test]
-async fn success_stake() {
-    let (mut context, stake_pool_accounts, new_deposit_fee) = setup(None).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_deposit_fee, new_deposit_fee);
-}
-
-#[tokio::test]
-async fn success_stake_increase_fee_from_0() {
-    let (mut context, stake_pool_accounts, _) = setup(Some(Fee {
-        numerator: 0,
-        denominator: 0,
-    }))
-    .await;
-    let new_deposit_fee = Fee {
-        numerator: 324,
-        denominator: 1234,
-    };
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_deposit_fee, new_deposit_fee);
-}
-
-#[tokio::test]
-async fn fail_stake_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_deposit_fee) = setup(None).await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::StakeDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_stake_high_deposit_fee() {
-    let (mut context, stake_pool_accounts, _new_deposit_fee) = setup(None).await;
-
-    let new_deposit_fee = Fee {
-        numerator: 100001,
-        denominator: 100000,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
-
-#[tokio::test]
-async fn success_sol() {
-    let (mut context, stake_pool_accounts, new_deposit_fee) = setup(None).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.sol_deposit_fee, new_deposit_fee);
-}
-
-#[tokio::test]
-async fn fail_sol_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_deposit_fee) = setup(None).await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::SolDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_sol_high_deposit_fee() {
-    let (mut context, stake_pool_accounts, _new_deposit_fee) = setup(None).await;
-
-    let new_deposit_fee = Fee {
-        numerator: 100001,
-        denominator: 100000,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolDeposit(new_deposit_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
diff --git a/stake-pool/program/tests/set_epoch_fee.rs b/stake-pool/program/tests/set_epoch_fee.rs
deleted file mode 100644
index c510a81314c..00000000000
--- a/stake-pool/program/tests/set_epoch_fee.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error, id, instruction,
-        state::{Fee, FeeType, FutureEpoch, StakePool},
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup() -> (ProgramTestContext, StakePoolAccounts, Fee) {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_fee = Fee {
-        numerator: 10,
-        denominator: 10,
-    };
-
-    (context, stake_pool_accounts, new_fee)
-}
-
-#[tokio::test]
-async fn success() {
-    let (mut context, stake_pool_accounts, new_fee) = setup().await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    let old_fee = stake_pool.epoch_fee;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::Epoch(new_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.epoch_fee, old_fee);
-    assert_eq!(stake_pool.next_epoch_fee, FutureEpoch::Two(new_fee));
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let slot = first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.epoch_fee, old_fee);
-    assert_eq!(stake_pool.next_epoch_fee, FutureEpoch::One(new_fee));
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    context.warp_to_slot(slot + slots_per_epoch).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.epoch_fee, new_fee);
-    assert_eq!(stake_pool.next_epoch_fee, FutureEpoch::None);
-}
-
-#[tokio::test]
-async fn fail_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_fee) = setup().await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::Epoch(new_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_fee() {
-    let (mut context, stake_pool_accounts, _new_fee) = setup().await;
-
-    let new_fee = Fee {
-        numerator: 11,
-        denominator: 10,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::Epoch(new_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
-
-#[tokio::test]
-async fn fail_not_updated() {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_fee = Fee {
-        numerator: 10,
-        denominator: 100,
-    };
-
-    // move forward so an update is required
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::Epoch(new_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::StakeListAndPoolOutOfDate as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when stake pool out of date"),
-    }
-}
diff --git a/stake-pool/program/tests/set_funding_authority.rs b/stake-pool/program/tests/set_funding_authority.rs
deleted file mode 100644
index ee2722d81d6..00000000000
--- a/stake-pool/program/tests/set_funding_authority.rs
+++ /dev/null
@@ -1,266 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        hash::Hash,
-        instruction::{AccountMeta, Instruction},
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{
-        error, find_deposit_authority_program_address, id,
-        instruction::{self, FundingType},
-        state, MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup() -> (BanksClient, Keypair, Hash, StakePoolAccounts, Keypair) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let new_deposit_authority = Keypair::new();
-
-    (
-        banks_client,
-        payer,
-        recent_blockhash,
-        stake_pool_accounts,
-        new_deposit_authority,
-    )
-}
-
-#[tokio::test]
-async fn success_set_stake_deposit_authority() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_authority) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&new_authority.pubkey()),
-            FundingType::StakeDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_deposit_authority, new_authority.pubkey());
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            None,
-            FundingType::StakeDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.stake_deposit_authority,
-        find_deposit_authority_program_address(&id(), &stake_pool_accounts.stake_pool.pubkey()).0
-    );
-}
-
-#[tokio::test]
-async fn fail_wrong_manager() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_authority) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &new_authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            FundingType::StakeDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &new_authority], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_without_signature() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_authority) =
-        setup().await;
-
-    let data = borsh::to_vec(&instruction::StakePoolInstruction::SetFundingAuthority(
-        FundingType::StakeDeposit,
-    ))
-    .unwrap();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.manager.pubkey(), false),
-        AccountMeta::new_readonly(new_authority.pubkey(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data,
-    };
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to set new manager without signature"),
-    }
-}
-
-#[tokio::test]
-async fn success_set_sol_deposit_authority() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_sol_deposit_authority) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&new_sol_deposit_authority.pubkey()),
-            FundingType::SolDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.sol_deposit_authority,
-        Some(new_sol_deposit_authority.pubkey())
-    );
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            None,
-            FundingType::SolDeposit,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.sol_deposit_authority, None);
-}
-
-#[tokio::test]
-async fn success_set_withdraw_authority() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_authority) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&new_authority.pubkey()),
-            FundingType::SolWithdraw,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.sol_withdraw_authority,
-        Some(new_authority.pubkey())
-    );
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            None,
-            FundingType::SolWithdraw,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.sol_withdraw_authority, None);
-}
diff --git a/stake-pool/program/tests/set_manager.rs b/stake-pool/program/tests/set_manager.rs
deleted file mode 100644
index 3172d3bf3ee..00000000000
--- a/stake-pool/program/tests/set_manager.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        hash::Hash,
-        instruction::{AccountMeta, Instruction},
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{error, id, instruction, state, MINIMUM_RESERVE_LAMPORTS},
-};
-
-async fn setup() -> (
-    BanksClient,
-    Keypair,
-    Hash,
-    StakePoolAccounts,
-    Keypair,
-    Keypair,
-) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let new_pool_fee = Keypair::new();
-    let new_manager = Keypair::new();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &new_pool_fee,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &new_manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    (
-        banks_client,
-        payer,
-        recent_blockhash,
-        stake_pool_accounts,
-        new_pool_fee,
-        new_manager,
-    )
-}
-
-#[tokio::test]
-async fn test_set_manager() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_pool_fee, new_manager) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_manager(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            &new_manager.pubkey(),
-            &new_pool_fee.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[&payer, &stake_pool_accounts.manager, &new_manager],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.manager, new_manager.pubkey());
-}
-
-#[tokio::test]
-async fn test_set_manager_by_malicious() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_pool_fee, new_manager) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_manager(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &new_manager.pubkey(),
-            &new_manager.pubkey(),
-            &new_pool_fee.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &new_manager], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn test_set_manager_without_existing_signature() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_pool_fee, new_manager) =
-        setup().await;
-
-    let data = borsh::to_vec(&instruction::StakePoolInstruction::SetManager).unwrap();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.manager.pubkey(), false),
-        AccountMeta::new_readonly(new_manager.pubkey(), true),
-        AccountMeta::new_readonly(new_pool_fee.pubkey(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data,
-    };
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer, &new_manager], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to set new manager without existing manager signature"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn test_set_manager_without_new_signature() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_pool_fee, new_manager) =
-        setup().await;
-
-    let data = borsh::to_vec(&instruction::StakePoolInstruction::SetManager).unwrap();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.manager.pubkey(), true),
-        AccountMeta::new_readonly(new_manager.pubkey(), false),
-        AccountMeta::new_readonly(new_pool_fee.pubkey(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data,
-    };
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => {
-            panic!("Wrong error occurs while try to set new manager without new manager signature")
-        }
-    }
-}
-
-#[tokio::test]
-async fn test_set_manager_with_wrong_mint_for_pool_fee_acc() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let new_mint = Keypair::new();
-    let new_withdraw_auth = Keypair::new();
-    let new_pool_fee = Keypair::new();
-    let new_manager = Keypair::new();
-
-    create_mint(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &new_mint,
-        &new_withdraw_auth.pubkey(),
-        0,
-        &[],
-    )
-    .await
-    .unwrap();
-    create_token_account(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &new_pool_fee,
-        &new_mint.pubkey(),
-        &new_manager,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_manager(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            &new_manager.pubkey(),
-            &new_pool_fee.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(
-        &[&payer, &stake_pool_accounts.manager, &new_manager],
-        recent_blockhash,
-    );
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::InvalidFeeAccount as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to set new manager with wrong mint"),
-    }
-}
diff --git a/stake-pool/program/tests/set_preferred.rs b/stake-pool/program/tests/set_preferred.rs
deleted file mode 100644
index 1a1e3c0f1cb..00000000000
--- a/stake-pool/program/tests/set_preferred.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::hash::Hash,
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error, find_transient_stake_program_address, id,
-        instruction::{self, PreferredValidatorType},
-        state::StakePool,
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup() -> (
-    BanksClient,
-    Keypair,
-    Hash,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake_account = simple_add_validator_to_pool(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    (
-        banks_client,
-        payer,
-        recent_blockhash,
-        stake_pool_accounts,
-        validator_stake_account,
-    )
-}
-
-#[tokio::test]
-async fn success_deposit() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake_account) =
-        setup().await;
-
-    let vote_account_address = validator_stake_account.vote.pubkey();
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Deposit,
-            Some(vote_account_address),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.preferred_deposit_validator_vote_address,
-        Some(vote_account_address)
-    );
-    assert_eq!(stake_pool.preferred_withdraw_validator_vote_address, None);
-}
-
-#[tokio::test]
-async fn success_withdraw() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake_account) =
-        setup().await;
-
-    let vote_account_address = validator_stake_account.vote.pubkey();
-
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Withdraw,
-            Some(vote_account_address),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.preferred_deposit_validator_vote_address, None);
-    assert_eq!(
-        stake_pool.preferred_withdraw_validator_vote_address,
-        Some(vote_account_address)
-    );
-}
-
-#[tokio::test]
-async fn success_unset() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake_account) =
-        setup().await;
-
-    let vote_account_address = validator_stake_account.vote.pubkey();
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Withdraw,
-            Some(vote_account_address),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(
-        stake_pool.preferred_withdraw_validator_vote_address,
-        Some(vote_account_address)
-    );
-
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Withdraw,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.preferred_withdraw_validator_vote_address, None);
-}
-
-#[tokio::test]
-async fn fail_wrong_staker() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, _) = setup().await;
-
-    let wrong_staker = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_preferred_validator(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_staker.pubkey(),
-            &stake_pool_accounts.validator_list.pubkey(),
-            PreferredValidatorType::Withdraw,
-            None,
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &wrong_staker],
-        recent_blockhash,
-    );
-    let error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongStaker as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_not_present_validator() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, _) = setup().await;
-
-    let validator_vote_address = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Withdraw,
-            Some(validator_vote_address),
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::ValidatorNotFound as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_ready_for_removal() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake_account) =
-        setup().await;
-    let validator_vote_address = validator_stake_account.vote.pubkey();
-
-    // Mark validator as ready for removal
-    let transient_stake_seed = 0;
-    let (transient_stake_address, _) = find_transient_stake_program_address(
-        &id(),
-        &validator_vote_address,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        transient_stake_seed,
-    );
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake_account.stake_account,
-            &transient_stake_address,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .set_preferred_validator(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            PreferredValidatorType::Withdraw,
-            Some(validator_vote_address),
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::InvalidPreferredValidator as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while trying to set ReadyForRemoval validator"),
-    }
-}
diff --git a/stake-pool/program/tests/set_referral_fee.rs b/stake-pool/program/tests/set_referral_fee.rs
deleted file mode 100644
index 7221e978d3f..00000000000
--- a/stake-pool/program/tests/set_referral_fee.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error, id, instruction,
-        state::{FeeType, StakePool},
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup(fee: Option<u8>) -> (ProgramTestContext, StakePoolAccounts, u8) {
-    let mut context = program_test().start_with_context().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    if let Some(fee) = fee {
-        stake_pool_accounts.referral_fee = fee;
-    }
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_referral_fee = 15u8;
-
-    (context, stake_pool_accounts, new_referral_fee)
-}
-
-#[tokio::test]
-async fn success_stake() {
-    let (mut context, stake_pool_accounts, new_referral_fee) = setup(None).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_referral_fee, new_referral_fee);
-}
-
-#[tokio::test]
-async fn success_stake_increase_fee_from_0() {
-    let (mut context, stake_pool_accounts, _) = setup(Some(0u8)).await;
-    let new_referral_fee = 30u8;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_referral_fee, new_referral_fee);
-}
-
-#[tokio::test]
-async fn fail_stake_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_referral_fee) = setup(None).await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::StakeReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_stake_high_referral_fee() {
-    let (mut context, stake_pool_accounts, _new_referral_fee) = setup(None).await;
-
-    let new_referral_fee = 110u8;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
-
-#[tokio::test]
-async fn success_sol() {
-    let (mut context, stake_pool_accounts, new_referral_fee) = setup(None).await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.sol_referral_fee, new_referral_fee);
-}
-
-#[tokio::test]
-async fn fail_sol_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_referral_fee) = setup(None).await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::SolReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_sol_high_referral_fee() {
-    let (mut context, stake_pool_accounts, _new_referral_fee) = setup(None).await;
-
-    let new_referral_fee = 110u8;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolReferral(new_referral_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
diff --git a/stake-pool/program/tests/set_staker.rs b/stake-pool/program/tests/set_staker.rs
deleted file mode 100644
index bef7c8837d1..00000000000
--- a/stake-pool/program/tests/set_staker.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        hash::Hash,
-        instruction::{AccountMeta, Instruction},
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{error, id, instruction, state, MINIMUM_RESERVE_LAMPORTS},
-};
-
-async fn setup() -> (BanksClient, Keypair, Hash, StakePoolAccounts, Keypair) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let new_staker = Keypair::new();
-
-    (
-        banks_client,
-        payer,
-        recent_blockhash,
-        stake_pool_accounts,
-        new_staker,
-    )
-}
-
-#[tokio::test]
-async fn success_set_staker_as_manager() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_staker) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_staker(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            &new_staker.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.manager], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.staker, new_staker.pubkey());
-}
-
-#[tokio::test]
-async fn success_set_staker_as_staker() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_staker) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_staker(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &new_staker.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.staker], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.staker, new_staker.pubkey());
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_staker(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &new_staker.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &new_staker], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let stake_pool = get_account(&mut banks_client, &stake_pool_accounts.stake_pool.pubkey()).await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.staker, stake_pool_accounts.staker.pubkey());
-}
-
-#[tokio::test]
-async fn fail_wrong_manager() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_staker) =
-        setup().await;
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::set_staker(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &new_staker.pubkey(),
-            &new_staker.pubkey(),
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &new_staker], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to set manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_set_staker_without_signature() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, new_staker) =
-        setup().await;
-
-    let data = borsh::to_vec(&instruction::StakePoolInstruction::SetStaker).unwrap();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.manager.pubkey(), false),
-        AccountMeta::new_readonly(new_staker.pubkey(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data,
-    };
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = error::StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to set new manager without signature"),
-    }
-}
diff --git a/stake-pool/program/tests/set_withdrawal_fee.rs b/stake-pool/program/tests/set_withdrawal_fee.rs
deleted file mode 100644
index b36ac69352c..00000000000
--- a/stake-pool/program/tests/set_withdrawal_fee.rs
+++ /dev/null
@@ -1,913 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program_test::*,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked,
-        instruction::InstructionError,
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error, id, instruction,
-        state::{Fee, FeeType, FutureEpoch, StakePool},
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup(fee: Option<Fee>) -> (ProgramTestContext, StakePoolAccounts, Fee) {
-    let mut context = program_test().start_with_context().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    if let Some(fee) = fee {
-        stake_pool_accounts.withdrawal_fee = fee;
-    }
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_withdrawal_fee = Fee {
-        numerator: 4,
-        denominator: 1000,
-    };
-
-    (context, stake_pool_accounts, new_withdrawal_fee)
-}
-
-#[tokio::test]
-async fn success() {
-    let (mut context, stake_pool_accounts, new_withdrawal_fee) = setup(None).await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    let old_stake_withdrawal_fee = stake_pool.stake_withdrawal_fee;
-    let old_sol_withdrawal_fee = stake_pool.sol_withdrawal_fee;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let slot = first_normal_slot + 1;
-
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    context.warp_to_slot(slot + slots_per_epoch).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_stake_withdrawal_fee, FutureEpoch::None);
-    assert_eq!(stake_pool.sol_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_sol_withdrawal_fee, FutureEpoch::None);
-}
-
-#[tokio::test]
-async fn success_fee_cannot_increase_more_than_once() {
-    let (mut context, stake_pool_accounts, new_withdrawal_fee) = setup(None).await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    let old_stake_withdrawal_fee = stake_pool.stake_withdrawal_fee;
-    let old_sol_withdrawal_fee = stake_pool.sol_withdrawal_fee;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let slot = first_normal_slot + 1;
-
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    context.warp_to_slot(slot + slots_per_epoch).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_stake_withdrawal_fee, FutureEpoch::None);
-    assert_eq!(stake_pool.sol_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_sol_withdrawal_fee, FutureEpoch::None);
-
-    // try setting to the old fee in the same epoch
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(old_stake_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(old_sol_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(old_stake_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(old_sol_withdrawal_fee)
-    );
-
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check that nothing has changed after updating the stake pool
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(old_stake_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(old_sol_withdrawal_fee)
-    );
-}
-
-#[tokio::test]
-async fn success_reset_fee_after_one_epoch() {
-    let (mut context, stake_pool_accounts, new_withdrawal_fee) = setup(None).await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    let old_stake_withdrawal_fee = stake_pool.stake_withdrawal_fee;
-    let old_sol_withdrawal_fee = stake_pool.sol_withdrawal_fee;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-
-    // Flip the two fees, resets the counter to two future epochs
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(old_sol_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(old_stake_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(old_sol_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(old_stake_withdrawal_fee)
-    );
-}
-
-#[tokio::test]
-async fn success_increase_fee_from_0() {
-    let (mut context, stake_pool_accounts, _) = setup(Some(Fee {
-        numerator: 0,
-        denominator: 1,
-    }))
-    .await;
-    let new_withdrawal_fee = Fee {
-        numerator: 15,
-        denominator: 10000,
-    };
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    let old_stake_withdrawal_fee = stake_pool.stake_withdrawal_fee;
-    let old_sol_withdrawal_fee = stake_pool.sol_withdrawal_fee;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::Two(new_withdrawal_fee)
-    );
-
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let slot = first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, old_stake_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_stake_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-    assert_eq!(stake_pool.sol_withdrawal_fee, old_sol_withdrawal_fee);
-    assert_eq!(
-        stake_pool.next_sol_withdrawal_fee,
-        FutureEpoch::One(new_withdrawal_fee)
-    );
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-    context.warp_to_slot(slot + slots_per_epoch).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(stake_pool.stake_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_stake_withdrawal_fee, FutureEpoch::None);
-    assert_eq!(stake_pool.sol_withdrawal_fee, new_withdrawal_fee);
-    assert_eq!(stake_pool.next_sol_withdrawal_fee, FutureEpoch::None);
-}
-
-#[tokio::test]
-async fn fail_wrong_manager() {
-    let (mut context, stake_pool_accounts, new_stake_withdrawal_fee) = setup(None).await;
-
-    let wrong_manager = Keypair::new();
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &wrong_manager.pubkey(),
-            FeeType::StakeWithdrawal(new_stake_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &wrong_manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_withdrawal_fee() {
-    let (mut context, stake_pool_accounts, _new_stake_withdrawal_fee) = setup(None).await;
-
-    let new_stake_withdrawal_fee = Fee {
-        numerator: 11,
-        denominator: 10,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_stake_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when setting fee too high"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_stake_fee_increase() {
-    let (mut context, stake_pool_accounts, _new_stake_withdrawal_fee) = setup(None).await;
-    let new_withdrawal_fee = Fee {
-        numerator: 46,
-        denominator: 10_000,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeIncreaseTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when increasing fee by too large a factor"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_sol_fee_increase() {
-    let (mut context, stake_pool_accounts, _new_stake_withdrawal_fee) = setup(None).await;
-    let new_withdrawal_fee = Fee {
-        numerator: 46,
-        denominator: 10_000,
-    };
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeIncreaseTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when increasing fee by too large a factor"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_stake_fee_increase_from_0() {
-    let (mut context, stake_pool_accounts, _new_stake_withdrawal_fee) = setup(Some(Fee {
-        numerator: 0,
-        denominator: 1,
-    }))
-    .await;
-    let new_withdrawal_fee = Fee {
-        numerator: 16,
-        denominator: 10_000,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeIncreaseTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when increasing fee by too large a factor"),
-    }
-}
-
-#[tokio::test]
-async fn fail_high_sol_fee_increase_from_0() {
-    let (mut context, stake_pool_accounts, _new_stake_withdrawal_fee) = setup(Some(Fee {
-        numerator: 0,
-        denominator: 1,
-    }))
-    .await;
-    let new_withdrawal_fee = Fee {
-        numerator: 16,
-        denominator: 10_000,
-    };
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::SolWithdrawal(new_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::FeeIncreaseTooHigh as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when increasing fee by too large a factor"),
-    }
-}
-
-#[tokio::test]
-async fn fail_not_updated() {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-    let new_stake_withdrawal_fee = Fee {
-        numerator: 11,
-        denominator: 100,
-    };
-
-    // move forward so an update is required
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slot = first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_fee(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            FeeType::StakeWithdrawal(new_stake_withdrawal_fee),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = error::StakePoolError::StakeListAndPoolOutOfDate as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs when stake pool out of date"),
-    }
-}
diff --git a/stake-pool/program/tests/update_pool_token_metadata.rs b/stake-pool/program/tests/update_pool_token_metadata.rs
deleted file mode 100644
index efe30a963dd..00000000000
--- a/stake-pool/program/tests/update_pool_token_metadata.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::instruction::InstructionError,
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError::{SignatureMissing, WrongManager},
-        instruction, MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup() -> (ProgramTestContext, StakePoolAccounts) {
-    let mut context = program_test_with_metadata_program()
-        .start_with_context()
-        .await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let name = "test_name";
-    let symbol = "SYM";
-    let uri = "test_uri";
-
-    let ix = instruction::create_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &context.payer.pubkey(),
-        name.to_string(),
-        symbol.to_string(),
-        uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    (context, stake_pool_accounts)
-}
-
-#[tokio::test]
-async fn success_update_pool_token_metadata() {
-    let (mut context, stake_pool_accounts) = setup().await;
-
-    let updated_name = "updated_name";
-    let updated_symbol = "USYM";
-    let updated_uri = "updated_uri";
-
-    let ix = instruction::update_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        updated_name.to_string(),
-        updated_symbol.to_string(),
-        updated_uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let metadata = get_metadata_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-
-    assert!(metadata.name.starts_with(updated_name));
-    assert!(metadata.symbol.starts_with(updated_symbol));
-    assert!(metadata.uri.starts_with(updated_uri));
-}
-
-#[tokio::test]
-async fn fail_manager_did_not_sign() {
-    let (mut context, stake_pool_accounts) = setup().await;
-
-    let updated_name = "updated_name";
-    let updated_symbol = "USYM";
-    let updated_uri = "updated_uri";
-
-    let mut ix = instruction::update_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &stake_pool_accounts.manager.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        updated_name.to_string(),
-        updated_symbol.to_string(),
-        updated_uri.to_string(),
-    );
-    ix.accounts[1].is_signer = false;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while manager signature missing"),
-    }
-}
-
-#[tokio::test]
-async fn fail_wrong_manager_signed() {
-    let (mut context, stake_pool_accounts) = setup().await;
-
-    let updated_name = "updated_name";
-    let updated_symbol = "USYM";
-    let updated_uri = "updated_uri";
-
-    let random_keypair = Keypair::new();
-    let ix = instruction::update_token_metadata(
-        &spl_stake_pool::id(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        &random_keypair.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        updated_name.to_string(),
-        updated_symbol.to_string(),
-        updated_uri.to_string(),
-    );
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &random_keypair],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(_, InstructionError::Custom(error_index)) => {
-            let program_error = WrongManager as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while signing with the wrong manager"),
-    }
-}
diff --git a/stake-pool/program/tests/update_stake_pool_balance.rs b/stake-pool/program/tests/update_stake_pool_balance.rs
deleted file mode 100644
index f242e14382f..00000000000
--- a/stake-pool/program/tests/update_stake_pool_balance.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{borsh1::try_from_slice_unchecked, instruction::InstructionError},
-    solana_program_test::*,
-    solana_sdk::{
-        hash::Hash,
-        signature::{Keypair, Signer},
-        stake,
-        transaction::TransactionError,
-    },
-    spl_stake_pool::{error::StakePoolError, state::StakePool, MINIMUM_RESERVE_LAMPORTS},
-    std::num::NonZeroU32,
-};
-
-const NUM_VALIDATORS: u64 = 3;
-
-async fn setup(
-    num_validators: u64,
-) -> (
-    ProgramTestContext,
-    Hash,
-    StakePoolAccounts,
-    Vec<ValidatorStakeAccount>,
-) {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            (stake_rent + current_minimum_delegation) * num_validators,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let mut last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // Add several accounts
-    let mut stake_accounts: Vec<ValidatorStakeAccount> = vec![];
-    for i in 0..num_validators {
-        let stake_account = ValidatorStakeAccount::new(
-            &stake_pool_accounts.stake_pool.pubkey(),
-            NonZeroU32::new(i as u32),
-            u64::MAX,
-        );
-        create_vote(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.validator,
-            &stake_account.vote,
-        )
-        .await;
-
-        let error = stake_pool_accounts
-            .add_validator_to_pool(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.vote.pubkey(),
-                stake_account.validator_stake_seed,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-
-        let mut deposit_account = DepositStakeAccount::new_with_vote(
-            stake_account.vote.pubkey(),
-            stake_account.stake_account,
-            TEST_STAKE_AMOUNT,
-        );
-        deposit_account
-            .create_and_delegate(&mut context.banks_client, &context.payer, &last_blockhash)
-            .await;
-
-        deposit_account
-            .deposit_stake(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_pool_accounts,
-            )
-            .await;
-
-        last_blockhash = context
-            .banks_client
-            .get_new_latest_blockhash(&last_blockhash)
-            .await
-            .unwrap();
-
-        stake_accounts.push(stake_account);
-    }
-
-    (context, last_blockhash, stake_pool_accounts, stake_accounts)
-}
-
-#[tokio::test]
-async fn success() {
-    let (mut context, last_blockhash, stake_pool_accounts, stake_accounts) =
-        setup(NUM_VALIDATORS).await;
-
-    let pre_fee = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-
-    let pre_balance = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(pre_balance, stake_pool.total_lamports);
-
-    let pre_token_supply = get_token_supply(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-
-    // Increment vote credits to earn rewards
-    const VOTE_CREDITS: u64 = 1_000;
-    for stake_account in &stake_accounts {
-        context.increment_vote_account_credits(&stake_account.vote.pubkey(), VOTE_CREDITS);
-    }
-
-    // Update epoch
-    let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // Update list and pool
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check fee
-    let post_balance = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(post_balance, stake_pool.total_lamports);
-
-    let post_fee = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-    let pool_token_supply = get_token_supply(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-    let actual_fee = post_fee - pre_fee;
-    assert_eq!(pool_token_supply - pre_token_supply, actual_fee);
-
-    let expected_fee_lamports = (post_balance - pre_balance) * stake_pool.epoch_fee.numerator
-        / stake_pool.epoch_fee.denominator;
-    let actual_fee_lamports = stake_pool.calc_pool_tokens_for_deposit(actual_fee).unwrap();
-    assert_eq!(actual_fee_lamports, expected_fee_lamports);
-
-    let expected_fee = expected_fee_lamports * pool_token_supply / post_balance;
-    assert_eq!(expected_fee, actual_fee);
-
-    assert_eq!(pool_token_supply, stake_pool.pool_token_supply);
-    assert_eq!(pre_token_supply, stake_pool.last_epoch_pool_token_supply);
-    assert_eq!(pre_balance, stake_pool.last_epoch_total_lamports);
-}
-
-#[tokio::test]
-async fn success_absorbing_extra_lamports() {
-    let (mut context, mut last_blockhash, stake_pool_accounts, stake_accounts) =
-        setup(NUM_VALIDATORS).await;
-
-    let pre_balance = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(stake_pool.data.as_slice()).unwrap();
-    assert_eq!(pre_balance, stake_pool.total_lamports);
-
-    let pre_token_supply = get_token_supply(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-
-    // Transfer extra funds, will be absorbed during update
-    const EXTRA_STAKE_AMOUNT: u64 = 1_000_000;
-    for stake_account in &stake_accounts {
-        transfer(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.stake_account,
-            EXTRA_STAKE_AMOUNT,
-        )
-        .await;
-
-        last_blockhash = context
-            .banks_client
-            .get_new_latest_blockhash(&last_blockhash)
-            .await
-            .unwrap();
-    }
-
-    let extra_lamports = EXTRA_STAKE_AMOUNT * stake_accounts.len() as u64;
-    let expected_fee = stake_pool.calc_epoch_fee_amount(extra_lamports).unwrap();
-
-    // Update epoch
-    let slot = context.genesis_config().epoch_schedule.first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // Update list and pool
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check extra lamports are absorbed and fee'd as rewards
-    let post_balance = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(post_balance, pre_balance + extra_lamports);
-    let pool_token_supply = get_token_supply(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-    assert_eq!(pool_token_supply, pre_token_supply + expected_fee);
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let wrong_validator_list = Keypair::new();
-    stake_pool_accounts.validator_list = wrong_validator_list;
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(&mut banks_client, &payer, &recent_blockhash)
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        ) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to update pool balance with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_pool_fee_account() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let wrong_fee_account = Keypair::new();
-    stake_pool_accounts.pool_fee_account = wrong_fee_account;
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(&mut banks_client, &payer, &recent_blockhash)
-        .await
-        .unwrap()
-        .unwrap();
-
-    match error {
-        TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        ) => {
-            let program_error = StakePoolError::InvalidFeeAccount as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to update pool balance with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_reserve() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let mut stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let wrong_reserve_stake = Keypair::new();
-    stake_pool_accounts.reserve_stake = wrong_reserve_stake;
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(&mut banks_client, &payer, &recent_blockhash)
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidProgramAddress as u32),
-        )
-    );
-}
-
-#[tokio::test]
-async fn test_update_stake_pool_balance_with_uninitialized_validator_list() {} // TODO
-
-#[tokio::test]
-async fn test_update_stake_pool_balance_with_out_of_dated_validators_balances() {} // TODO
diff --git a/stake-pool/program/tests/update_validator_list_balance.rs b/stake-pool/program/tests/update_validator_list_balance.rs
deleted file mode 100644
index 7d5d431a16c..00000000000
--- a/stake-pool/program/tests/update_validator_list_balance.rs
+++ /dev/null
@@ -1,737 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{borsh1::try_from_slice_unchecked, program_pack::Pack},
-    solana_program_test::*,
-    solana_sdk::{hash::Hash, signature::Signer, stake::state::StakeStateV2},
-    spl_stake_pool::{
-        state::{StakePool, StakeStatus, ValidatorList},
-        MAX_VALIDATORS_TO_UPDATE, MINIMUM_RESERVE_LAMPORTS,
-    },
-    spl_token::state::Mint,
-    std::num::NonZeroU32,
-};
-
-async fn setup(
-    num_validators: usize,
-) -> (
-    ProgramTestContext,
-    Hash,
-    StakePoolAccounts,
-    Vec<ValidatorStakeAccount>,
-    Vec<DepositStakeAccount>,
-    u64,
-    u64,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let mut slot = first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    let reserve_stake_amount = TEST_STAKE_AMOUNT * 2 * num_validators as u64;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            reserve_stake_amount + MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    // Add several accounts with some stake
-    let mut stake_accounts: Vec<ValidatorStakeAccount> = vec![];
-    let mut deposit_accounts: Vec<DepositStakeAccount> = vec![];
-    for i in 0..num_validators {
-        let stake_account = ValidatorStakeAccount::new(
-            &stake_pool_accounts.stake_pool.pubkey(),
-            NonZeroU32::new(i as u32),
-            u64::MAX,
-        );
-        create_vote(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_account.validator,
-            &stake_account.vote,
-        )
-        .await;
-
-        let error = stake_pool_accounts
-            .add_validator_to_pool(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.vote.pubkey(),
-                stake_account.validator_stake_seed,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-
-        let deposit_account = DepositStakeAccount::new_with_vote(
-            stake_account.vote.pubkey(),
-            stake_account.stake_account,
-            TEST_STAKE_AMOUNT,
-        );
-        deposit_account
-            .create_and_delegate(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-            )
-            .await;
-
-        stake_accounts.push(stake_account);
-        deposit_accounts.push(deposit_account);
-    }
-
-    // Warp forward so the stakes properly activate, and deposit
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    for deposit_account in &mut deposit_accounts {
-        deposit_account
-            .deposit_stake(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_pool_accounts,
-            )
-            .await;
-    }
-
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    (
-        context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        deposit_accounts,
-        TEST_STAKE_AMOUNT,
-        reserve_stake_amount,
-        slot,
-    )
-}
-
-#[tokio::test]
-async fn success_with_normal() {
-    let num_validators = 5;
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        validator_lamports,
-        reserve_lamports,
-        mut slot,
-    ) = setup(num_validators).await;
-
-    // Check current balance in the list
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<StakeStateV2>());
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    let validator_list_sum = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(stake_pool.total_lamports, validator_list_sum);
-    // initially, have all of the deposits plus their rent, and the reserve stake
-    let initial_lamports =
-        (validator_lamports + stake_rent) * num_validators as u64 + reserve_lamports;
-    assert_eq!(validator_list_sum, initial_lamports);
-
-    // Simulate rewards
-    for stake_account in &stake_accounts {
-        context.increment_vote_account_credits(&stake_account.vote.pubkey(), 100);
-    }
-
-    // Warp one more epoch so the rewards are paid out
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    let new_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert!(new_lamports > initial_lamports);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(new_lamports, stake_pool.total_lamports);
-}
-
-#[tokio::test]
-async fn merge_into_reserve() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        lamports,
-        _,
-        mut slot,
-    ) = setup(MAX_VALIDATORS_TO_UPDATE).await;
-
-    let pre_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-
-    let reserve_stake = context
-        .banks_client
-        .get_account(stake_pool_accounts.reserve_stake.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let pre_reserve_lamports = reserve_stake.lamports;
-
-    println!("Decrease from all validators");
-    for stake_account in &stake_accounts {
-        let error = stake_pool_accounts
-            .decrease_validator_stake_either(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.transient_stake_account,
-                lamports,
-                stake_account.transient_stake_seed,
-                DecreaseInstruction::Reserve,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-    }
-
-    println!("Update, should not change, no merges yet");
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(expected_lamports, stake_pool.total_lamports);
-
-    println!("Warp one more epoch so the stakes deactivate");
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-
-    let reserve_stake = context
-        .banks_client
-        .get_account(stake_pool_accounts.reserve_stake.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let post_reserve_lamports = reserve_stake.lamports;
-    assert!(post_reserve_lamports > pre_reserve_lamports);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(expected_lamports, stake_pool.total_lamports);
-}
-
-#[tokio::test]
-async fn merge_into_validator_stake() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        lamports,
-        reserve_lamports,
-        mut slot,
-    ) = setup(MAX_VALIDATORS_TO_UPDATE).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let pre_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-
-    // Increase stake to all validators
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-    )
-    .await;
-    let available_lamports =
-        reserve_lamports - (stake_rent + current_minimum_delegation) * stake_accounts.len() as u64;
-    let increase_amount = available_lamports / stake_accounts.len() as u64;
-    for stake_account in &stake_accounts {
-        let error = stake_pool_accounts
-            .increase_validator_stake(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_account.transient_stake_account,
-                &stake_account.stake_account,
-                &stake_account.vote.pubkey(),
-                increase_amount,
-                stake_account.transient_stake_seed,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-    }
-
-    // Warp just a little bit to get a new blockhash and update again
-    context.warp_to_slot(slot + 10).unwrap();
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // Update, should not change, no merges yet
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(expected_lamports, stake_pool.total_lamports);
-
-    // Warp one more epoch so the stakes activate, ready to merge
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-    let current_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(current_lamports, stake_pool.total_lamports);
-
-    // Check that transient accounts are gone
-    for stake_account in &stake_accounts {
-        assert!(context
-            .banks_client
-            .get_account(stake_account.transient_stake_account)
-            .await
-            .unwrap()
-            .is_none());
-    }
-
-    // Check validator stake accounts have the expected balance now:
-    // validator stake account minimum + deposited lamports + rents + increased
-    // lamports
-    let expected_lamports = current_minimum_delegation + lamports + increase_amount + stake_rent;
-    for stake_account in &stake_accounts {
-        let validator_stake =
-            get_account(&mut context.banks_client, &stake_account.stake_account).await;
-        assert_eq!(validator_stake.lamports, expected_lamports);
-    }
-
-    // Check reserve stake accounts for expected balance:
-    // own rent, other account rents, and 1 extra lamport
-    let reserve_stake = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    assert_eq!(
-        reserve_stake.lamports,
-        MINIMUM_RESERVE_LAMPORTS + stake_rent * (1 + stake_accounts.len() as u64)
-    );
-}
-
-#[tokio::test]
-async fn merge_transient_stake_after_remove() {
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        lamports,
-        reserve_lamports,
-        mut slot,
-    ) = setup(1).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-    )
-    .await;
-    let deactivated_lamports = lamports;
-    // Decrease and remove all validators
-    for stake_account in &stake_accounts {
-        let error = stake_pool_accounts
-            .decrease_validator_stake_either(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.transient_stake_account,
-                deactivated_lamports,
-                stake_account.transient_stake_seed,
-                DecreaseInstruction::Reserve,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-        let error = stake_pool_accounts
-            .remove_validator_from_pool(
-                &mut context.banks_client,
-                &context.payer,
-                &last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.transient_stake_account,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-    }
-
-    // Warp forward to merge time
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    // Update without merge, status should be DeactivatingTransient
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            true,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(validator_list.validators.len(), 1);
-    assert_eq!(
-        validator_list.validators[0].status,
-        StakeStatus::DeactivatingAll.into()
-    );
-    assert_eq!(
-        u64::from(validator_list.validators[0].active_stake_lamports),
-        stake_rent + current_minimum_delegation
-    );
-    assert_eq!(
-        u64::from(validator_list.validators[0].transient_stake_lamports),
-        deactivated_lamports + stake_rent
-    );
-
-    // Update with merge, status should be ReadyForRemoval and no lamports
-    let error = stake_pool_accounts
-        .update_validator_list_balance(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            validator_list.validators.len(),
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // stake accounts were merged in, none exist anymore
-    for stake_account in &stake_accounts {
-        let not_found_account = context
-            .banks_client
-            .get_account(stake_account.stake_account)
-            .await
-            .unwrap();
-        assert!(not_found_account.is_none());
-        let not_found_account = context
-            .banks_client
-            .get_account(stake_account.transient_stake_account)
-            .await
-            .unwrap();
-        assert!(not_found_account.is_none());
-    }
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(validator_list.validators.len(), 1);
-    assert_eq!(
-        validator_list.validators[0].status,
-        StakeStatus::ReadyForRemoval.into()
-    );
-    assert_eq!(validator_list.validators[0].stake_lamports().unwrap(), 0);
-
-    let reserve_stake = context
-        .banks_client
-        .get_account(stake_pool_accounts.reserve_stake.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        reserve_stake.lamports,
-        reserve_lamports + deactivated_lamports + stake_rent * 2 + MINIMUM_RESERVE_LAMPORTS
-    );
-
-    // Update stake pool balance and cleanup, should be gone
-    let error = stake_pool_accounts
-        .update_stake_pool_balance(&mut context.banks_client, &context.payer, &last_blockhash)
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .cleanup_removed_validator_entries(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(validator_list.validators.len(), 0);
-}
-
-#[tokio::test]
-async fn success_with_burned_tokens() {
-    let num_validators = 1;
-    let (mut context, last_blockhash, stake_pool_accounts, _, deposit_accounts, _, _, mut slot) =
-        setup(num_validators).await;
-
-    let mint_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-    let mint = Mint::unpack(&mint_info.data).unwrap();
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(mint.supply, stake_pool.pool_token_supply);
-
-    burn_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &deposit_accounts[0].pool_account.pubkey(),
-        &deposit_accounts[0].authority,
-        deposit_accounts[0].pool_tokens,
-    )
-    .await
-    .unwrap();
-
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let mint_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_mint.pubkey(),
-    )
-    .await;
-    let mint = Mint::unpack(&mint_info.data).unwrap();
-    assert_ne!(mint.supply, stake_pool.pool_token_supply);
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-
-    assert_eq!(mint.supply, stake_pool.pool_token_supply);
-}
-
-#[tokio::test]
-async fn fail_with_uninitialized_validator_list() {} // TODO
-
-#[tokio::test]
-async fn success_with_force_destaked_validator() {}
diff --git a/stake-pool/program/tests/update_validator_list_balance_hijack.rs b/stake-pool/program/tests/update_validator_list_balance_hijack.rs
deleted file mode 100644
index 66a2ab36d40..00000000000
--- a/stake-pool/program/tests/update_validator_list_balance_hijack.rs
+++ /dev/null
@@ -1,547 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-use spl_stake_pool::instruction;
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{borsh1::try_from_slice_unchecked, pubkey::Pubkey, stake},
-    solana_program_test::*,
-    solana_sdk::{
-        hash::Hash,
-        instruction::InstructionError,
-        signature::Signer,
-        stake::state::{Authorized, Lockup, StakeStateV2},
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_stake_program_address, find_transient_stake_program_address,
-        find_withdraw_authority_program_address, id, state::StakePool, MINIMUM_RESERVE_LAMPORTS,
-    },
-    std::num::NonZeroU32,
-};
-
-async fn setup(
-    num_validators: usize,
-) -> (
-    ProgramTestContext,
-    Hash,
-    StakePoolAccounts,
-    Vec<ValidatorStakeAccount>,
-    Vec<DepositStakeAccount>,
-    u64,
-    u64,
-    u64,
-) {
-    let mut context = program_test().start_with_context().await;
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let mut slot = first_normal_slot + 1;
-    context.warp_to_slot(slot).unwrap();
-
-    let reserve_stake_amount = TEST_STAKE_AMOUNT * 2 * num_validators as u64;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            reserve_stake_amount + MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    // Add several accounts with some stake
-    let mut stake_accounts: Vec<ValidatorStakeAccount> = vec![];
-    let mut deposit_accounts: Vec<DepositStakeAccount> = vec![];
-    for i in 0..num_validators {
-        let stake_account = ValidatorStakeAccount::new(
-            &stake_pool_accounts.stake_pool.pubkey(),
-            NonZeroU32::new(i as u32),
-            u64::MAX,
-        );
-        create_vote(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_account.validator,
-            &stake_account.vote,
-        )
-        .await;
-
-        let error = stake_pool_accounts
-            .add_validator_to_pool(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-                &stake_account.stake_account,
-                &stake_account.vote.pubkey(),
-                stake_account.validator_stake_seed,
-            )
-            .await;
-        assert!(error.is_none(), "{:?}", error);
-
-        let deposit_account = DepositStakeAccount::new_with_vote(
-            stake_account.vote.pubkey(),
-            stake_account.stake_account,
-            TEST_STAKE_AMOUNT,
-        );
-        deposit_account
-            .create_and_delegate(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-            )
-            .await;
-
-        stake_accounts.push(stake_account);
-        deposit_accounts.push(deposit_account);
-    }
-
-    // Warp forward so the stakes properly activate, and deposit
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    for deposit_account in &mut deposit_accounts {
-        deposit_account
-            .deposit_stake(
-                &mut context.banks_client,
-                &context.payer,
-                &context.last_blockhash,
-                &stake_pool_accounts,
-            )
-            .await;
-    }
-
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    (
-        context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        deposit_accounts,
-        TEST_STAKE_AMOUNT,
-        reserve_stake_amount,
-        slot,
-    )
-}
-
-#[tokio::test]
-async fn success_ignoring_hijacked_transient_stake_with_authorized() {
-    let hijacker = Pubkey::new_unique();
-    check_ignored_hijacked_transient_stake(Some(&Authorized::auto(&hijacker)), None).await;
-}
-
-#[tokio::test]
-async fn success_ignoring_hijacked_transient_stake_with_lockup() {
-    let hijacker = Pubkey::new_unique();
-    check_ignored_hijacked_transient_stake(
-        None,
-        Some(&Lockup {
-            custodian: hijacker,
-            ..Lockup::default()
-        }),
-    )
-    .await;
-}
-
-async fn check_ignored_hijacked_transient_stake(
-    hijack_authorized: Option<&Authorized>,
-    hijack_lockup: Option<&Lockup>,
-) {
-    let num_validators = 1;
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        lamports,
-        _,
-        mut slot,
-    ) = setup(num_validators).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<StakeStateV2>());
-
-    let pre_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let (withdraw_authority, _) =
-        find_withdraw_authority_program_address(&id(), &stake_pool_accounts.stake_pool.pubkey());
-
-    println!("Decrease from all validators");
-    let stake_account = &stake_accounts[0];
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.stake_account,
-            &stake_account.transient_stake_account,
-            lamports,
-            stake_account.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    println!("Warp one epoch so the stakes deactivate and merge");
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    println!("During update, hijack the transient stake account");
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &stake_account.vote.pubkey(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        stake_account.transient_stake_seed,
-    )
-    .0;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::update_validator_list_balance_chunk(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &validator_list,
-                1,
-                0,
-                /* no_merge = */ false,
-            )
-            .unwrap(),
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &transient_stake_address,
-                stake_rent + MINIMUM_RESERVE_LAMPORTS,
-            ),
-            stake::instruction::initialize(
-                &transient_stake_address,
-                hijack_authorized.unwrap_or(&Authorized::auto(&withdraw_authority)),
-                hijack_lockup.unwrap_or(&Lockup::default()),
-            ),
-            instruction::update_stake_pool_balance(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &spl_token::id(),
-            ),
-            instruction::cleanup_removed_validator_entries(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err();
-    assert!(error.is_none(), "{:?}", error);
-
-    println!("Update again normally, should be no change in the lamports");
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(pre_lamports, stake_pool.total_lamports);
-}
-
-#[tokio::test]
-async fn success_ignoring_hijacked_validator_stake_with_authorized() {
-    let hijacker = Pubkey::new_unique();
-    check_ignored_hijacked_transient_stake(Some(&Authorized::auto(&hijacker)), None).await;
-}
-
-#[tokio::test]
-async fn success_ignoring_hijacked_validator_stake_with_lockup() {
-    let hijacker = Pubkey::new_unique();
-    check_ignored_hijacked_validator_stake(
-        None,
-        Some(&Lockup {
-            custodian: hijacker,
-            ..Lockup::default()
-        }),
-    )
-    .await;
-}
-
-async fn check_ignored_hijacked_validator_stake(
-    hijack_authorized: Option<&Authorized>,
-    hijack_lockup: Option<&Lockup>,
-) {
-    let num_validators = 1;
-    let (
-        mut context,
-        last_blockhash,
-        stake_pool_accounts,
-        stake_accounts,
-        _,
-        lamports,
-        _,
-        mut slot,
-    ) = setup(num_validators).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<StakeStateV2>());
-
-    let pre_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let (withdraw_authority, _) =
-        find_withdraw_authority_program_address(&id(), &stake_pool_accounts.stake_pool.pubkey());
-
-    let stake_account = &stake_accounts[0];
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.stake_account,
-            &stake_account.transient_stake_account,
-            lamports,
-            stake_account.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.stake_account,
-            &stake_account.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    println!("Warp one epoch so the stakes deactivate and merge");
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    println!("During update, hijack the validator stake account");
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::update_validator_list_balance_chunk(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &validator_list,
-                1,
-                0,
-                /* no_merge = */ false,
-            )
-            .unwrap(),
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &stake_account.stake_account,
-                stake_rent + MINIMUM_RESERVE_LAMPORTS,
-            ),
-            stake::instruction::initialize(
-                &stake_account.stake_account,
-                hijack_authorized.unwrap_or(&Authorized::auto(&withdraw_authority)),
-                hijack_lockup.unwrap_or(&Lockup::default()),
-            ),
-            instruction::update_stake_pool_balance(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &spl_token::id(),
-            ),
-            instruction::cleanup_removed_validator_entries(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err();
-    assert!(error.is_none(), "{:?}", error);
-
-    println!("Update again normally, should be no change in the lamports");
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(pre_lamports, stake_pool.total_lamports);
-
-    println!("Fail adding validator back in with first seed");
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account.stake_account,
-            &stake_account.vote.pubkey(),
-            stake_account.validator_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::AlreadyInUse as u32),
-        )
-    );
-
-    println!("Succeed adding validator back in with new seed");
-    let seed = NonZeroU32::new(1);
-    let validator = stake_account.vote.pubkey();
-    let (stake_account, _) = find_stake_program_address(
-        &id(),
-        &validator,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        seed,
-    );
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &stake_account,
-            &validator,
-            seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let stake_pool_info = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool_info.data).unwrap();
-    assert_eq!(pre_lamports, stake_pool.total_lamports);
-
-    let expected_lamports = get_validator_list_sum(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    assert_eq!(pre_lamports, expected_lamports);
-}
diff --git a/stake-pool/program/tests/vsa_add.rs b/stake-pool/program/tests/vsa_add.rs
deleted file mode 100644
index 3016a28d8b9..00000000000
--- a/stake-pool/program/tests/vsa_add.rs
+++ /dev/null
@@ -1,720 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        hash::Hash,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-        stake, system_program, sysvar,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_stake_program_address, id, instruction, state,
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-};
-
-async fn setup(
-    num_validators: u64,
-) -> (
-    BanksClient,
-    Keypair,
-    Hash,
-    StakePoolAccounts,
-    ValidatorStakeAccount,
-) {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation =
-        stake_pool_get_minimum_delegation(&mut banks_client, &payer, &recent_blockhash).await;
-    let minimum_for_validator = stake_rent + current_minimum_delegation;
-
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS + num_validators * minimum_for_validator,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake =
-        ValidatorStakeAccount::new(&stake_pool_accounts.stake_pool.pubkey(), None, 0);
-    create_vote(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-
-    (
-        banks_client,
-        payer,
-        recent_blockhash,
-        stake_pool_accounts,
-        validator_stake,
-    )
-}
-
-#[tokio::test]
-async fn success() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check if validator account was added to the list
-    let validator_list = get_account(
-        &mut banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let rent = banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation =
-        stake_pool_get_minimum_delegation(&mut banks_client, &payer, &recent_blockhash).await;
-    assert_eq!(
-        validator_list,
-        state::ValidatorList {
-            header: state::ValidatorListHeader {
-                account_type: state::AccountType::ValidatorList,
-                max_validators: stake_pool_accounts.max_validators,
-            },
-            validators: vec![state::ValidatorStakeInfo {
-                status: state::StakeStatus::Active.into(),
-                vote_account_address: validator_stake.vote.pubkey(),
-                last_update_epoch: 0.into(),
-                active_stake_lamports: (stake_rent + current_minimum_delegation).into(),
-                transient_stake_lamports: 0.into(),
-                transient_seed_suffix: 0.into(),
-                unused: 0.into(),
-                validator_seed_suffix: validator_stake
-                    .validator_stake_seed
-                    .map(|s| s.get())
-                    .unwrap_or(0)
-                    .into(),
-            }]
-        }
-    );
-
-    // Check stake account existence and authority
-    let stake = get_account(&mut banks_client, &validator_stake.stake_account).await;
-    let stake_state = deserialize::<stake::state::StakeStateV2>(&stake.data).unwrap();
-    match stake_state {
-        stake::state::StakeStateV2::Stake(meta, _, _) => {
-            assert_eq!(
-                &meta.authorized.staker,
-                &stake_pool_accounts.withdraw_authority
-            );
-            assert_eq!(
-                &meta.authorized.withdrawer,
-                &stake_pool_accounts.withdraw_authority
-            );
-        }
-        _ => panic!(),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list_account() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let wrong_validator_list = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::add_validator_to_pool(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &wrong_validator_list.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.staker], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to add validator stake address with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_double_add() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(2).await;
-
-    stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-
-    let latest_blockhash = banks_client.get_latest_blockhash().await.unwrap();
-
-    let transaction_error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &latest_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::ValidatorAlreadyAdded as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to add already added validator stake account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_wrong_staker() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let malicious = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::add_validator_to_pool(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &malicious.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &malicious], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::WrongStaker as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to add validator stake account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_without_signature() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), false),
-        AccountMeta::new(payer.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new(validator_stake.stake_account, false),
-        AccountMeta::new(validator_stake.vote.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::AddValidatorToPool(
-            validator_stake
-                .validator_stake_seed
-                .map(|s| s.get())
-                .unwrap_or(0),
-        ))
-        .unwrap(),
-    };
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to add validator stake account without signing transaction"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_stake_program_id() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let wrong_stake_program = Pubkey::new_unique();
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), true),
-        AccountMeta::new(payer.pubkey(), true),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new(validator_stake.stake_account, false),
-        AccountMeta::new(validator_stake.vote.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(system_program::id(), false),
-        AccountMeta::new_readonly(wrong_stake_program, false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::AddValidatorToPool(
-            validator_stake
-                .validator_stake_seed
-                .map(|s| s.get())
-                .unwrap_or(0),
-        ))
-        .unwrap(),
-    };
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer, &stake_pool_accounts.staker], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to add validator stake account with wrong stake program ID"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_system_program_id() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let wrong_system_program = Pubkey::new_unique();
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), true),
-        AccountMeta::new(payer.pubkey(), true),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new(validator_stake.stake_account, false),
-        AccountMeta::new(validator_stake.vote.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(sysvar::stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
-        AccountMeta::new_readonly(wrong_system_program, false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::AddValidatorToPool(
-            validator_stake
-                .validator_stake_seed
-                .map(|s| s.get())
-                .unwrap_or(0),
-        ))
-        .unwrap(),
-    };
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer, &stake_pool_accounts.staker], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to add validator stake account with wrong stake program ID"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_add_too_many_validator_stake_accounts() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let rent = banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation =
-        stake_pool_get_minimum_delegation(&mut banks_client, &payer, &recent_blockhash).await;
-    let minimum_for_validator = stake_rent + current_minimum_delegation;
-
-    let stake_pool_accounts = StakePoolAccounts {
-        max_validators: 1,
-        ..Default::default()
-    };
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            MINIMUM_RESERVE_LAMPORTS + 2 * minimum_for_validator,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake =
-        ValidatorStakeAccount::new(&stake_pool_accounts.stake_pool.pubkey(), None, 0);
-    create_vote(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_stake =
-        ValidatorStakeAccount::new(&stake_pool_accounts.stake_pool.pubkey(), None, 0);
-    create_vote(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::AccountDataTooSmall),
-    );
-}
-
-#[tokio::test]
-async fn fail_with_unupdated_stake_pool() {} // TODO
-
-#[tokio::test]
-async fn fail_with_uninitialized_validator_list_account() {} // TODO
-
-#[tokio::test]
-async fn fail_on_non_vote_account() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, _) = setup(1).await;
-
-    let validator = Pubkey::new_unique();
-    let (stake_account, _) = find_stake_program_address(
-        &id(),
-        &validator,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        None,
-    );
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &stake_account,
-            &validator,
-            None,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::IncorrectProgramId,)
-    );
-}
-
-#[tokio::test]
-async fn fail_on_incorrectly_derived_stake_account() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let bad_stake_account = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &bad_stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidStakeAccountAddress as u32),
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_with_lamports_in_account() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    transfer(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &validator_stake.stake_account,
-        1_000_000,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check stake account existence and authority
-    let stake = get_account(&mut banks_client, &validator_stake.stake_account).await;
-    let stake_state = deserialize::<stake::state::StakeStateV2>(&stake.data).unwrap();
-    match stake_state {
-        stake::state::StakeStateV2::Stake(meta, _, _) => {
-            assert_eq!(
-                &meta.authorized.staker,
-                &stake_pool_accounts.withdraw_authority
-            );
-            assert_eq!(
-                &meta.authorized.withdrawer,
-                &stake_pool_accounts.withdraw_authority
-            );
-        }
-        _ => panic!(),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_not_enough_reserve_lamports() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(0).await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::InsufficientFunds)
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_reserve() {
-    let (mut banks_client, payer, recent_blockhash, stake_pool_accounts, validator_stake) =
-        setup(1).await;
-
-    let wrong_reserve = Pubkey::new_unique();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::add_validator_to_pool(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &wrong_reserve,
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )],
-        Some(&payer.pubkey()),
-    );
-    transaction.sign(&[&payer, &stake_pool_accounts.staker], recent_blockhash);
-    let transaction_error = banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to add validator stake address with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_draining_reserve() {
-    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
-    let current_minimum_delegation =
-        stake_pool_get_minimum_delegation(&mut banks_client, &payer, &recent_blockhash).await;
-
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            current_minimum_delegation, // add exactly enough for a validator
-        )
-        .await
-        .unwrap();
-
-    let validator_stake =
-        ValidatorStakeAccount::new(&stake_pool_accounts.stake_pool.pubkey(), None, 0);
-    create_vote(
-        &mut banks_client,
-        &payer,
-        &recent_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut banks_client,
-            &payer,
-            &recent_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::InsufficientFunds),
-    );
-}
diff --git a/stake-pool/program/tests/vsa_remove.rs b/stake-pool/program/tests/vsa_remove.rs
deleted file mode 100644
index 46571865b2b..00000000000
--- a/stake-pool/program/tests/vsa_remove.rs
+++ /dev/null
@@ -1,845 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-        stake, system_instruction, sysvar,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{
-        error::StakePoolError, find_transient_stake_program_address, id, instruction, state,
-        MINIMUM_RESERVE_LAMPORTS,
-    },
-    std::num::NonZeroU32,
-};
-
-async fn setup() -> (ProgramTestContext, StakePoolAccounts, ValidatorStakeAccount) {
-    let mut context = program_test().start_with_context().await;
-    let stake_pool_accounts = StakePoolAccounts::default();
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            10_000_000_000 + MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let validator_stake = ValidatorStakeAccount::new(
-        &stake_pool_accounts.stake_pool.pubkey(),
-        NonZeroU32::new(u32::MAX),
-        u64::MAX,
-    );
-    create_vote(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &validator_stake.validator,
-        &validator_stake.vote,
-    )
-    .await;
-
-    let error = stake_pool_accounts
-        .add_validator_to_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            validator_stake.validator_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-    (context, stake_pool_accounts, validator_stake)
-}
-
-#[tokio::test]
-async fn success() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check if account was removed from the list of stake accounts
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(
-        validator_list,
-        state::ValidatorList {
-            header: state::ValidatorListHeader {
-                account_type: state::AccountType::ValidatorList,
-                max_validators: stake_pool_accounts.max_validators,
-            },
-            validators: vec![]
-        }
-    );
-
-    // Check stake account no longer exists
-    let account = context
-        .banks_client
-        .get_account(validator_stake.stake_account)
-        .await
-        .unwrap();
-    assert!(account.is_none());
-}
-
-#[tokio::test]
-async fn fail_with_wrong_stake_program_id() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let wrong_stake_program = Pubkey::new_unique();
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), true),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new(validator_stake.stake_account, false),
-        AccountMeta::new_readonly(validator_stake.transient_stake_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(wrong_stake_program, false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::RemoveValidatorFromPool).unwrap(),
-    };
-
-    let mut transaction =
-        Transaction::new_with_payer(&[instruction], Some(&context.payer.pubkey()));
-    transaction.sign(
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            error,
-        )) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to remove validator stake address with wrong stake program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list_account() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let wrong_validator_list = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::remove_validator_from_pool(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.staker.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &wrong_validator_list.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )],
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(
-        &[&context.payer, &stake_pool_accounts.staker],
-        context.last_blockhash,
-    );
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to remove validator stake address with wrong validator stake list account"),
-    }
-}
-
-#[tokio::test]
-async fn success_at_large_value() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-
-    let threshold_amount = current_minimum_delegation * 1_000;
-    let _ = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake,
-        threshold_amount,
-    )
-    .await
-    .unwrap();
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_double_remove() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::BorshIoError("Unknown".to_string())
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_wrong_staker() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let malicious = Keypair::new();
-
-    let mut transaction = Transaction::new_with_payer(
-        &[instruction::remove_validator_from_pool(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &malicious.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &stake_pool_accounts.validator_list.pubkey(),
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )],
-        Some(&context.payer.pubkey()),
-    );
-    transaction.sign(&[&context.payer, &malicious], context.last_blockhash);
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::WrongStaker as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => {
-            panic!("Wrong error occurs while not an staker try to remove validator stake address")
-        }
-    }
-}
-
-#[tokio::test]
-async fn fail_no_signature() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.staker.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new(validator_stake.stake_account, false),
-        AccountMeta::new_readonly(validator_stake.transient_stake_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(stake::program::id(), false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::RemoveValidatorFromPool).unwrap(),
-    };
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::SignatureMissing as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while malicious try to remove validator stake account without signing transaction"),
-    }
-}
-
-#[tokio::test]
-async fn success_with_activating_transient_stake() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    // increase the validator stake
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            2_000_000_000,
-            validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // transient stake should be inactive now
-    let stake = get_account(
-        &mut context.banks_client,
-        &validator_stake.transient_stake_account,
-    )
-    .await;
-    let stake_state = deserialize::<stake::state::StakeStateV2>(&stake.data).unwrap();
-    assert_ne!(
-        stake_state.stake().unwrap().delegation.deactivation_epoch,
-        u64::MAX
-    );
-}
-
-#[tokio::test]
-async fn success_with_deactivating_transient_stake() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-    let deposit_info = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake,
-        TEST_STAKE_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    // increase the validator stake
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            TEST_STAKE_AMOUNT + stake_rent,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // fail deposit
-    let maybe_deposit = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        &validator_stake,
-        TEST_STAKE_AMOUNT,
-    )
-    .await;
-    assert!(maybe_deposit.is_none());
-
-    // fail withdraw
-    let user_stake_recipient = Keypair::new();
-    create_blank_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &user_stake_recipient,
-    )
-    .await;
-
-    let user_transfer_authority = Keypair::new();
-    let new_authority = Pubkey::new_unique();
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-        &user_transfer_authority.pubkey(),
-        1,
-    )
-    .await;
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_authority,
-            1,
-        )
-        .await;
-    assert!(error.is_some());
-
-    // check validator has changed
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let expected_list = state::ValidatorList {
-        header: state::ValidatorListHeader {
-            account_type: state::AccountType::ValidatorList,
-            max_validators: stake_pool_accounts.max_validators,
-        },
-        validators: vec![state::ValidatorStakeInfo {
-            status: state::StakeStatus::DeactivatingAll.into(),
-            vote_account_address: validator_stake.vote.pubkey(),
-            last_update_epoch: 0.into(),
-            active_stake_lamports: (stake_rent + current_minimum_delegation).into(),
-            transient_stake_lamports: (TEST_STAKE_AMOUNT + stake_rent * 2).into(),
-            transient_seed_suffix: validator_stake.transient_stake_seed.into(),
-            unused: 0.into(),
-            validator_seed_suffix: validator_stake
-                .validator_stake_seed
-                .map(|s| s.get())
-                .unwrap_or(0)
-                .into(),
-        }],
-    };
-    assert_eq!(validator_list, expected_list);
-
-    // Update will merge since activation and deactivation were in the same epoch
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let expected_list = state::ValidatorList {
-        header: state::ValidatorListHeader {
-            account_type: state::AccountType::ValidatorList,
-            max_validators: stake_pool_accounts.max_validators,
-        },
-        validators: vec![],
-    };
-    assert_eq!(validator_list, expected_list);
-}
-
-#[tokio::test]
-async fn success_resets_preferred_validator() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Deposit,
-            Some(validator_stake.vote.pubkey()),
-        )
-        .await;
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(validator_stake.vote.pubkey()),
-        )
-        .await;
-
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check if account was removed from the list of stake accounts
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(
-        validator_list,
-        state::ValidatorList {
-            header: state::ValidatorListHeader {
-                account_type: state::AccountType::ValidatorList,
-                max_validators: stake_pool_accounts.max_validators,
-            },
-            validators: vec![]
-        }
-    );
-
-    // Check stake account no longer exists
-    let account = context
-        .banks_client
-        .get_account(validator_stake.stake_account)
-        .await
-        .unwrap();
-    assert!(account.is_none());
-}
-
-#[tokio::test]
-async fn success_with_hijacked_transient_account() {
-    let (mut context, stake_pool_accounts, validator_stake) = setup().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let current_minimum_delegation = stake_pool_get_minimum_delegation(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-    )
-    .await;
-    let increase_amount = current_minimum_delegation + stake_rent;
-
-    // increase stake on validator
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            increase_amount,
-            validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to merge
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
-    let mut slot = first_normal_slot + slots_per_epoch + 1;
-    context.warp_to_slot(slot).unwrap();
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    // decrease
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            increase_amount,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to merge
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    // hijack
-    let validator_list = stake_pool_accounts
-        .get_validator_list(&mut context.banks_client)
-        .await;
-    let hijacker = Keypair::new();
-    let transient_stake_address = find_transient_stake_program_address(
-        &id(),
-        &validator_stake.vote.pubkey(),
-        &stake_pool_accounts.stake_pool.pubkey(),
-        validator_stake.transient_stake_seed,
-    )
-    .0;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::update_validator_list_balance_chunk(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &validator_list,
-                1,
-                0,
-                /* no_merge = */ false,
-            )
-            .unwrap(),
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &transient_stake_address,
-                current_minimum_delegation + stake_rent,
-            ),
-            stake::instruction::initialize(
-                &transient_stake_address,
-                &stake::state::Authorized {
-                    staker: hijacker.pubkey(),
-                    withdrawer: hijacker.pubkey(),
-                },
-                &stake::state::Lockup::default(),
-            ),
-            instruction::update_stake_pool_balance(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.withdraw_authority,
-                &stake_pool_accounts.validator_list.pubkey(),
-                &stake_pool_accounts.reserve_stake.pubkey(),
-                &stake_pool_accounts.pool_fee_account.pubkey(),
-                &stake_pool_accounts.pool_mint.pubkey(),
-                &spl_token::id(),
-            ),
-            instruction::cleanup_removed_validator_entries(
-                &id(),
-                &stake_pool_accounts.stake_pool.pubkey(),
-                &stake_pool_accounts.validator_list.pubkey(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err();
-    assert!(error.is_none(), "{:?}", error);
-
-    // activate transient stake account
-    delegate_stake_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &transient_stake_address,
-        &hijacker,
-        &validator_stake.vote.pubkey(),
-    )
-    .await;
-
-    // Remove works even though transient account is activating
-    let error = stake_pool_accounts
-        .remove_validator_from_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to merge
-    slot += slots_per_epoch;
-    context.warp_to_slot(slot).unwrap();
-
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check if account was removed from the list of stake accounts
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    assert_eq!(
-        validator_list,
-        state::ValidatorList {
-            header: state::ValidatorListHeader {
-                account_type: state::AccountType::ValidatorList,
-                max_validators: stake_pool_accounts.max_validators,
-            },
-            validators: vec![]
-        }
-    );
-}
-
-#[tokio::test]
-async fn fail_not_updated_stake_pool() {} // TODO
-
-#[tokio::test]
-async fn fail_with_uninitialized_validator_list_account() {} // TODO
diff --git a/stake-pool/program/tests/withdraw.rs b/stake-pool/program/tests/withdraw.rs
deleted file mode 100644
index 84401a1e91c..00000000000
--- a/stake-pool/program/tests/withdraw.rs
+++ /dev/null
@@ -1,840 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        pubkey::Pubkey,
-        sysvar,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_stake_pool::{error::StakePoolError, id, instruction, state},
-    spl_token::error::TokenError,
-    test_case::test_case,
-};
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    _success(token_program_id, SuccessTestType::Success).await;
-}
-
-#[tokio::test]
-async fn success_with_closed_manager_fee_account() {
-    _success(spl_token::id(), SuccessTestType::UninitializedManagerFee).await;
-}
-
-enum SuccessTestType {
-    Success,
-    UninitializedManagerFee,
-}
-
-async fn _success(token_program_id: Pubkey, test_type: SuccessTestType) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(token_program_id, 0).await;
-
-    // Save stake pool state before withdrawal
-    let stake_pool_before = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool_before =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool_before.data.as_slice()).unwrap();
-
-    // Check user recipient stake account balance
-    let initial_stake_lamports =
-        get_account(&mut context.banks_client, &user_stake_recipient.pubkey())
-            .await
-            .lamports;
-
-    // Save validator stake account record before withdrawal
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let validator_stake_item_before = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-
-    // Save user token balance
-    let user_token_balance_before = get_token_balance(
-        &mut context.banks_client,
-        &deposit_info.pool_account.pubkey(),
-    )
-    .await;
-
-    // Save pool fee token balance
-    let pool_fee_balance_before = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-
-    let destination_keypair = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &destination_keypair,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &Keypair::new(),
-        &[],
-    )
-    .await
-    .unwrap();
-
-    if let SuccessTestType::UninitializedManagerFee = test_type {
-        transfer_spl_tokens(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &destination_keypair.pubkey(),
-            &stake_pool_accounts.manager,
-            pool_fee_balance_before,
-            stake_pool_accounts.pool_decimals,
-        )
-        .await;
-        // Check that the account cannot be frozen due to lack of
-        // freeze authority.
-        let transaction_error = freeze_token_account(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &stake_pool_accounts.manager,
-        )
-        .await
-        .unwrap_err();
-
-        match transaction_error {
-            TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-                assert_eq!(error, InstructionError::Custom(0x10));
-            }
-            _ => panic!("Wrong error occurs while try to withdraw with wrong stake program ID"),
-        }
-        close_token_account(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &stake_pool_accounts.token_program_id,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &destination_keypair.pubkey(),
-            &stake_pool_accounts.manager,
-        )
-        .await
-        .unwrap();
-    }
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_withdraw,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check pool stats
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-    // first and only deposit, lamports:pool 1:1
-    let tokens_withdrawal_fee = match test_type {
-        SuccessTestType::Success => {
-            stake_pool_accounts.calculate_withdrawal_fee(tokens_to_withdraw)
-        }
-        _ => 0,
-    };
-    let tokens_burnt = tokens_to_withdraw - tokens_withdrawal_fee;
-    assert_eq!(
-        stake_pool.total_lamports,
-        stake_pool_before.total_lamports - tokens_burnt
-    );
-    assert_eq!(
-        stake_pool.pool_token_supply,
-        stake_pool_before.pool_token_supply - tokens_burnt
-    );
-
-    if let SuccessTestType::Success = test_type {
-        // Check manager received withdrawal fee
-        let pool_fee_balance = get_token_balance(
-            &mut context.banks_client,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-        )
-        .await;
-        assert_eq!(
-            pool_fee_balance,
-            pool_fee_balance_before + tokens_withdrawal_fee,
-        );
-    }
-
-    // Check validator stake list storage
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let validator_stake_item = validator_list
-        .find(&validator_stake_account.vote.pubkey())
-        .unwrap();
-    assert_eq!(
-        validator_stake_item.stake_lamports().unwrap(),
-        validator_stake_item_before.stake_lamports().unwrap() - tokens_burnt
-    );
-    assert_eq!(
-        u64::from(validator_stake_item.active_stake_lamports),
-        validator_stake_item.stake_lamports().unwrap(),
-    );
-
-    // Check tokens used
-    let user_token_balance = get_token_balance(
-        &mut context.banks_client,
-        &deposit_info.pool_account.pubkey(),
-    )
-    .await;
-    assert_eq!(
-        user_token_balance,
-        user_token_balance_before - tokens_to_withdraw
-    );
-
-    // Check validator stake account balance
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &validator_stake_account.stake_account,
-    )
-    .await;
-    assert_eq!(
-        validator_stake_account.lamports,
-        u64::from(validator_stake_item.active_stake_lamports)
-    );
-
-    // Check user recipient stake account balance
-    let user_stake_recipient_account =
-        get_account(&mut context.banks_client, &user_stake_recipient.pubkey()).await;
-    assert_eq!(
-        user_stake_recipient_account.lamports,
-        initial_stake_lamports + tokens_burnt
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_stake_program() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let new_authority = Pubkey::new_unique();
-    let wrong_stake_program = Pubkey::new_unique();
-
-    let accounts = vec![
-        AccountMeta::new(stake_pool_accounts.stake_pool.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.validator_list.pubkey(), false),
-        AccountMeta::new_readonly(stake_pool_accounts.withdraw_authority, false),
-        AccountMeta::new(validator_stake_account.stake_account, false),
-        AccountMeta::new(user_stake_recipient.pubkey(), false),
-        AccountMeta::new_readonly(new_authority, false),
-        AccountMeta::new_readonly(user_transfer_authority.pubkey(), true),
-        AccountMeta::new(deposit_info.pool_account.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.pool_fee_account.pubkey(), false),
-        AccountMeta::new(stake_pool_accounts.pool_mint.pubkey(), false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(spl_token::id(), false),
-        AccountMeta::new_readonly(wrong_stake_program, false),
-    ];
-    let instruction = Instruction {
-        program_id: id(),
-        accounts,
-        data: borsh::to_vec(&instruction::StakePoolInstruction::WithdrawStake(
-            tokens_to_burn,
-        ))
-        .unwrap(),
-    };
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &user_transfer_authority],
-        context.last_blockhash,
-    );
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to withdraw with wrong stake program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (
-        mut context,
-        mut stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let new_authority = Pubkey::new_unique();
-    stake_pool_accounts.withdraw_authority = Keypair::new().pubkey();
-
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::InvalidProgramAddress as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!("Wrong error occurs while try to withdraw with wrong withdraw authority"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_token_program_id() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let new_authority = Pubkey::new_unique();
-    let wrong_token_program = Keypair::new();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::withdraw_stake(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.validator_list.pubkey(),
-            &stake_pool_accounts.withdraw_authority,
-            &validator_stake_account.stake_account,
-            &user_stake_recipient.pubkey(),
-            &new_authority,
-            &user_transfer_authority.pubkey(),
-            &deposit_info.pool_account.pubkey(),
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &stake_pool_accounts.pool_mint.pubkey(),
-            &wrong_token_program.pubkey(),
-            tokens_to_burn,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &user_transfer_authority],
-        context.last_blockhash,
-    );
-    let transaction_error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .err()
-        .unwrap()
-        .into();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::IncorrectProgramId);
-        }
-        _ => panic!("Wrong error occurs while try to withdraw with wrong token program ID"),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_wrong_validator_list() {
-    let (
-        mut context,
-        mut stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let new_authority = Pubkey::new_unique();
-    stake_pool_accounts.validator_list = Keypair::new();
-
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = StakePoolError::InvalidValidatorStakeList as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to withdraw with wrong validator stake list account"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_unknown_validator() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        _,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let unknown_stake = create_unknown_validator_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.stake_pool.pubkey(),
-        0,
-    )
-    .await;
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &unknown_stake.stake_account,
-            &new_authority,
-            tokens_to_withdraw,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ValidatorNotFound as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_double_withdraw_to_the_same_account() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn / 2,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let latest_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    // Delegate tokens for burning
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &latest_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-        &user_transfer_authority.pubkey(),
-        tokens_to_burn / 2,
-    )
-    .await;
-
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &latest_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn / 2,
-        )
-        .await
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(_, error)) => {
-            assert_eq!(error, InstructionError::InvalidAccountData);
-        }
-        _ => panic!("Wrong error occurs while try to do double withdraw"),
-    }
-}
-
-#[tokio::test]
-async fn fail_without_token_approval() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    revoke_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-    )
-    .await;
-
-    let new_authority = Pubkey::new_unique();
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap();
-
-    match transaction_error {
-        TransportError::TransactionError(TransactionError::InstructionError(
-            _,
-            InstructionError::Custom(error_index),
-        )) => {
-            let program_error = TokenError::OwnerMismatch as u32;
-            assert_eq!(error_index, program_error);
-        }
-        _ => panic!(
-            "Wrong error occurs while try to do withdraw without token delegation for burn before"
-        ),
-    }
-}
-
-#[tokio::test]
-async fn fail_with_not_enough_tokens() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // Empty validator stake account
-    let empty_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &empty_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::StakeLamportsNotEqualToMinimum as u32)
-        ),
-    );
-
-    // revoked delegation
-    revoke_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-    )
-    .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // generate a new authority each time to make each transaction unique
-    let new_authority = Pubkey::new_unique();
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        transaction_error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenError::OwnerMismatch as u32),
-        )
-    );
-
-    // Delegate few tokens for burning
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &deposit_info.authority,
-        &user_transfer_authority.pubkey(),
-        1,
-    )
-    .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // generate a new authority each time to make each transaction unique
-    let new_authority = Pubkey::new_unique();
-    let transaction_error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        transaction_error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenError::InsufficientFunds as u32),
-        )
-    );
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success_with_slippage(token_program_id: Pubkey) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(token_program_id, 0).await;
-
-    // Save user token balance
-    let user_token_balance_before = get_token_balance(
-        &mut context.banks_client,
-        &deposit_info.pool_account.pubkey(),
-    )
-    .await;
-
-    // first and only deposit, lamports:pool 1:1
-    let tokens_withdrawal_fee = stake_pool_accounts.calculate_withdrawal_fee(tokens_to_withdraw);
-    let received_lamports = tokens_to_withdraw - tokens_withdrawal_fee;
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_withdraw,
-            received_lamports + 1,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ExceededSlippage as u32)
-        )
-    );
-
-    let error = stake_pool_accounts
-        .withdraw_stake_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            tokens_to_withdraw,
-            received_lamports,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check tokens used
-    let user_token_balance = get_token_balance(
-        &mut context.banks_client,
-        &deposit_info.pool_account.pubkey(),
-    )
-    .await;
-    assert_eq!(
-        user_token_balance,
-        user_token_balance_before - tokens_to_withdraw
-    );
-}
diff --git a/stake-pool/program/tests/withdraw_edge_cases.rs b/stake-pool/program/tests/withdraw_edge_cases.rs
deleted file mode 100644
index 8abdc2f87a3..00000000000
--- a/stake-pool/program/tests/withdraw_edge_cases.rs
+++ /dev/null
@@ -1,877 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::items_after_test_module)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked, instruction::InstructionError, pubkey::Pubkey, stake,
-    },
-    solana_program_test::*,
-    solana_sdk::{signature::Signer, transaction::TransactionError},
-    spl_stake_pool::{error::StakePoolError, instruction, state},
-    test_case::test_case,
-};
-
-#[tokio::test]
-async fn fail_remove_validator() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        _,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    // decrease a little stake, not all
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports / 2,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    // update to merge deactivated stake into reserve
-    let error = stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Withdraw entire account, fail because some stake left
-    let validator_stake_account =
-        get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-    let remaining_lamports = validator_stake_account.lamports;
-    let new_user_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_user_authority,
-            remaining_lamports,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::StakeLamportsNotEqualToMinimum as u32)
-        )
-    );
-}
-
-#[test_case(0; "equal")]
-#[test_case(5; "big")]
-#[test_case(11; "bigger")]
-#[test_case(29; "biggest")]
-#[tokio::test]
-async fn success_remove_validator(multiple: u64) {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        _,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    // make pool tokens very valuable, so it isn't possible to exactly get down to
-    // the minimum
-    transfer(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        deposit_info.stake_lamports * multiple, // each pool token is worth more than one lamport
-    )
-    .await;
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let stake_pool = stake_pool_accounts
-        .get_stake_pool(&mut context.banks_client)
-        .await;
-    let lamports_per_pool_token = stake_pool.get_lamports_per_pool_token().unwrap();
-
-    // decrease all of stake except for lamports_per_pool_token lamports, must be
-    // withdrawable
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports + stake_rent - lamports_per_pool_token,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // update to merge deactivated stake into reserve
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let validator_stake_account =
-        get_account(&mut context.banks_client, &validator_stake.stake_account).await;
-    let remaining_lamports = validator_stake_account.lamports;
-    let stake_minimum_delegation =
-        stake_get_minimum_delegation(&mut context.banks_client, &context.payer, &last_blockhash)
-            .await;
-    // make sure it's actually more than the minimum
-    assert!(remaining_lamports > stake_rent + stake_minimum_delegation);
-
-    // round up to force one more pool token if needed
-    let pool_tokens_post_fee =
-        (remaining_lamports * stake_pool.pool_token_supply + stake_pool.total_lamports - 1)
-            / stake_pool.total_lamports;
-    let new_user_authority = Pubkey::new_unique();
-    let pool_tokens = stake_pool_accounts.calculate_inverse_withdrawal_fee(pool_tokens_post_fee);
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_user_authority,
-            pool_tokens,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check validator stake account gone
-    let validator_stake_account = context
-        .banks_client
-        .get_account(validator_stake.stake_account)
-        .await
-        .unwrap();
-    assert!(validator_stake_account.is_none());
-
-    // Check user recipient stake account balance
-    let user_stake_recipient_account =
-        get_account(&mut context.banks_client, &user_stake_recipient.pubkey()).await;
-    assert_eq!(
-        user_stake_recipient_account.lamports,
-        remaining_lamports + stake_rent
-    );
-
-    // Check that cleanup happens correctly
-    stake_pool_accounts
-        .cleanup_removed_validator_entries(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-        )
-        .await;
-
-    let validator_list = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.validator_list.pubkey(),
-    )
-    .await;
-    let validator_list =
-        try_from_slice_unchecked::<state::ValidatorList>(validator_list.data.as_slice()).unwrap();
-    let validator_stake_item = validator_list.find(&validator_stake.vote.pubkey());
-    assert!(validator_stake_item.is_none());
-}
-
-#[tokio::test]
-async fn fail_with_reserve() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    // decrease a little stake, not all
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports / 2,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    // update to merge deactivated stake into reserve
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    // Withdraw directly from reserve, fail because some stake left
-    let new_user_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &new_user_authority,
-            tokens_to_burn,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::StakeLamportsNotEqualToMinimum as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_with_reserve() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        _,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // decrease all of stake
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.stake_account,
-            &validator_stake.transient_stake_account,
-            deposit_info.stake_lamports + stake_rent,
-            validator_stake.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    // update to merge deactivated stake into reserve
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            false,
-        )
-        .await;
-
-    // now it works
-    let new_user_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &stake_pool_accounts.reserve_stake.pubkey(),
-            &new_user_authority,
-            deposit_info.pool_tokens,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // first and only deposit, lamports:pool 1:1
-    let stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(stake_pool.data.as_slice()).unwrap();
-    // the entire deposit is actually stake since it isn't activated, so only
-    // the stake deposit fee is charged
-    let deposit_fee = stake_pool
-        .calc_pool_tokens_stake_deposit_fee(stake_rent + deposit_info.stake_lamports)
-        .unwrap();
-    assert_eq!(
-        deposit_info.stake_lamports + stake_rent - deposit_fee,
-        deposit_info.pool_tokens,
-        "stake {} rent {} deposit fee {} pool tokens {}",
-        deposit_info.stake_lamports,
-        stake_rent,
-        deposit_fee,
-        deposit_info.pool_tokens
-    );
-
-    let withdrawal_fee = stake_pool_accounts.calculate_withdrawal_fee(deposit_info.pool_tokens);
-
-    // Check tokens used
-    let user_token_balance = get_token_balance(
-        &mut context.banks_client,
-        &deposit_info.pool_account.pubkey(),
-    )
-    .await;
-    assert_eq!(user_token_balance, 0);
-
-    // Check reserve stake account balance
-    let reserve_stake_account = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await;
-    let stake_state =
-        deserialize::<stake::state::StakeStateV2>(&reserve_stake_account.data).unwrap();
-    let meta = stake_state.meta().unwrap();
-    assert_eq!(
-        meta.rent_exempt_reserve + withdrawal_fee + deposit_fee + stake_rent,
-        reserve_stake_account.lamports
-    );
-
-    // Check user recipient stake account balance
-    let user_stake_recipient_account =
-        get_account(&mut context.banks_client, &user_stake_recipient.pubkey()).await;
-    assert_eq!(
-        user_stake_recipient_account.lamports,
-        deposit_info.stake_lamports + stake_rent * 2 - withdrawal_fee - deposit_fee
-    );
-}
-
-#[tokio::test]
-async fn success_with_empty_preferred_withdraw() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    // preferred is empty, withdrawing from non-preferred works
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_authority,
-            tokens_to_burn / 2,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn success_and_fail_with_preferred_withdraw() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    let _preferred_deposit = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        &preferred_validator,
-        TEST_STAKE_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_authority,
-            tokens_to_burn / 2 + 1,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::IncorrectWithdrawVoteAddress as u32)
-        )
-    );
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // success from preferred
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &preferred_validator.stake_account,
-            &new_authority,
-            tokens_to_burn / 2,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_withdraw_from_transient() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // add a preferred withdraw validator, keep it empty, to be sure that this works
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    // decrease to minimum stake + 2 lamports
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake_account.stake_account,
-            &validator_stake_account.transient_stake_account,
-            deposit_info.stake_lamports + stake_rent - 2,
-            validator_stake_account.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // fail withdrawing from transient, still a lamport in the validator stake
-    // account
-    let new_user_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.transient_stake_account,
-            &new_user_authority,
-            tokens_to_withdraw,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidStakeAccountAddress as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_withdraw_from_transient() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(spl_token::id(), STAKE_ACCOUNT_RENT_EXEMPTION).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // add a preferred withdraw validator, keep it empty, to be sure that this works
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // decrease all of stake
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &validator_stake_account.stake_account,
-            &validator_stake_account.transient_stake_account,
-            deposit_info.stake_lamports + stake_rent,
-            validator_stake_account.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // nothing left in the validator stake account (or any others), so withdrawing
-    // from the transient account is ok!
-    let new_user_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake_account.transient_stake_account,
-            &new_user_authority,
-            tokens_to_withdraw / 2,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn success_with_small_preferred_withdraw() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_burn,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // make pool tokens very valuable, so it isn't possible to exactly get down to
-    // the minimum
-    transfer(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-        deposit_info.stake_lamports * 5, // each pool token is worth more than one lamport
-    )
-    .await;
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    let preferred_validator = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    stake_pool_accounts
-        .set_preferred_validator(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            instruction::PreferredValidatorType::Withdraw,
-            Some(preferred_validator.vote.pubkey()),
-        )
-        .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // add a tiny bit of stake, less than lamports per pool token to preferred
-    // validator
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_exempt = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let stake_minimum_delegation =
-        stake_get_minimum_delegation(&mut context.banks_client, &context.payer, &last_blockhash)
-            .await;
-    let minimum_lamports = stake_minimum_delegation + rent_exempt;
-
-    simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        &preferred_validator,
-        stake_minimum_delegation + 1, // stake_rent gets deposited too
-    )
-    .await
-    .unwrap();
-
-    // decrease all stake except for 1 lamport
-    let error = stake_pool_accounts
-        .decrease_validator_stake_either(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &preferred_validator.stake_account,
-            &preferred_validator.transient_stake_account,
-            minimum_lamports,
-            preferred_validator.transient_stake_seed,
-            DecreaseInstruction::Reserve,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // warp forward to deactivation
-    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
-    context.warp_to_slot(first_normal_slot + 1).unwrap();
-
-    // update to merge deactivated stake into reserve
-    stake_pool_accounts
-        .update_all(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            false,
-        )
-        .await;
-
-    // withdraw from preferred fails
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &preferred_validator.stake_account,
-            &new_authority,
-            1,
-        )
-        .await;
-    assert!(error.is_some());
-
-    // preferred is empty, withdrawing from non-preferred works
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &deposit_info.pool_account.pubkey(),
-            &validator_stake.stake_account,
-            &new_authority,
-            tokens_to_burn / 6,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
diff --git a/stake-pool/program/tests/withdraw_sol.rs b/stake-pool/program/tests/withdraw_sol.rs
deleted file mode 100644
index 623aa82cf0a..00000000000
--- a/stake-pool/program/tests/withdraw_sol.rs
+++ /dev/null
@@ -1,394 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    helpers::*,
-    solana_program::{
-        borsh1::try_from_slice_unchecked, instruction::InstructionError, pubkey::Pubkey, stake,
-    },
-    solana_program_test::*,
-    solana_sdk::{
-        signature::{Keypair, Signer},
-        transaction::{Transaction, TransactionError},
-    },
-    spl_stake_pool::{
-        error::StakePoolError,
-        id,
-        instruction::{self, FundingType},
-        state, MINIMUM_RESERVE_LAMPORTS,
-    },
-    test_case::test_case,
-};
-
-async fn setup(
-    token_program_id: Pubkey,
-) -> (ProgramTestContext, StakePoolAccounts, Keypair, Pubkey, u64) {
-    let mut context = program_test().start_with_context().await;
-
-    let stake_pool_accounts = StakePoolAccounts::new_with_token_program(token_program_id);
-    stake_pool_accounts
-        .initialize_stake_pool(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            MINIMUM_RESERVE_LAMPORTS,
-        )
-        .await
-        .unwrap();
-
-    let user = Keypair::new();
-
-    // make pool token account for user
-    let pool_token_account = Keypair::new();
-    create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &pool_token_account,
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &user,
-        &[],
-    )
-    .await
-    .unwrap();
-
-    let error = stake_pool_accounts
-        .deposit_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &pool_token_account.pubkey(),
-            TEST_STAKE_AMOUNT,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    let tokens_issued =
-        get_token_balance(&mut context.banks_client, &pool_token_account.pubkey()).await;
-
-    (
-        context,
-        stake_pool_accounts,
-        user,
-        pool_token_account.pubkey(),
-        tokens_issued,
-    )
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success(token_program_id: Pubkey) {
-    let (mut context, stake_pool_accounts, user, pool_token_account, pool_tokens) =
-        setup(token_program_id).await;
-
-    // Save stake pool state before withdrawing
-    let pre_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let pre_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(pre_stake_pool.data.as_slice()).unwrap();
-
-    // Save reserve state before withdrawing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let error = stake_pool_accounts
-        .withdraw_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            None,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Stake pool should add its balance to the pool balance
-    let post_stake_pool = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.stake_pool.pubkey(),
-    )
-    .await;
-    let post_stake_pool =
-        try_from_slice_unchecked::<state::StakePool>(post_stake_pool.data.as_slice()).unwrap();
-    let amount_withdrawn_minus_fee =
-        pool_tokens - stake_pool_accounts.calculate_withdrawal_fee(pool_tokens);
-    assert_eq!(
-        post_stake_pool.total_lamports,
-        pre_stake_pool.total_lamports - amount_withdrawn_minus_fee
-    );
-    assert_eq!(
-        post_stake_pool.pool_token_supply,
-        pre_stake_pool.pool_token_supply - amount_withdrawn_minus_fee
-    );
-
-    // Check minted tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    assert_eq!(user_token_balance, 0);
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports - amount_withdrawn_minus_fee
-    );
-}
-
-#[tokio::test]
-async fn fail_with_wrong_withdraw_authority() {
-    let (mut context, mut stake_pool_accounts, user, pool_token_account, pool_tokens) =
-        setup(spl_token::id()).await;
-
-    stake_pool_accounts.withdraw_authority = Pubkey::new_unique();
-
-    let error = stake_pool_accounts
-        .withdraw_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            None,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidProgramAddress as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_overdraw_reserve() {
-    let (mut context, stake_pool_accounts, user, pool_token_account, _) =
-        setup(spl_token::id()).await;
-
-    // add a validator and increase stake to drain the reserve
-    let validator_stake = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &context.last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let stake_rent = rent.minimum_balance(std::mem::size_of::<stake::state::StakeStateV2>());
-    let error = stake_pool_accounts
-        .increase_validator_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &validator_stake.transient_stake_account,
-            &validator_stake.stake_account,
-            &validator_stake.vote.pubkey(),
-            TEST_STAKE_AMOUNT - stake_rent,
-            validator_stake.transient_stake_seed,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // try to withdraw one lamport after fees, will overdraw
-    let error = stake_pool_accounts
-        .withdraw_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            2,
-            None,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::SolWithdrawalTooLarge as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_with_sol_withdraw_authority() {
-    let (mut context, stake_pool_accounts, user, pool_token_account, pool_tokens) =
-        setup(spl_token::id()).await;
-    let sol_withdraw_authority = Keypair::new();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&sol_withdraw_authority.pubkey()),
-            FundingType::SolWithdraw,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let error = stake_pool_accounts
-        .withdraw_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            Some(&sol_withdraw_authority),
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-}
-
-#[tokio::test]
-async fn fail_without_sol_withdraw_authority_signature() {
-    let (mut context, stake_pool_accounts, user, pool_token_account, pool_tokens) =
-        setup(spl_token::id()).await;
-    let sol_withdraw_authority = Keypair::new();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::set_funding_authority(
-            &id(),
-            &stake_pool_accounts.stake_pool.pubkey(),
-            &stake_pool_accounts.manager.pubkey(),
-            Some(&sol_withdraw_authority.pubkey()),
-            FundingType::SolWithdraw,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &stake_pool_accounts.manager],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let wrong_withdrawer = Keypair::new();
-    let error = stake_pool_accounts
-        .withdraw_sol(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            Some(&wrong_withdrawer),
-        )
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::InvalidSolWithdrawAuthority as u32)
-        )
-    );
-}
-
-#[test_case(spl_token::id(); "token")]
-#[test_case(spl_token_2022::id(); "token-2022")]
-#[tokio::test]
-async fn success_with_slippage(token_program_id: Pubkey) {
-    let (mut context, stake_pool_accounts, user, pool_token_account, pool_tokens) =
-        setup(token_program_id).await;
-
-    let amount_received = pool_tokens - stake_pool_accounts.calculate_withdrawal_fee(pool_tokens);
-
-    // Save reserve state before withdrawing
-    let pre_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-
-    let error = stake_pool_accounts
-        .withdraw_sol_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            amount_received + 1,
-        )
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(StakePoolError::ExceededSlippage as u32)
-        )
-    );
-
-    let error = stake_pool_accounts
-        .withdraw_sol_with_slippage(
-            &mut context.banks_client,
-            &context.payer,
-            &context.last_blockhash,
-            &user,
-            &pool_token_account,
-            pool_tokens,
-            amount_received,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check burned tokens
-    let user_token_balance =
-        get_token_balance(&mut context.banks_client, &pool_token_account).await;
-    assert_eq!(user_token_balance, 0);
-
-    // Check reserve
-    let post_reserve_lamports = get_account(
-        &mut context.banks_client,
-        &stake_pool_accounts.reserve_stake.pubkey(),
-    )
-    .await
-    .lamports;
-    assert_eq!(
-        post_reserve_lamports,
-        pre_reserve_lamports - amount_received
-    );
-}
diff --git a/stake-pool/program/tests/withdraw_with_fee.rs b/stake-pool/program/tests/withdraw_with_fee.rs
deleted file mode 100644
index 7a8e000c1cb..00000000000
--- a/stake-pool/program/tests/withdraw_with_fee.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![cfg(feature = "test-sbf")]
-
-mod helpers;
-
-use {
-    bincode::deserialize,
-    helpers::*,
-    solana_program::{pubkey::Pubkey, stake},
-    solana_program_test::*,
-    solana_sdk::signature::{Keypair, Signer},
-    spl_stake_pool::minimum_stake_lamports,
-};
-
-#[tokio::test]
-async fn success_withdraw_all_fee_tokens() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        validator_stake_account,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // move tokens to fee account
-    transfer_spl_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &user_transfer_authority,
-        tokens_to_withdraw / 2,
-        stake_pool_accounts.pool_decimals,
-    )
-    .await;
-
-    let fee_tokens = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-
-    let user_transfer_authority = Keypair::new();
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-        &stake_pool_accounts.manager,
-        &user_transfer_authority.pubkey(),
-        fee_tokens,
-    )
-    .await;
-
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &stake_pool_accounts.pool_fee_account.pubkey(),
-            &validator_stake_account.stake_account,
-            &new_authority,
-            fee_tokens,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check balance is 0
-    let fee_tokens = get_token_balance(
-        &mut context.banks_client,
-        &stake_pool_accounts.pool_fee_account.pubkey(),
-    )
-    .await;
-    assert_eq!(fee_tokens, 0);
-}
-
-#[tokio::test]
-async fn success_empty_out_stake_with_fee() {
-    let (
-        mut context,
-        stake_pool_accounts,
-        _,
-        deposit_info,
-        user_transfer_authority,
-        user_stake_recipient,
-        tokens_to_withdraw,
-    ) = setup_for_withdraw(spl_token::id(), 0).await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&context.last_blockhash)
-        .await
-        .unwrap();
-
-    // add another validator and deposit into it
-    let other_validator_stake_account = simple_add_validator_to_pool(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        None,
-    )
-    .await;
-
-    let other_deposit_info = simple_deposit_stake(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts,
-        &other_validator_stake_account,
-        TEST_STAKE_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    // move tokens to new account
-    transfer_spl_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &deposit_info.pool_account.pubkey(),
-        &stake_pool_accounts.pool_mint.pubkey(),
-        &other_deposit_info.pool_account.pubkey(),
-        &user_transfer_authority,
-        tokens_to_withdraw,
-        stake_pool_accounts.pool_decimals,
-    )
-    .await;
-
-    let user_tokens = get_token_balance(
-        &mut context.banks_client,
-        &other_deposit_info.pool_account.pubkey(),
-    )
-    .await;
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    let user_transfer_authority = Keypair::new();
-    delegate_tokens(
-        &mut context.banks_client,
-        &context.payer,
-        &last_blockhash,
-        &stake_pool_accounts.token_program_id,
-        &other_deposit_info.pool_account.pubkey(),
-        &other_deposit_info.authority,
-        &user_transfer_authority.pubkey(),
-        user_tokens,
-    )
-    .await;
-
-    // calculate exactly how much to withdraw, given the fee, to get the account
-    // down to 0, using an inverse fee calculation
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &other_validator_stake_account.stake_account,
-    )
-    .await;
-    let stake_state =
-        deserialize::<stake::state::StakeStateV2>(&validator_stake_account.data).unwrap();
-    let meta = stake_state.meta().unwrap();
-    let stake_minimum_delegation =
-        stake_get_minimum_delegation(&mut context.banks_client, &context.payer, &last_blockhash)
-            .await;
-    let lamports_to_withdraw =
-        validator_stake_account.lamports - minimum_stake_lamports(&meta, stake_minimum_delegation);
-    let pool_tokens_to_withdraw =
-        stake_pool_accounts.calculate_inverse_withdrawal_fee(lamports_to_withdraw);
-
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-    let new_authority = Pubkey::new_unique();
-    let error = stake_pool_accounts
-        .withdraw_stake(
-            &mut context.banks_client,
-            &context.payer,
-            &last_blockhash,
-            &user_stake_recipient.pubkey(),
-            &user_transfer_authority,
-            &other_deposit_info.pool_account.pubkey(),
-            &other_validator_stake_account.stake_account,
-            &new_authority,
-            pool_tokens_to_withdraw,
-        )
-        .await;
-    assert!(error.is_none(), "{:?}", error);
-
-    // Check balance of validator stake account is MINIMUM + rent-exemption
-    let validator_stake_account = get_account(
-        &mut context.banks_client,
-        &other_validator_stake_account.stake_account,
-    )
-    .await;
-    let stake_state =
-        deserialize::<stake::state::StakeStateV2>(&validator_stake_account.data).unwrap();
-    let meta = stake_state.meta().unwrap();
-    assert_eq!(
-        validator_stake_account.lamports,
-        minimum_stake_lamports(&meta, stake_minimum_delegation)
-    );
-}
diff --git a/stake-pool/py/.flake8 b/stake-pool/py/.flake8
deleted file mode 100644
index aa079ec57f8..00000000000
--- a/stake-pool/py/.flake8
+++ /dev/null
@@ -1,2 +0,0 @@
-[flake8]
-max-line-length=120
diff --git a/stake-pool/py/.gitignore b/stake-pool/py/.gitignore
deleted file mode 100644
index ad0e7548ff2..00000000000
--- a/stake-pool/py/.gitignore
+++ /dev/null
@@ -1,7 +0,0 @@
-# python cache files
-*__pycache__*
-.pytest_cache
-.mypy_cache
-
-# venv
-venv/
diff --git a/stake-pool/py/LICENSE b/stake-pool/py/LICENSE
deleted file mode 100644
index 7e71f6e9a88..00000000000
--- a/stake-pool/py/LICENSE
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright 2022 Solana Foundation.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/stake-pool/py/README.md b/stake-pool/py/README.md
deleted file mode 100644
index cda7beea17b..00000000000
--- a/stake-pool/py/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# Stake-Pool Python Bindings
-
-Preliminary Python bindings to interact with the stake pool program, enabling
-simple stake delegation bots.
-
-## To do
-
-* More reference bot implementations
-* Add bindings for all stake pool instructions, see `TODO`s in `stake_pool/instructions.py`
-* Finish bindings for vote and stake program
-* Upstream vote and stake program bindings to https://github.com/michaelhly/solana-py
-
-## Development
-
-### Environment Setup
-
-1. Ensure that Python 3 is installed with `venv`: https://www.python.org/downloads/
-2. (Optional, but highly recommended) Setup and activate a virtual environment:
-
-```
-$ python3 -m venv venv
-$ source venv/bin/activate
-```
-
-3. Install build and dev requirements
-
-```
-$ pip install -r requirements.txt
-$ pip install -r optional-requirements.txt
-```
-
-4. Install the Solana tool suite: https://docs.solana.com/cli/install-solana-cli-tools
-
-### Test
-
-Testing through `pytest`:
-
-```
-$ python3 -m pytest
-```
-
-Note: the tests all run against a `solana-test-validator` with short epochs of 64
-slots (25.6 seconds exactly). Some tests wait for epoch changes, so they take
-time, roughly 90 seconds total at the time of this writing.
-
-### Formatting
-
-```
-$ flake8 bot spl_token stake stake_pool system tests vote
-```
-
-### Type Checker
-
-```
-$ mypy bot stake stake_pool tests vote spl_token system
-```
-
-## Delegation Bots
-
-The `./bot` directory contains sample stake pool delegation bot implementations:
-
-* `rebalance`: simple bot to make the amount delegated to each validator
-uniform, while also maintaining some SOL in the reserve if desired. Can be run
-with the stake pool address, staker keypair, and SOL to leave in the reserve:
-
-```
-$ python3 bot/rebalance.py Zg5YBPAk8RqBR9kaLLSoN5C8Uv7nErBz1WC63HTsCPR staker.json 10.5
-```
diff --git a/stake-pool/py/bot/__init__.py b/stake-pool/py/bot/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/bot/rebalance.py b/stake-pool/py/bot/rebalance.py
deleted file mode 100644
index bc656a87591..00000000000
--- a/stake-pool/py/bot/rebalance.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import argparse
-import asyncio
-import json
-
-from solana.keypair import Keypair
-from solana.publickey import PublicKey
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-
-from stake.constants import STAKE_LEN, LAMPORTS_PER_SOL
-from stake_pool.actions import decrease_validator_stake, increase_validator_stake, update_stake_pool
-from stake_pool.constants import MINIMUM_ACTIVE_STAKE
-from stake_pool.state import StakePool, ValidatorList
-
-
-async def get_client(endpoint: str) -> AsyncClient:
-    print(f'Connecting to network at {endpoint}')
-    async_client = AsyncClient(endpoint=endpoint, commitment=Confirmed)
-    total_attempts = 10
-    current_attempt = 0
-    while not await async_client.is_connected():
-        if current_attempt == total_attempts:
-            raise Exception("Could not connect to test validator")
-        else:
-            current_attempt += 1
-        await asyncio.sleep(1)
-    return async_client
-
-
-async def rebalance(endpoint: str, stake_pool_address: PublicKey, staker: Keypair, retained_reserve_amount: float):
-    async_client = await get_client(endpoint)
-
-    resp = await async_client.get_epoch_info(commitment=Confirmed)
-    epoch = resp['result']['epoch']
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    print(f'Stake pool last update epoch {stake_pool.last_update_epoch}, current epoch {epoch}')
-    if stake_pool.last_update_epoch != epoch:
-        print('Updating stake pool')
-        await update_stake_pool(async_client, staker, stake_pool_address)
-        resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-        data = resp['result']['value']['data']
-        stake_pool = StakePool.decode(data[0], data[1])
-
-    resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-    retained_reserve_lamports = int(retained_reserve_amount * LAMPORTS_PER_SOL)
-
-    resp = await async_client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-
-    print('Stake pool stats:')
-    print(f'* {stake_pool.total_lamports} total lamports')
-    num_validators = len(validator_list.validators)
-    print(f'* {num_validators} validators')
-    print(f'* Retaining {retained_reserve_lamports} lamports in the reserve')
-    lamports_per_validator = (stake_pool.total_lamports - retained_reserve_lamports) // num_validators
-    num_increases = sum([
-        1 for validator in validator_list.validators
-        if validator.transient_stake_lamports == 0 and validator.active_stake_lamports < lamports_per_validator
-    ])
-    total_usable_lamports = stake_pool.total_lamports - retained_reserve_lamports - num_increases * stake_rent_exemption
-    lamports_per_validator = total_usable_lamports // num_validators
-    print(f'* {lamports_per_validator} lamports desired per validator')
-
-    futures = []
-    for validator in validator_list.validators:
-        if validator.transient_stake_lamports != 0:
-            print(f'Skipping {validator.vote_account_address}: {validator.transient_stake_lamports} transient lamports')
-        else:
-            if validator.active_stake_lamports > lamports_per_validator:
-                lamports_to_decrease = validator.active_stake_lamports - lamports_per_validator
-                if lamports_to_decrease <= stake_rent_exemption:
-                    print(f'Skipping decrease on {validator.vote_account_address}, \
-currently at {validator.active_stake_lamports} lamports, \
-decrease of {lamports_to_decrease} below the rent exmption')
-                else:
-                    futures.append(decrease_validator_stake(
-                        async_client, staker, staker, stake_pool_address,
-                        validator.vote_account_address, lamports_to_decrease
-                    ))
-            elif validator.active_stake_lamports < lamports_per_validator:
-                lamports_to_increase = lamports_per_validator - validator.active_stake_lamports
-                if lamports_to_increase < MINIMUM_ACTIVE_STAKE:
-                    print(f'Skipping increase on {validator.vote_account_address}, \
-currently at {validator.active_stake_lamports} lamports, \
-increase of {lamports_to_increase} less than the minimum of {MINIMUM_ACTIVE_STAKE}')
-                else:
-                    futures.append(increase_validator_stake(
-                        async_client, staker, staker, stake_pool_address,
-                        validator.vote_account_address, lamports_to_increase
-                    ))
-            else:
-                print(f'{validator.vote_account_address}: already at {lamports_per_validator}')
-
-    print('Executing strategy')
-    await asyncio.gather(*futures)
-    print('Done')
-    await async_client.close()
-
-
-def keypair_from_file(keyfile_name: str) -> Keypair:
-    with open(keyfile_name, 'r') as keyfile:
-        data = keyfile.read()
-    int_list = json.loads(data)
-    bytes_list = [value.to_bytes(1, 'little') for value in int_list]
-    return Keypair.from_secret_key(b''.join(bytes_list))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Rebalance stake evenly between all the validators in a stake pool.')
-    parser.add_argument('stake_pool', metavar='STAKE_POOL_ADDRESS', type=str,
-                        help='Stake pool to rebalance, given by a public key in base-58,\
-                         e.g. Zg5YBPAk8RqBR9kaLLSoN5C8Uv7nErBz1WC63HTsCPR')
-    parser.add_argument('staker', metavar='STAKER_KEYPAIR', type=str,
-                        help='Staker for the stake pool, given by a keypair file, e.g. staker.json')
-    parser.add_argument('reserve_amount', metavar='RESERVE_AMOUNT', type=float,
-                        help='Amount of SOL to keep in the reserve, e.g. 10.5')
-    parser.add_argument('--endpoint', metavar='ENDPOINT_URL', type=str,
-                        default='https://api.mainnet-beta.solana.com',
-                        help='RPC endpoint to use, e.g. https://api.mainnet-beta.solana.com')
-
-    args = parser.parse_args()
-    stake_pool = PublicKey(args.stake_pool)
-    staker = keypair_from_file(args.staker)
-    print(f'Rebalancing stake pool {stake_pool}')
-    print(f'Staker public key: {staker.public_key}')
-    print(f'Amount to leave in the reserve: {args.reserve_amount} SOL')
-    asyncio.run(rebalance(args.endpoint, stake_pool, staker, args.reserve_amount))
diff --git a/stake-pool/py/optional-requirements.txt b/stake-pool/py/optional-requirements.txt
deleted file mode 100644
index 5aa593192f4..00000000000
--- a/stake-pool/py/optional-requirements.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-attrs==22.1.0
-flake8==5.0.3
-iniconfig==1.1.1
-mccabe==0.7.0
-mypy==0.971
-mypy-extensions==0.4.3
-packaging==21.3
-pluggy==1.0.0
-py==1.11.0
-pycodestyle==2.9.0
-pyflakes==2.5.0
-pyparsing==3.0.9
-pytest==7.1.2
-pytest-asyncio==0.19.0
-tomli==2.0.1
diff --git a/stake-pool/py/requirements.txt b/stake-pool/py/requirements.txt
deleted file mode 100644
index c2b25c73869..00000000000
--- a/stake-pool/py/requirements.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-anyio==3.6.1
-base58==2.1.1
-cachetools==4.2.4
-certifi==2023.7.22
-cffi==1.15.1
-charset-normalizer==2.1.0
-construct==2.10.68
-h11==0.12.0
-httpcore==0.15.0
-httpx==0.23.0
-idna==3.7
-pycparser==2.21
-PyNaCl==1.5.0
-requests==2.32.0
-rfc3986==1.5.0
-sniffio==1.2.0
-solana==0.18.1
-typing_extensions==4.3.0
-urllib3==1.26.18
diff --git a/stake-pool/py/spl_token/__init__.py b/stake-pool/py/spl_token/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/spl_token/actions.py b/stake-pool/py/spl_token/actions.py
deleted file mode 100644
index 6c00a9285cf..00000000000
--- a/stake-pool/py/spl_token/actions.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from solana.publickey import PublicKey
-from solana.keypair import Keypair
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-from solana.rpc.types import TxOpts
-from solana.transaction import Transaction
-import solana.system_program as sys
-
-from spl.token.constants import TOKEN_PROGRAM_ID
-from spl.token.async_client import AsyncToken
-from spl.token._layouts import MINT_LAYOUT
-import spl.token.instructions as spl_token
-
-
-async def create_associated_token_account(
-    client: AsyncClient,
-    payer: Keypair,
-    owner: PublicKey,
-    mint: PublicKey
-) -> PublicKey:
-    txn = Transaction()
-    create_txn = spl_token.create_associated_token_account(
-        payer=payer.public_key, owner=owner, mint=mint
-    )
-    txn.add(create_txn)
-    await client.send_transaction(txn, payer, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-    return create_txn.keys[1].pubkey
-
-
-async def create_mint(client: AsyncClient, payer: Keypair, mint: Keypair, mint_authority: PublicKey):
-    mint_balance = await AsyncToken.get_min_balance_rent_for_exempt_for_mint(client)
-    print(f"Creating pool token mint {mint.public_key}")
-    txn = Transaction()
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=payer.public_key,
-                new_account_pubkey=mint.public_key,
-                lamports=mint_balance,
-                space=MINT_LAYOUT.sizeof(),
-                program_id=TOKEN_PROGRAM_ID,
-            )
-        )
-    )
-    txn.add(
-        spl_token.initialize_mint(
-            spl_token.InitializeMintParams(
-                program_id=TOKEN_PROGRAM_ID,
-                mint=mint.public_key,
-                decimals=9,
-                mint_authority=mint_authority,
-                freeze_authority=None,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, payer, mint, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
diff --git a/stake-pool/py/stake/__init__.py b/stake-pool/py/stake/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/stake/actions.py b/stake-pool/py/stake/actions.py
deleted file mode 100644
index 2963a43da62..00000000000
--- a/stake-pool/py/stake/actions.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from solana.publickey import PublicKey
-from solana.keypair import Keypair
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-from solana.rpc.types import TxOpts
-from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY
-from solana.transaction import Transaction
-import solana.system_program as sys
-
-from stake.constants import STAKE_LEN, STAKE_PROGRAM_ID, SYSVAR_STAKE_CONFIG_ID
-from stake.state import Authorized, Lockup, StakeAuthorize
-import stake.instructions as st
-
-
-async def create_stake(client: AsyncClient, payer: Keypair, stake: Keypair, authority: PublicKey, lamports: int):
-    print(f"Creating stake {stake.public_key}")
-    resp = await client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    txn = Transaction()
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=payer.public_key,
-                new_account_pubkey=stake.public_key,
-                lamports=resp['result'] + lamports,
-                space=STAKE_LEN,
-                program_id=STAKE_PROGRAM_ID,
-            )
-        )
-    )
-    txn.add(
-        st.initialize(
-            st.InitializeParams(
-                stake=stake.public_key,
-                authorized=Authorized(
-                    staker=authority,
-                    withdrawer=authority,
-                ),
-                lockup=Lockup(
-                    unix_timestamp=0,
-                    epoch=0,
-                    custodian=sys.SYS_PROGRAM_ID,
-                )
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, payer, stake, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def delegate_stake(client: AsyncClient, payer: Keypair, staker: Keypair, stake: PublicKey, vote: PublicKey):
-    txn = Transaction()
-    txn.add(
-        st.delegate_stake(
-            st.DelegateStakeParams(
-                stake=stake,
-                vote=vote,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                stake_config_id=SYSVAR_STAKE_CONFIG_ID,
-                staker=staker.public_key,
-            )
-        )
-    )
-    signers = [payer, staker] if payer != staker else [payer]
-    await client.send_transaction(
-        txn, *signers, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def authorize(
-    client: AsyncClient, payer: Keypair, authority: Keypair, stake: PublicKey,
-    new_authority: PublicKey, stake_authorize: StakeAuthorize
-):
-    txn = Transaction()
-    txn.add(
-        st.authorize(
-            st.AuthorizeParams(
-                stake=stake,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                authority=authority.public_key,
-                new_authority=new_authority,
-                stake_authorize=stake_authorize,
-            )
-        )
-    )
-    signers = [payer, authority] if payer != authority else [payer]
-    await client.send_transaction(
-        txn, *signers, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
diff --git a/stake-pool/py/stake/constants.py b/stake-pool/py/stake/constants.py
deleted file mode 100644
index 344a8a5e768..00000000000
--- a/stake-pool/py/stake/constants.py
+++ /dev/null
@@ -1,18 +0,0 @@
-"""Stake Program Constants."""
-
-from solana.publickey import PublicKey
-
-STAKE_PROGRAM_ID: PublicKey = PublicKey("Stake11111111111111111111111111111111111111")
-"""Public key that identifies the Stake program."""
-
-SYSVAR_STAKE_CONFIG_ID: PublicKey = PublicKey("StakeConfig11111111111111111111111111111111")
-"""Public key that identifies the Stake config sysvar."""
-
-STAKE_LEN: int = 200
-"""Size of stake account."""
-
-LAMPORTS_PER_SOL: int = 1_000_000_000
-"""Number of lamports per SOL"""
-
-MINIMUM_DELEGATION: int = LAMPORTS_PER_SOL
-"""Minimum delegation allowed by the stake program"""
diff --git a/stake-pool/py/stake/instructions.py b/stake-pool/py/stake/instructions.py
deleted file mode 100644
index f4b116bac5b..00000000000
--- a/stake-pool/py/stake/instructions.py
+++ /dev/null
@@ -1,178 +0,0 @@
-"""Stake Program Instructions."""
-
-from enum import IntEnum
-from typing import NamedTuple
-
-from construct import Switch  # type: ignore
-from construct import Int32ul, Pass  # type: ignore
-from construct import Bytes, Struct
-
-from solana.publickey import PublicKey
-from solana.sysvar import SYSVAR_RENT_PUBKEY
-from solana.transaction import AccountMeta, TransactionInstruction
-
-from stake.constants import STAKE_PROGRAM_ID
-from stake.state import AUTHORIZED_LAYOUT, LOCKUP_LAYOUT, Authorized, Lockup, StakeAuthorize
-
-PUBLIC_KEY_LAYOUT = Bytes(32)
-
-
-class InitializeParams(NamedTuple):
-    """Initialize stake transaction params."""
-
-    stake: PublicKey
-    """`[w]` Uninitialized stake account."""
-    authorized: Authorized
-    """Information about the staker and withdrawer keys."""
-    lockup: Lockup
-    """Stake lockup, if any."""
-
-
-class DelegateStakeParams(NamedTuple):
-    """Initialize stake transaction params."""
-
-    stake: PublicKey
-    """`[w]` Uninitialized stake account."""
-    vote: PublicKey
-    """`[]` Vote account to which this stake will be delegated."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    stake_history_sysvar: PublicKey
-    """`[]` Stake history sysvar that carries stake warmup/cooldown history."""
-    stake_config_id: PublicKey
-    """`[]` Address of config account that carries stake config."""
-    staker: PublicKey
-    """`[s]` Stake authority."""
-
-
-class AuthorizeParams(NamedTuple):
-    """Authorize stake transaction params."""
-
-    stake: PublicKey
-    """`[w]` Initialized stake account to modify."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    authority: PublicKey
-    """`[s]` Current stake authority."""
-
-    # Params
-    new_authority: PublicKey
-    """New authority's public key."""
-    stake_authorize: StakeAuthorize
-    """Type of authority to modify, staker or withdrawer."""
-
-
-class InstructionType(IntEnum):
-    """Stake Instruction Types."""
-
-    INITIALIZE = 0
-    AUTHORIZE = 1
-    DELEGATE_STAKE = 2
-    SPLIT = 3
-    WITHDRAW = 4
-    DEACTIVATE = 5
-    SET_LOCKUP = 6
-    MERGE = 7
-    AUTHORIZE_WITH_SEED = 8
-    INITIALIZE_CHECKED = 9
-    AUTHORIZED_CHECKED = 10
-    AUTHORIZED_CHECKED_WITH_SEED = 11
-    SET_LOCKUP_CHECKED = 12
-
-
-INITIALIZE_LAYOUT = Struct(
-    "authorized" / AUTHORIZED_LAYOUT,
-    "lockup" / LOCKUP_LAYOUT,
-)
-
-
-AUTHORIZE_LAYOUT = Struct(
-    "new_authority" / PUBLIC_KEY_LAYOUT,
-    "stake_authorize" / Int32ul,
-)
-
-
-INSTRUCTIONS_LAYOUT = Struct(
-    "instruction_type" / Int32ul,
-    "args"
-    / Switch(
-        lambda this: this.instruction_type,
-        {
-            InstructionType.INITIALIZE: INITIALIZE_LAYOUT,
-            InstructionType.AUTHORIZE: AUTHORIZE_LAYOUT,
-            InstructionType.DELEGATE_STAKE: Pass,
-            InstructionType.SPLIT: Pass,
-            InstructionType.WITHDRAW: Pass,
-            InstructionType.DEACTIVATE: Pass,
-            InstructionType.SET_LOCKUP: Pass,
-            InstructionType.MERGE: Pass,
-            InstructionType.AUTHORIZE_WITH_SEED: Pass,
-            InstructionType.INITIALIZE_CHECKED: Pass,
-            InstructionType.AUTHORIZED_CHECKED: Pass,
-            InstructionType.AUTHORIZED_CHECKED_WITH_SEED: Pass,
-            InstructionType.SET_LOCKUP_CHECKED: Pass,
-        },
-    ),
-)
-
-
-def initialize(params: InitializeParams) -> TransactionInstruction:
-    """Creates a transaction instruction to initialize a new stake."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False),
-        ],
-        program_id=STAKE_PROGRAM_ID,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.INITIALIZE,
-                args=dict(
-                    authorized=params.authorized.as_bytes_dict(),
-                    lockup=params.lockup.as_bytes_dict(),
-                ),
-            )
-        )
-    )
-
-
-def delegate_stake(params: DelegateStakeParams) -> TransactionInstruction:
-    """Creates an instruction to delegate a stake account."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.vote, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_config_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-        ],
-        program_id=STAKE_PROGRAM_ID,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DELEGATE_STAKE,
-                args=None,
-            )
-        )
-    )
-
-
-def authorize(params: AuthorizeParams) -> TransactionInstruction:
-    """Creates an instruction to change the authority on a stake account."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.authority, is_signer=True, is_writable=False),
-        ],
-        program_id=STAKE_PROGRAM_ID,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.AUTHORIZE,
-                args={
-                    'new_authority': bytes(params.new_authority),
-                    'stake_authorize': params.stake_authorize,
-                },
-            )
-        )
-    )
diff --git a/stake-pool/py/stake/state.py b/stake-pool/py/stake/state.py
deleted file mode 100644
index 8d8ac81f128..00000000000
--- a/stake-pool/py/stake/state.py
+++ /dev/null
@@ -1,132 +0,0 @@
-"""Stake State."""
-
-from enum import IntEnum
-from typing import NamedTuple, Dict
-from construct import Bytes, Container, Struct, Float64l, Int32ul, Int64ul  # type: ignore
-
-from solana.publickey import PublicKey
-from solana.utils.helpers import decode_byte_string
-
-PUBLIC_KEY_LAYOUT = Bytes(32)
-
-
-class Lockup(NamedTuple):
-    """Lockup for a stake account."""
-    unix_timestamp: int
-    epoch: int
-    custodian: PublicKey
-
-    @classmethod
-    def decode_container(cls, container: Container):
-        return Lockup(
-            unix_timestamp=container['unix_timestamp'],
-            epoch=container['epoch'],
-            custodian=PublicKey(container['custodian']),
-        )
-
-    def as_bytes_dict(self) -> Dict:
-        self_dict = self._asdict()
-        self_dict['custodian'] = bytes(self_dict['custodian'])
-        return self_dict
-
-
-class Authorized(NamedTuple):
-    """Define who is authorized to change a stake."""
-    staker: PublicKey
-    withdrawer: PublicKey
-
-    def as_bytes_dict(self) -> Dict:
-        return {
-            'staker': bytes(self.staker),
-            'withdrawer': bytes(self.withdrawer),
-        }
-
-
-class StakeAuthorize(IntEnum):
-    """Stake Authorization Types."""
-    STAKER = 0
-    WITHDRAWER = 1
-
-
-class StakeStakeType(IntEnum):
-    """Stake State Types."""
-    UNINITIALIZED = 0
-    INITIALIZED = 1
-    STAKE = 2
-    REWARDS_POOL = 3
-
-
-class StakeStake(NamedTuple):
-    state_type: StakeStakeType
-    state: Container
-
-    """Stake state."""
-    @classmethod
-    def decode(cls, data: str, encoding: str):
-        data_bytes = decode_byte_string(data, encoding)
-        parsed = STAKE_STATE_LAYOUT.parse(data_bytes)
-        return StakeStake(
-            state_type=parsed['state_type'],
-            state=parsed['state'],
-        )
-
-
-LOCKUP_LAYOUT = Struct(
-    "unix_timestamp" / Int64ul,
-    "epoch" / Int64ul,
-    "custodian" / PUBLIC_KEY_LAYOUT,
-)
-
-
-AUTHORIZED_LAYOUT = Struct(
-    "staker" / PUBLIC_KEY_LAYOUT,
-    "withdrawer" / PUBLIC_KEY_LAYOUT,
-)
-
-META_LAYOUT = Struct(
-    "rent_exempt_reserve" / Int64ul,
-    "authorized" / AUTHORIZED_LAYOUT,
-    "lockup" / LOCKUP_LAYOUT,
-)
-
-META_LAYOUT = Struct(
-    "rent_exempt_reserve" / Int64ul,
-    "authorized" / AUTHORIZED_LAYOUT,
-    "lockup" / LOCKUP_LAYOUT,
-)
-
-DELEGATION_LAYOUT = Struct(
-    "voter_pubkey" / PUBLIC_KEY_LAYOUT,
-    "stake" / Int64ul,
-    "activation_epoch" / Int64ul,
-    "deactivation_epoch" / Int64ul,
-    "warmup_cooldown_rate" / Float64l,
-)
-
-STAKE_LAYOUT = Struct(
-    "delegation" / DELEGATION_LAYOUT,
-    "credits_observed" / Int64ul,
-)
-
-STAKE_AND_META_LAYOUT = Struct(
-    "meta" / META_LAYOUT,
-    "stake" / STAKE_LAYOUT,
-)
-
-STAKE_STATE_LAYOUT = Struct(
-    "state_type" / Int32ul,
-    "state" / STAKE_AND_META_LAYOUT,
-    # NOTE: This can be done better, but was mainly needed for testing. Ideally,
-    # we would have something like:
-    #
-    # Switch(
-    #     lambda this: this.state,
-    #     {
-    #         StakeStakeType.UNINITIALIZED: Pass,
-    #         StakeStakeType.INITIALIZED: META_LAYOUT,
-    #         StakeStakeType.STAKE: STAKE_AND_META_LAYOUT,
-    #     }
-    # ),
-    #
-    # Unfortunately, it didn't work.
-)
diff --git a/stake-pool/py/stake_pool/__init__.py b/stake-pool/py/stake_pool/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/stake_pool/actions.py b/stake-pool/py/stake_pool/actions.py
deleted file mode 100644
index e44afba4d80..00000000000
--- a/stake-pool/py/stake_pool/actions.py
+++ /dev/null
@@ -1,749 +0,0 @@
-from typing import Optional, Tuple
-
-from solana.keypair import Keypair
-from solana.publickey import PublicKey
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-from solana.rpc.types import TxOpts
-from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY
-from solana.transaction import Transaction
-import solana.system_program as sys
-
-from spl.token.constants import TOKEN_PROGRAM_ID
-
-from stake.constants import STAKE_PROGRAM_ID, STAKE_LEN, SYSVAR_STAKE_CONFIG_ID
-import stake.instructions as st
-from stake.state import StakeAuthorize
-from stake_pool.constants import \
-    MAX_VALIDATORS_TO_UPDATE, \
-    MINIMUM_RESERVE_LAMPORTS, \
-    STAKE_POOL_PROGRAM_ID, \
-    METADATA_PROGRAM_ID, \
-    find_stake_program_address, \
-    find_transient_stake_program_address, \
-    find_withdraw_authority_program_address, \
-    find_metadata_account, \
-    find_ephemeral_stake_program_address
-from stake_pool.state import STAKE_POOL_LAYOUT, ValidatorList, Fee, StakePool
-import stake_pool.instructions as sp
-
-from stake.actions import create_stake
-from spl_token.actions import create_mint, create_associated_token_account
-
-
-async def create(client: AsyncClient, manager: Keypair,
-                 stake_pool: Keypair, validator_list: Keypair,
-                 pool_mint: PublicKey, reserve_stake: PublicKey,
-                 manager_fee_account: PublicKey, fee: Fee, referral_fee: int):
-    resp = await client.get_minimum_balance_for_rent_exemption(STAKE_POOL_LAYOUT.sizeof())
-    pool_balance = resp['result']
-    txn = Transaction()
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=manager.public_key,
-                new_account_pubkey=stake_pool.public_key,
-                lamports=pool_balance,
-                space=STAKE_POOL_LAYOUT.sizeof(),
-                program_id=STAKE_POOL_PROGRAM_ID,
-            )
-        )
-    )
-    max_validators = 2950  # current supported max by the program, go big!
-    validator_list_size = ValidatorList.calculate_validator_list_size(max_validators)
-    resp = await client.get_minimum_balance_for_rent_exemption(validator_list_size)
-    validator_list_balance = resp['result']
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=manager.public_key,
-                new_account_pubkey=validator_list.public_key,
-                lamports=validator_list_balance,
-                space=validator_list_size,
-                program_id=STAKE_POOL_PROGRAM_ID,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, manager, stake_pool, validator_list, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(
-        STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
-    txn = Transaction()
-    txn.add(
-        sp.initialize(
-            sp.InitializeParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool.public_key,
-                manager=manager.public_key,
-                staker=manager.public_key,
-                withdraw_authority=withdraw_authority,
-                validator_list=validator_list.public_key,
-                reserve_stake=reserve_stake,
-                pool_mint=pool_mint,
-                manager_fee_account=manager_fee_account,
-                token_program_id=TOKEN_PROGRAM_ID,
-                epoch_fee=fee,
-                withdrawal_fee=fee,
-                deposit_fee=fee,
-                referral_fee=referral_fee,
-                max_validators=max_validators,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, manager, validator_list, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def create_all(
-        client: AsyncClient, manager: Keypair, fee: Fee, referral_fee: int
-) -> Tuple[PublicKey, PublicKey, PublicKey]:
-    stake_pool = Keypair()
-    validator_list = Keypair()
-    (pool_withdraw_authority, seed) = find_withdraw_authority_program_address(
-        STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
-
-    reserve_stake = Keypair()
-    await create_stake(client, manager, reserve_stake, pool_withdraw_authority, MINIMUM_RESERVE_LAMPORTS)
-
-    pool_mint = Keypair()
-    await create_mint(client, manager, pool_mint, pool_withdraw_authority)
-
-    manager_fee_account = await create_associated_token_account(
-        client,
-        manager,
-        manager.public_key,
-        pool_mint.public_key,
-    )
-
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    await create(
-        client, manager, stake_pool, validator_list, pool_mint.public_key,
-        reserve_stake.public_key, manager_fee_account, fee, referral_fee)
-    return (stake_pool.public_key, validator_list.public_key, pool_mint.public_key)
-
-
-async def add_validator_to_pool(
-    client: AsyncClient, staker: Keypair,
-    stake_pool_address: PublicKey, validator: PublicKey
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    txn = Transaction()
-    txn.add(
-        sp.add_validator_to_pool_with_vote(
-            STAKE_POOL_PROGRAM_ID,
-            stake_pool_address,
-            stake_pool.staker,
-            stake_pool.validator_list,
-            stake_pool.reserve_stake,
-            validator,
-            None,
-        )
-    )
-    await client.send_transaction(
-        txn, staker, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def remove_validator_from_pool(
-    client: AsyncClient, staker: Keypair,
-    stake_pool_address: PublicKey, validator: PublicKey
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    validator_info = next(x for x in validator_list.validators if x.vote_account_address == validator)
-    txn = Transaction()
-    txn.add(
-        sp.remove_validator_from_pool_with_vote(
-            STAKE_POOL_PROGRAM_ID,
-            stake_pool_address,
-            stake_pool.staker,
-            stake_pool.validator_list,
-            validator,
-            validator_info.validator_seed_suffix or None,
-            validator_info.transient_seed_suffix,
-        )
-    )
-    await client.send_transaction(
-        txn, staker,
-        opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def deposit_sol(
-    client: AsyncClient, funder: Keypair, stake_pool_address: PublicKey,
-    destination_token_account: PublicKey, amount: int,
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-
-    txn = Transaction()
-    txn.add(
-        sp.deposit_sol(
-            sp.DepositSolParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                withdraw_authority=withdraw_authority,
-                reserve_stake=stake_pool.reserve_stake,
-                funding_account=funder.public_key,
-                destination_pool_account=destination_token_account,
-                manager_fee_account=stake_pool.manager_fee_account,
-                referral_pool_account=destination_token_account,
-                pool_mint=stake_pool.pool_mint,
-                system_program_id=sys.SYS_PROGRAM_ID,
-                token_program_id=stake_pool.token_program_id,
-                amount=amount,
-                deposit_authority=None,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, funder, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def withdraw_sol(
-    client: AsyncClient, owner: Keypair, source_token_account: PublicKey,
-    stake_pool_address: PublicKey, destination_system_account: PublicKey, amount: int,
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-
-    txn = Transaction()
-    txn.add(
-        sp.withdraw_sol(
-            sp.WithdrawSolParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                withdraw_authority=withdraw_authority,
-                source_transfer_authority=owner.public_key,
-                source_pool_account=source_token_account,
-                reserve_stake=stake_pool.reserve_stake,
-                destination_system_account=destination_system_account,
-                manager_fee_account=stake_pool.manager_fee_account,
-                pool_mint=stake_pool.pool_mint,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                stake_program_id=STAKE_PROGRAM_ID,
-                token_program_id=stake_pool.token_program_id,
-                amount=amount,
-                sol_withdraw_authority=None,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, owner, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def deposit_stake(
-    client: AsyncClient,
-    deposit_stake_authority: Keypair,
-    stake_pool_address: PublicKey,
-    validator_vote: PublicKey,
-    deposit_stake: PublicKey,
-    destination_pool_account: PublicKey,
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-
-    validator_info = next(x for x in validator_list.validators if x.vote_account_address == validator_vote)
-
-    (withdraw_authority, _) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-    (validator_stake, _) = find_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_vote,
-        stake_pool_address,
-        validator_info.validator_seed_suffix or None,
-    )
-
-    txn = Transaction()
-    txn.add(
-        st.authorize(
-            st.AuthorizeParams(
-                stake=deposit_stake,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                authority=deposit_stake_authority.public_key,
-                new_authority=stake_pool.stake_deposit_authority,
-                stake_authorize=StakeAuthorize.STAKER,
-            )
-        )
-    )
-    txn.add(
-        st.authorize(
-            st.AuthorizeParams(
-                stake=deposit_stake,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                authority=deposit_stake_authority.public_key,
-                new_authority=stake_pool.stake_deposit_authority,
-                stake_authorize=StakeAuthorize.WITHDRAWER,
-            )
-        )
-    )
-    txn.add(
-        sp.deposit_stake(
-            sp.DepositStakeParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                validator_list=stake_pool.validator_list,
-                deposit_authority=stake_pool.stake_deposit_authority,
-                withdraw_authority=withdraw_authority,
-                deposit_stake=deposit_stake,
-                validator_stake=validator_stake,
-                reserve_stake=stake_pool.reserve_stake,
-                destination_pool_account=destination_pool_account,
-                manager_fee_account=stake_pool.manager_fee_account,
-                referral_pool_account=destination_pool_account,
-                pool_mint=stake_pool.pool_mint,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                token_program_id=stake_pool.token_program_id,
-                stake_program_id=STAKE_PROGRAM_ID,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, deposit_stake_authority, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def withdraw_stake(
-    client: AsyncClient,
-    payer: Keypair,
-    source_transfer_authority: Keypair,
-    destination_stake: Keypair,
-    stake_pool_address: PublicKey,
-    validator_vote: PublicKey,
-    destination_stake_authority: PublicKey,
-    source_pool_account: PublicKey,
-    amount: int,
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-
-    validator_info = next(x for x in validator_list.validators if x.vote_account_address == validator_vote)
-
-    (withdraw_authority, _) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-    (validator_stake, _) = find_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_vote,
-        stake_pool_address,
-        validator_info.validator_seed_suffix or None,
-    )
-
-    resp = await client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-
-    txn = Transaction()
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=payer.public_key,
-                new_account_pubkey=destination_stake.public_key,
-                lamports=stake_rent_exemption,
-                space=STAKE_LEN,
-                program_id=STAKE_PROGRAM_ID,
-            )
-        )
-    )
-    txn.add(
-        sp.withdraw_stake(
-            sp.WithdrawStakeParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                validator_list=stake_pool.validator_list,
-                withdraw_authority=withdraw_authority,
-                validator_stake=validator_stake,
-                destination_stake=destination_stake.public_key,
-                destination_stake_authority=destination_stake_authority,
-                source_transfer_authority=source_transfer_authority.public_key,
-                source_pool_account=source_pool_account,
-                manager_fee_account=stake_pool.manager_fee_account,
-                pool_mint=stake_pool.pool_mint,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                token_program_id=stake_pool.token_program_id,
-                stake_program_id=STAKE_PROGRAM_ID,
-                amount=amount,
-            )
-        )
-    )
-    signers = [payer, source_transfer_authority, destination_stake] \
-        if payer != source_transfer_authority else [payer, destination_stake]
-    await client.send_transaction(
-        txn, *signers, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def update_stake_pool(client: AsyncClient, payer: Keypair, stake_pool_address: PublicKey):
-    """Create and send all instructions to completely update a stake pool after epoch change."""
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-    update_list_instructions = []
-    validator_chunks = [
-        validator_list.validators[i:i+MAX_VALIDATORS_TO_UPDATE]
-        for i in range(0, len(validator_list.validators), MAX_VALIDATORS_TO_UPDATE)
-    ]
-    start_index = 0
-    for validator_chunk in validator_chunks:
-        validator_and_transient_stake_pairs = []
-        for validator in validator_chunk:
-            (validator_stake_address, _) = find_stake_program_address(
-                STAKE_POOL_PROGRAM_ID,
-                validator.vote_account_address,
-                stake_pool_address,
-                validator.validator_seed_suffix or None,
-            )
-            validator_and_transient_stake_pairs.append(validator_stake_address)
-            (transient_stake_address, _) = find_transient_stake_program_address(
-                STAKE_POOL_PROGRAM_ID,
-                validator.vote_account_address,
-                stake_pool_address,
-                validator.transient_seed_suffix,
-            )
-            validator_and_transient_stake_pairs.append(transient_stake_address)
-        update_list_instructions.append(
-            sp.update_validator_list_balance(
-                sp.UpdateValidatorListBalanceParams(
-                    program_id=STAKE_POOL_PROGRAM_ID,
-                    stake_pool=stake_pool_address,
-                    withdraw_authority=withdraw_authority,
-                    validator_list=stake_pool.validator_list,
-                    reserve_stake=stake_pool.reserve_stake,
-                    clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                    stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                    stake_program_id=STAKE_PROGRAM_ID,
-                    validator_and_transient_stake_pairs=validator_and_transient_stake_pairs,
-                    start_index=start_index,
-                    no_merge=False,
-                )
-            )
-        )
-        start_index += MAX_VALIDATORS_TO_UPDATE
-    if update_list_instructions:
-        last_instruction = update_list_instructions.pop()
-        for update_list_instruction in update_list_instructions:
-            txn = Transaction()
-            txn.add(update_list_instruction)
-            await client.send_transaction(
-                txn, payer, opts=TxOpts(skip_confirmation=True, preflight_commitment=Confirmed))
-        txn = Transaction()
-        txn.add(last_instruction)
-        await client.send_transaction(
-            txn, payer, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-    txn = Transaction()
-    txn.add(
-        sp.update_stake_pool_balance(
-            sp.UpdateStakePoolBalanceParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                withdraw_authority=withdraw_authority,
-                validator_list=stake_pool.validator_list,
-                reserve_stake=stake_pool.reserve_stake,
-                manager_fee_account=stake_pool.manager_fee_account,
-                pool_mint=stake_pool.pool_mint,
-                token_program_id=stake_pool.token_program_id,
-            )
-        )
-    )
-    txn.add(
-        sp.cleanup_removed_validator_entries(
-            sp.CleanupRemovedValidatorEntriesParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                validator_list=stake_pool.validator_list,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, payer, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def increase_validator_stake(
-    client: AsyncClient,
-    payer: Keypair,
-    staker: Keypair,
-    stake_pool_address: PublicKey,
-    validator_vote: PublicKey,
-    lamports: int,
-    ephemeral_stake_seed: Optional[int] = None
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-
-    validator_info = next(x for x in validator_list.validators if x.vote_account_address == validator_vote)
-
-    if ephemeral_stake_seed is None:
-        transient_stake_seed = validator_info.transient_seed_suffix + 1  # bump up by one to avoid reuse
-    else:
-        # we are updating an existing transient stake account, so we must use the same seed
-        transient_stake_seed = validator_info.transient_seed_suffix
-
-    validator_stake_seed = validator_info.validator_seed_suffix or None
-    (transient_stake, _) = find_transient_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_info.vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    )
-    (validator_stake, _) = find_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_info.vote_account_address,
-        stake_pool_address,
-        validator_stake_seed
-    )
-
-    txn = Transaction()
-    if ephemeral_stake_seed is not None:
-
-        # We assume there is an existing transient account that we will update
-        (ephemeral_stake, _) = find_ephemeral_stake_program_address(
-            STAKE_POOL_PROGRAM_ID,
-            stake_pool_address,
-            ephemeral_stake_seed)
-
-        txn.add(
-            sp.increase_additional_validator_stake(
-                sp.IncreaseAdditionalValidatorStakeParams(
-                    program_id=STAKE_POOL_PROGRAM_ID,
-                    stake_pool=stake_pool_address,
-                    staker=staker.public_key,
-                    withdraw_authority=withdraw_authority,
-                    validator_list=stake_pool.validator_list,
-                    reserve_stake=stake_pool.reserve_stake,
-                    transient_stake=transient_stake,
-                    validator_stake=validator_stake,
-                    validator_vote=validator_vote,
-                    clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                    rent_sysvar=SYSVAR_RENT_PUBKEY,
-                    stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                    stake_config_sysvar=SYSVAR_STAKE_CONFIG_ID,
-                    system_program_id=sys.SYS_PROGRAM_ID,
-                    stake_program_id=STAKE_PROGRAM_ID,
-                    lamports=lamports,
-                    transient_stake_seed=transient_stake_seed,
-                    ephemeral_stake=ephemeral_stake,
-                    ephemeral_stake_seed=ephemeral_stake_seed
-                )
-            )
-        )
-
-    else:
-        txn.add(
-            sp.increase_validator_stake(
-                sp.IncreaseValidatorStakeParams(
-                    program_id=STAKE_POOL_PROGRAM_ID,
-                    stake_pool=stake_pool_address,
-                    staker=staker.public_key,
-                    withdraw_authority=withdraw_authority,
-                    validator_list=stake_pool.validator_list,
-                    reserve_stake=stake_pool.reserve_stake,
-                    transient_stake=transient_stake,
-                    validator_stake=validator_stake,
-                    validator_vote=validator_vote,
-                    clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                    rent_sysvar=SYSVAR_RENT_PUBKEY,
-                    stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                    stake_config_sysvar=SYSVAR_STAKE_CONFIG_ID,
-                    system_program_id=sys.SYS_PROGRAM_ID,
-                    stake_program_id=STAKE_PROGRAM_ID,
-                    lamports=lamports,
-                    transient_stake_seed=transient_stake_seed,
-                )
-            )
-        )
-
-    signers = [payer, staker] if payer != staker else [payer]
-    await client.send_transaction(
-        txn, *signers, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def decrease_validator_stake(
-    client: AsyncClient,
-    payer: Keypair,
-    staker: Keypair,
-    stake_pool_address: PublicKey,
-    validator_vote: PublicKey,
-    lamports: int,
-    ephemeral_stake_seed: Optional[int] = None
-):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    resp = await client.get_account_info(stake_pool.validator_list, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-
-    validator_info = next(x for x in validator_list.validators if x.vote_account_address == validator_vote)
-    validator_stake_seed = validator_info.validator_seed_suffix or None
-    (validator_stake, _) = find_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_info.vote_account_address,
-        stake_pool_address,
-        validator_stake_seed,
-    )
-
-    if ephemeral_stake_seed is None:
-        transient_stake_seed = validator_info.transient_seed_suffix + 1  # bump up by one to avoid reuse
-    else:
-        # we are updating an existing transient stake account, so we must use the same seed
-        transient_stake_seed = validator_info.transient_seed_suffix
-
-    (transient_stake, _) = find_transient_stake_program_address(
-        STAKE_POOL_PROGRAM_ID,
-        validator_info.vote_account_address,
-        stake_pool_address,
-        transient_stake_seed,
-    )
-
-    txn = Transaction()
-
-    if ephemeral_stake_seed is not None:
-
-        # We assume there is an existing transient account that we will update
-        (ephemeral_stake, _) = find_ephemeral_stake_program_address(
-            STAKE_POOL_PROGRAM_ID,
-            stake_pool_address,
-            ephemeral_stake_seed)
-
-        txn.add(
-            sp.decrease_additional_validator_stake(
-                sp.DecreaseAdditionalValidatorStakeParams(
-                    program_id=STAKE_POOL_PROGRAM_ID,
-                    stake_pool=stake_pool_address,
-                    staker=staker.public_key,
-                    withdraw_authority=withdraw_authority,
-                    validator_list=stake_pool.validator_list,
-                    reserve_stake=stake_pool.reserve_stake,
-                    validator_stake=validator_stake,
-                    transient_stake=transient_stake,
-                    clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                    rent_sysvar=SYSVAR_RENT_PUBKEY,
-                    stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                    system_program_id=sys.SYS_PROGRAM_ID,
-                    stake_program_id=STAKE_PROGRAM_ID,
-                    lamports=lamports,
-                    transient_stake_seed=transient_stake_seed,
-                    ephemeral_stake=ephemeral_stake,
-                    ephemeral_stake_seed=ephemeral_stake_seed
-                )
-            )
-        )
-
-    else:
-
-        txn.add(
-            sp.decrease_validator_stake_with_reserve(
-                sp.DecreaseValidatorStakeWithReserveParams(
-                    program_id=STAKE_POOL_PROGRAM_ID,
-                    stake_pool=stake_pool_address,
-                    staker=staker.public_key,
-                    withdraw_authority=withdraw_authority,
-                    validator_list=stake_pool.validator_list,
-                    reserve_stake=stake_pool.reserve_stake,
-                    validator_stake=validator_stake,
-                    transient_stake=transient_stake,
-                    clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                    stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-                    system_program_id=sys.SYS_PROGRAM_ID,
-                    stake_program_id=STAKE_PROGRAM_ID,
-                    lamports=lamports,
-                    transient_stake_seed=transient_stake_seed,
-                )
-            )
-        )
-
-    signers = [payer, staker] if payer != staker else [payer]
-    await client.send_transaction(
-        txn, *signers, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def create_token_metadata(client: AsyncClient, payer: Keypair, stake_pool_address: PublicKey,
-                                name: str, symbol: str, uri: str):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    (withdraw_authority, _seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-    (token_metadata, _seed) = find_metadata_account(stake_pool.pool_mint)
-
-    txn = Transaction()
-    txn.add(
-        sp.create_token_metadata(
-            sp.CreateTokenMetadataParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                manager=stake_pool.manager,
-                pool_mint=stake_pool.pool_mint,
-                payer=payer.public_key,
-                name=name,
-                symbol=symbol,
-                uri=uri,
-                withdraw_authority=withdraw_authority,
-                token_metadata=token_metadata,
-                metadata_program_id=METADATA_PROGRAM_ID,
-                system_program_id=sys.SYS_PROGRAM_ID,
-            )
-        )
-    )
-
-    await client.send_transaction(txn, payer, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
-
-
-async def update_token_metadata(client: AsyncClient, payer: Keypair, stake_pool_address: PublicKey,
-                                name: str, symbol: str, uri: str):
-    resp = await client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    (withdraw_authority, _seed) = find_withdraw_authority_program_address(STAKE_POOL_PROGRAM_ID, stake_pool_address)
-    (token_metadata, _seed) = find_metadata_account(stake_pool.pool_mint)
-
-    txn = Transaction()
-    txn.add(
-        sp.update_token_metadata(
-            sp.UpdateTokenMetadataParams(
-                program_id=STAKE_POOL_PROGRAM_ID,
-                stake_pool=stake_pool_address,
-                manager=stake_pool.manager,
-                pool_mint=stake_pool.pool_mint,
-                name=name,
-                symbol=symbol,
-                uri=uri,
-                withdraw_authority=withdraw_authority,
-                token_metadata=token_metadata,
-                metadata_program_id=METADATA_PROGRAM_ID,
-            )
-        )
-    )
-
-    await client.send_transaction(txn, payer, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
diff --git a/stake-pool/py/stake_pool/constants.py b/stake-pool/py/stake_pool/constants.py
deleted file mode 100644
index ff1f1dbe2f3..00000000000
--- a/stake-pool/py/stake_pool/constants.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""SPL Stake Pool Constants."""
-
-from typing import Optional, Tuple
-
-from solana.publickey import PublicKey
-from stake.constants import MINIMUM_DELEGATION
-
-STAKE_POOL_PROGRAM_ID: PublicKey = PublicKey("SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy")
-"""Public key that identifies the SPL Stake Pool program."""
-
-MAX_VALIDATORS_TO_UPDATE: int = 5
-"""Maximum number of validators to update during UpdateValidatorListBalance."""
-
-MINIMUM_RESERVE_LAMPORTS: int = 0
-"""Minimum balance required in the stake pool reserve"""
-
-MINIMUM_ACTIVE_STAKE: int = MINIMUM_DELEGATION
-"""Minimum active delegated staked required in a stake account"""
-
-METADATA_PROGRAM_ID: PublicKey = PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
-"""Public key that identifies the Metaplex Token Metadata program."""
-
-
-def find_deposit_authority_program_address(
-    program_id: PublicKey,
-    stake_pool_address: PublicKey,
-) -> Tuple[PublicKey, int]:
-    """Generates the deposit authority program address for the stake pool"""
-    return PublicKey.find_program_address(
-        [bytes(stake_pool_address), AUTHORITY_DEPOSIT],
-        program_id,
-    )
-
-
-def find_withdraw_authority_program_address(
-    program_id: PublicKey,
-    stake_pool_address: PublicKey,
-) -> Tuple[PublicKey, int]:
-    """Generates the withdraw authority program address for the stake pool"""
-    return PublicKey.find_program_address(
-        [bytes(stake_pool_address), AUTHORITY_WITHDRAW],
-        program_id,
-    )
-
-
-def find_stake_program_address(
-    program_id: PublicKey,
-    vote_account_address: PublicKey,
-    stake_pool_address: PublicKey,
-    seed: Optional[int]
-) -> Tuple[PublicKey, int]:
-    """Generates the stake program address for a validator's vote account"""
-    return PublicKey.find_program_address(
-        [
-            bytes(vote_account_address),
-            bytes(stake_pool_address),
-            seed.to_bytes(4, 'little') if seed else bytes(),
-        ],
-        program_id,
-    )
-
-
-def find_transient_stake_program_address(
-    program_id: PublicKey,
-    vote_account_address: PublicKey,
-    stake_pool_address: PublicKey,
-    seed: int,
-) -> Tuple[PublicKey, int]:
-    """Generates the stake program address for a validator's vote account"""
-    return PublicKey.find_program_address(
-        [
-            TRANSIENT_STAKE_SEED_PREFIX,
-            bytes(vote_account_address),
-            bytes(stake_pool_address),
-            seed.to_bytes(8, 'little'),
-        ],
-        program_id,
-    )
-
-
-def find_ephemeral_stake_program_address(
-    program_id: PublicKey,
-    stake_pool_address: PublicKey,
-    seed: int
-) -> Tuple[PublicKey, int]:
-
-    """Generates the ephemeral program address for stake pool redelegation"""
-    return PublicKey.find_program_address(
-        [
-            EPHEMERAL_STAKE_SEED_PREFIX,
-            bytes(stake_pool_address),
-            seed.to_bytes(8, 'little'),
-        ],
-        program_id,
-    )
-
-
-def find_metadata_account(
-    mint_key: PublicKey
-) -> Tuple[PublicKey, int]:
-    """Generates the metadata account program address"""
-    return PublicKey.find_program_address(
-        [
-            METADATA_SEED_PREFIX,
-            bytes(METADATA_PROGRAM_ID),
-            bytes(mint_key)
-        ],
-        METADATA_PROGRAM_ID
-    )
-
-
-AUTHORITY_DEPOSIT = b"deposit"
-"""Seed used to derive the default stake pool deposit authority."""
-AUTHORITY_WITHDRAW = b"withdraw"
-"""Seed used to derive the stake pool withdraw authority."""
-TRANSIENT_STAKE_SEED_PREFIX = b"transient"
-"""Seed used to derive transient stake accounts."""
-METADATA_SEED_PREFIX = b"metadata"
-"""Seed used to avoid certain collision attacks."""
-EPHEMERAL_STAKE_SEED_PREFIX = b'ephemeral'
-"""Seed for ephemeral stake account"""
diff --git a/stake-pool/py/stake_pool/instructions.py b/stake-pool/py/stake_pool/instructions.py
deleted file mode 100644
index 8a3ae4cf5f3..00000000000
--- a/stake-pool/py/stake_pool/instructions.py
+++ /dev/null
@@ -1,1277 +0,0 @@
-"""SPL Stake Pool Instructions."""
-
-from enum import IntEnum
-from typing import List, NamedTuple, Optional
-from construct import Prefixed, GreedyString, Struct, Switch, Int8ul, Int32ul, Int64ul, Pass  # type: ignore
-
-from solana.publickey import PublicKey
-from solana.transaction import AccountMeta, TransactionInstruction
-from solana.system_program import SYS_PROGRAM_ID
-from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY
-from spl.token.constants import TOKEN_PROGRAM_ID
-
-from stake.constants import STAKE_PROGRAM_ID, SYSVAR_STAKE_CONFIG_ID
-from stake_pool.constants import find_stake_program_address, find_transient_stake_program_address
-from stake_pool.constants import find_withdraw_authority_program_address
-from stake_pool.constants import STAKE_POOL_PROGRAM_ID
-from stake_pool.state import Fee, FEE_LAYOUT
-
-
-class PreferredValidatorType(IntEnum):
-    """Specifies the validator type for SetPreferredValidator instruction."""
-
-    DEPOSIT = 0
-    """Specifies the preferred deposit validator."""
-    WITHDRAW = 1
-    """Specifies the preferred withdraw validator."""
-
-
-class FundingType(IntEnum):
-    """Defines which authority to update in the `SetFundingAuthority` instruction."""
-
-    STAKE_DEPOSIT = 0
-    """Sets the stake deposit authority."""
-    SOL_DEPOSIT = 1
-    """Sets the SOL deposit authority."""
-    SOL_WITHDRAW = 2
-    """Sets the SOL withdraw authority."""
-
-
-class InitializeParams(NamedTuple):
-    """Initialize token mint transaction params."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """[w] Stake Pool account to initialize."""
-    manager: PublicKey
-    """[s] Manager for new stake pool."""
-    staker: PublicKey
-    """[] Staker for the new stake pool."""
-    withdraw_authority: PublicKey
-    """[] Withdraw authority for the new stake pool."""
-    validator_list: PublicKey
-    """[w] Uninitialized validator list account for the new stake pool."""
-    reserve_stake: PublicKey
-    """[] Reserve stake account."""
-    pool_mint: PublicKey
-    """[w] Pool token mint account."""
-    manager_fee_account: PublicKey
-    """[w] Manager's fee account"""
-    token_program_id: PublicKey
-    """[] SPL Token program id."""
-
-    # Params
-    epoch_fee: Fee
-    """Fee assessed as percentage of rewards."""
-    withdrawal_fee: Fee
-    """Fee charged per withdrawal."""
-    deposit_fee: Fee
-    """Fee charged per deposit."""
-    referral_fee: int
-    """Percentage [0-100] of deposit fee that goes to referrer."""
-    max_validators: int
-    """Maximum number of possible validators in the pool."""
-
-    # Optional
-    deposit_authority: Optional[PublicKey] = None
-    """[] Optional deposit authority that must sign all deposits."""
-
-
-class AddValidatorToPoolParams(NamedTuple):
-    """(Staker only) Adds stake account delegated to validator to the pool's list of managed validators."""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    reserve_stake: PublicKey
-    """`[w]` Reserve stake account."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    validator_stake: PublicKey
-    """`[w]` Stake account to add to the pool."""
-    validator_vote: PublicKey
-    """`[]` Validator this stake account will be delegated to."""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    stake_config_sysvar: PublicKey
-    """'[]' Stake config sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    seed: Optional[int]
-    """Seed to used to create the validator stake account."""
-
-
-class RemoveValidatorFromPoolParams(NamedTuple):
-    """(Staker only) Removes validator from the pool."""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    validator_stake: PublicKey
-    """`[w]` Stake account to remove from the pool."""
-    transient_stake: PublicKey
-    """`[]` Transient stake account, to check that there's no activation ongoing."""
-    clock_sysvar: PublicKey
-    """'[]' Stake config sysvar."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-
-class DecreaseValidatorStakeParams(NamedTuple):
-    """(Staker only) Decrease active stake on a validator, eventually moving it to the reserve"""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    validator_stake: PublicKey
-    """`[w]` Canonical stake to split from."""
-    transient_stake: PublicKey
-    """`[w]` Transient stake account to receive split."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    lamports: int
-    """Amount of lamports to split into the transient stake account."""
-    transient_stake_seed: int
-    """Seed to used to create the transient stake account."""
-
-
-class DecreaseValidatorStakeWithReserveParams(NamedTuple):
-    """(Staker only) Decrease active stake on a validator, eventually moving it to the reserve"""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    validator_stake: PublicKey
-    """`[w]` Canonical stake to split from."""
-    transient_stake: PublicKey
-    """`[w]` Transient stake account to receive split."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    lamports: int
-    """Amount of lamports to split into the transient stake account."""
-    transient_stake_seed: int
-    """Seed to used to create the transient stake account."""
-
-
-class IncreaseValidatorStakeParams(NamedTuple):
-    """(Staker only) Increase stake on a validator from the reserve account."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    transient_stake: PublicKey
-    """`[w]` Transient stake account to receive split."""
-    validator_stake: PublicKey
-    """`[]` Canonical stake account to check."""
-    validator_vote: PublicKey
-    """`[]` Validator vote account to delegate to."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    stake_config_sysvar: PublicKey
-    """'[]' Stake config sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    lamports: int
-    """Amount of lamports to split into the transient stake account."""
-    transient_stake_seed: int
-    """Seed to used to create the transient stake account."""
-
-
-class SetPreferredValidatorParams(NamedTuple):
-    pass
-
-
-class UpdateValidatorListBalanceParams(NamedTuple):
-    """Updates balances of validator and transient stake accounts in the pool."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-    validator_and_transient_stake_pairs: List[PublicKey]
-    """[] N pairs of validator and transient stake accounts"""
-
-    # Params
-    start_index: int
-    """Index to start updating on the validator list."""
-    no_merge: bool
-    """If true, don't try merging transient stake accounts."""
-
-
-class UpdateStakePoolBalanceParams(NamedTuple):
-    """Updates total pool balance based on balances in the reserve and validator list."""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    manager_fee_account: PublicKey
-    """`[w]` Account to receive pool fee tokens."""
-    pool_mint: PublicKey
-    """`[w]` Pool mint account."""
-    token_program_id: PublicKey
-    """`[]` Pool token program."""
-
-
-class CleanupRemovedValidatorEntriesParams(NamedTuple):
-    """Cleans up validator stake account entries marked as `ReadyForRemoval`"""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-
-
-class DepositStakeParams(NamedTuple):
-    """Deposits a stake account into the pool in exchange for pool tokens"""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool"""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account"""
-    deposit_authority: PublicKey
-    """`[s]/[]` Stake pool deposit authority"""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority"""
-    deposit_stake: PublicKey
-    """`[w]` Stake account to join the pool (stake's withdraw authority set to the stake pool deposit authority)"""
-    validator_stake: PublicKey
-    """`[w]` Validator stake account for the stake account to be merged with"""
-    reserve_stake: PublicKey
-    """`[w]` Reserve stake account, to withdraw rent exempt reserve"""
-    destination_pool_account: PublicKey
-    """`[w]` User account to receive pool tokens"""
-    manager_fee_account: PublicKey
-    """`[w]` Account to receive pool fee tokens"""
-    referral_pool_account: PublicKey
-    """`[w]` Account to receive a portion of pool fee tokens as referral fees"""
-    pool_mint: PublicKey
-    """`[w]` Pool token mint account"""
-    clock_sysvar: PublicKey
-    """`[]` Sysvar clock account"""
-    stake_history_sysvar: PublicKey
-    """`[]` Sysvar stake history account"""
-    token_program_id: PublicKey
-    """`[]` Pool token program id"""
-    stake_program_id: PublicKey
-    """`[]` Stake program id"""
-
-
-class WithdrawStakeParams(NamedTuple):
-    """Withdraws a stake account from the pool in exchange for pool tokens"""
-
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool"""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account"""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority"""
-    validator_stake: PublicKey
-    """`[w]` Validator or reserve stake account to split"""
-    destination_stake: PublicKey
-    """`[w]` Unitialized stake account to receive withdrawal"""
-    destination_stake_authority: PublicKey
-    """`[]` User account to set as a new withdraw authority"""
-    source_transfer_authority: PublicKey
-    """`[s]` User transfer authority, for pool token account"""
-    source_pool_account: PublicKey
-    """`[w]` User account with pool tokens to burn from"""
-    manager_fee_account: PublicKey
-    """`[w]` Account to receive pool fee tokens"""
-    pool_mint: PublicKey
-    """`[w]` Pool token mint account"""
-    clock_sysvar: PublicKey
-    """`[]` Sysvar clock account"""
-    token_program_id: PublicKey
-    """`[]` Pool token program id"""
-    stake_program_id: PublicKey
-    """`[]` Stake program id"""
-
-    # Params
-    amount: int
-    """Amount of pool tokens to burn in exchange for stake"""
-
-
-class SetManagerParams(NamedTuple):
-    pass
-
-
-class SetFeeParams(NamedTuple):
-    pass
-
-
-class SetStakerParams(NamedTuple):
-    pass
-
-
-class DepositSolParams(NamedTuple):
-    """Deposit SOL directly into the pool's reserve account. The output is a "pool" token
-    representing ownership into the pool. Inputs are converted to the current ratio."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    funding_account: PublicKey
-    """`[ws]` Funding account (must be a system account)."""
-    destination_pool_account: PublicKey
-    """`[w]` User account to receive pool tokens."""
-    manager_fee_account: PublicKey
-    """`[w]` Manager's pool token account to receive deposit fee."""
-    referral_pool_account: PublicKey
-    """`[w]` Referrer pool token account to receive referral fee."""
-    pool_mint: PublicKey
-    """`[w]` Pool token mint."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    token_program_id: PublicKey
-    """`[]` Token program."""
-
-    # Params
-    amount: int
-    """Amount of SOL to deposit"""
-
-    # Optional
-    deposit_authority: Optional[PublicKey] = None
-    """`[s]` (Optional) Stake pool sol deposit authority."""
-
-
-class SetFundingAuthorityParams(NamedTuple):
-    pass
-
-
-class WithdrawSolParams(NamedTuple):
-    """Withdraw SOL directly from the pool's reserve account."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[w]` Stake pool."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    source_transfer_authority: PublicKey
-    """`[s]` Transfer authority for user pool token account."""
-    source_pool_account: PublicKey
-    """`[w]` User's pool token account to burn pool tokens."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    destination_system_account: PublicKey
-    """`[w]` Destination system account to receive lamports from the reserve."""
-    manager_fee_account: PublicKey
-    """`[w]` Manager's pool token account to receive fee."""
-    pool_mint: PublicKey
-    """`[w]` Pool token mint."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-    token_program_id: PublicKey
-    """`[]` Token program."""
-
-    # Params
-    amount: int
-    """Amount of pool tokens to burn"""
-
-    # Optional
-    sol_withdraw_authority: Optional[PublicKey] = None
-    """`[s]` (Optional) Stake pool sol withdraw authority."""
-
-
-class CreateTokenMetadataParams(NamedTuple):
-    """Create token metadata for the stake-pool token in the metaplex-token program."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    manager: PublicKey
-    """`[s]` Manager."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    pool_mint: PublicKey
-    """`[]` Pool token mint account."""
-    payer: PublicKey
-    """`[s, w]` Payer for creation of token metadata account."""
-    token_metadata: PublicKey
-    """`[w]` Token metadata program account."""
-    metadata_program_id: PublicKey
-    """`[]` Metadata program id"""
-    system_program_id: PublicKey
-    """`[]` System program id"""
-
-    # Params
-    name: str
-    """Token name."""
-    symbol: str
-    """Token symbol e.g. stkSOL."""
-    uri: str
-    """URI of the uploaded metadata of the spl-token."""
-
-
-class UpdateTokenMetadataParams(NamedTuple):
-    """Update token metadata for the stake-pool token in the metaplex-token program."""
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    manager: PublicKey
-    """`[s]` Manager."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    pool_mint: PublicKey
-    """`[]` Pool token mint account."""
-    token_metadata: PublicKey
-    """`[w]` Token metadata program account."""
-    metadata_program_id: PublicKey
-    """`[]` Metadata program id"""
-
-    # Params
-    name: str
-    """Token name."""
-    symbol: str
-    """Token symbol e.g. stkSOL."""
-    uri: str
-    """URI of the uploaded metadata of the spl-token."""
-
-
-class IncreaseAdditionalValidatorStakeParams(NamedTuple):
-    """(Staker only) Increase stake on a validator from the reserve account."""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """`[w]` Stake pool's reserve."""
-    ephemeral_stake: PublicKey
-    """The ephemeral stake account used during the operation."""
-    transient_stake: PublicKey
-    """`[w]` Transient stake account to receive split."""
-    validator_stake: PublicKey
-    """`[]` Canonical stake account to check."""
-    validator_vote: PublicKey
-    """`[]` Validator vote account to delegate to."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    stake_config_sysvar: PublicKey
-    """'[]' Stake config sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    lamports: int
-    """Amount of lamports to increase on the given validator."""
-    transient_stake_seed: int
-    """Seed to used to create the transient stake account."""
-    ephemeral_stake_seed: int
-    """The seed used to generate the ephemeral stake account"""
-
-
-class DecreaseAdditionalValidatorStakeParams(NamedTuple):
-    """(Staker only) Decrease active stake on a validator, eventually moving it to the reserve"""
-
-    # Accounts
-    program_id: PublicKey
-    """SPL Stake Pool program account."""
-    stake_pool: PublicKey
-    """`[]` Stake pool."""
-    staker: PublicKey
-    """`[s]` Staker."""
-    withdraw_authority: PublicKey
-    """`[]` Stake pool withdraw authority."""
-    validator_list: PublicKey
-    """`[w]` Validator stake list storage account."""
-    reserve_stake: PublicKey
-    """The reserve stake account to move the stake to."""
-    validator_stake: PublicKey
-    """`[w]` Canonical stake to split from."""
-    ephemeral_stake: PublicKey
-    """The ephemeral stake account used during the operation."""
-    transient_stake: PublicKey
-    """`[w]` Transient stake account to receive split."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    stake_history_sysvar: PublicKey
-    """'[]' Stake history sysvar."""
-    system_program_id: PublicKey
-    """`[]` System program."""
-    stake_program_id: PublicKey
-    """`[]` Stake program."""
-
-    # Params
-    lamports: int
-    """Amount of lamports to split into the transient stake account."""
-    transient_stake_seed: int
-    """Seed to used to create the transient stake account."""
-    ephemeral_stake_seed: int
-    """The seed used to generate the ephemeral stake account"""
-
-
-class InstructionType(IntEnum):
-    """Stake Pool Instruction Types."""
-
-    INITIALIZE = 0
-    ADD_VALIDATOR_TO_POOL = 1
-    REMOVE_VALIDATOR_FROM_POOL = 2
-    DECREASE_VALIDATOR_STAKE = 3
-    INCREASE_VALIDATOR_STAKE = 4
-    SET_PREFERRED_VALIDATOR = 5
-    UPDATE_VALIDATOR_LIST_BALANCE = 6
-    UPDATE_STAKE_POOL_BALANCE = 7
-    CLEANUP_REMOVED_VALIDATOR_ENTRIES = 8
-    DEPOSIT_STAKE = 9
-    WITHDRAW_STAKE = 10
-    SET_MANAGER = 11
-    SET_FEE = 12
-    SET_STAKER = 13
-    DEPOSIT_SOL = 14
-    SET_FUNDING_AUTHORITY = 15
-    WITHDRAW_SOL = 16
-    CREATE_TOKEN_METADATA = 17
-    UPDATE_TOKEN_METADATA = 18
-    INCREASE_ADDITIONAL_VALIDATOR_STAKE = 19
-    DECREASE_ADDITIONAL_VALIDATOR_STAKE = 20
-    DECREASE_VALIDATOR_STAKE_WITH_RESERVE = 21
-    REDELEGATE = 22
-
-
-INITIALIZE_LAYOUT = Struct(
-    "epoch_fee" / FEE_LAYOUT,
-    "withdrawal_fee" / FEE_LAYOUT,
-    "deposit_fee" / FEE_LAYOUT,
-    "referral_fee" / Int8ul,
-    "max_validators" / Int32ul,
-)
-
-MOVE_STAKE_LAYOUT = Struct(
-    "lamports" / Int64ul,
-    "transient_stake_seed" / Int64ul,
-)
-
-MOVE_STAKE_LAYOUT_WITH_EPHEMERAL_STAKE = Struct(
-    "lamports" / Int64ul,
-    "transient_stake_seed" / Int64ul,
-    "ephemeral_stake_seed" / Int64ul,
-)
-
-UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT = Struct(
-    "start_index" / Int32ul,
-    "no_merge" / Int8ul,
-)
-
-AMOUNT_LAYOUT = Struct(
-    "amount" / Int64ul
-)
-
-SEED_LAYOUT = Struct(
-    "seed" / Int32ul
-)
-
-TOKEN_METADATA_LAYOUT = Struct(
-    "name" / Prefixed(Int32ul, GreedyString("utf8")),
-    "symbol" / Prefixed(Int32ul, GreedyString("utf8")),
-    "uri" / Prefixed(Int32ul, GreedyString("utf8"))
-)
-
-INSTRUCTIONS_LAYOUT = Struct(
-    "instruction_type" / Int8ul,
-    "args"
-    / Switch(
-        lambda this: this.instruction_type,
-        {
-            InstructionType.INITIALIZE: INITIALIZE_LAYOUT,
-            InstructionType.ADD_VALIDATOR_TO_POOL: SEED_LAYOUT,
-            InstructionType.REMOVE_VALIDATOR_FROM_POOL: Pass,
-            InstructionType.DECREASE_VALIDATOR_STAKE: MOVE_STAKE_LAYOUT,
-            InstructionType.INCREASE_VALIDATOR_STAKE: MOVE_STAKE_LAYOUT,
-            InstructionType.SET_PREFERRED_VALIDATOR: Pass,  # TODO
-            InstructionType.UPDATE_VALIDATOR_LIST_BALANCE: UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT,
-            InstructionType.UPDATE_STAKE_POOL_BALANCE: Pass,
-            InstructionType.CLEANUP_REMOVED_VALIDATOR_ENTRIES: Pass,
-            InstructionType.DEPOSIT_STAKE: Pass,
-            InstructionType.WITHDRAW_STAKE: AMOUNT_LAYOUT,
-            InstructionType.SET_MANAGER: Pass,  # TODO
-            InstructionType.SET_FEE: Pass,  # TODO
-            InstructionType.SET_STAKER: Pass,  # TODO
-            InstructionType.DEPOSIT_SOL: AMOUNT_LAYOUT,
-            InstructionType.SET_FUNDING_AUTHORITY: Pass,  # TODO
-            InstructionType.WITHDRAW_SOL: AMOUNT_LAYOUT,
-            InstructionType.CREATE_TOKEN_METADATA: TOKEN_METADATA_LAYOUT,
-            InstructionType.UPDATE_TOKEN_METADATA: TOKEN_METADATA_LAYOUT,
-            InstructionType.DECREASE_ADDITIONAL_VALIDATOR_STAKE: MOVE_STAKE_LAYOUT_WITH_EPHEMERAL_STAKE,
-            InstructionType.INCREASE_ADDITIONAL_VALIDATOR_STAKE: MOVE_STAKE_LAYOUT_WITH_EPHEMERAL_STAKE,
-            InstructionType.DECREASE_VALIDATOR_STAKE_WITH_RESERVE: MOVE_STAKE_LAYOUT,
-        },
-    ),
-)
-
-
-def initialize(params: InitializeParams) -> TransactionInstruction:
-    """Creates a transaction instruction to initialize a new stake pool."""
-
-    data = INSTRUCTIONS_LAYOUT.build(
-        dict(
-            instruction_type=InstructionType.INITIALIZE,
-            args=dict(
-                epoch_fee=params.epoch_fee._asdict(),
-                withdrawal_fee=params.withdrawal_fee._asdict(),
-                deposit_fee=params.deposit_fee._asdict(),
-                referral_fee=params.referral_fee,
-                max_validators=params.max_validators
-            ),
-        )
-    )
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.manager, is_signer=True, is_writable=False),
-        AccountMeta(pubkey=params.staker, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
-    ]
-    if params.deposit_authority:
-        keys.append(
-            AccountMeta(pubkey=params.deposit_authority, is_signer=True, is_writable=False),
-        )
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=data,
-    )
-
-
-def add_validator_to_pool(params: AddValidatorToPoolParams) -> TransactionInstruction:
-    """Creates instruction to add a validator to the pool."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_vote, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.rent_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_config_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.ADD_VALIDATOR_TO_POOL,
-                args={'seed': params.seed or 0}
-            )
-        )
-    )
-
-
-def add_validator_to_pool_with_vote(
-    program_id: PublicKey,
-    stake_pool: PublicKey,
-    staker: PublicKey,
-    validator_list: PublicKey,
-    reserve_stake: PublicKey,
-    validator: PublicKey,
-    validator_stake_seed: Optional[int],
-) -> TransactionInstruction:
-    """Creates instruction to add a validator based on their vote account address."""
-    (withdraw_authority, _seed) = find_withdraw_authority_program_address(program_id, stake_pool)
-    (validator_stake, _seed) = find_stake_program_address(program_id, validator, stake_pool, validator_stake_seed)
-    return add_validator_to_pool(
-        AddValidatorToPoolParams(
-            program_id=STAKE_POOL_PROGRAM_ID,
-            stake_pool=stake_pool,
-            staker=staker,
-            reserve_stake=reserve_stake,
-            withdraw_authority=withdraw_authority,
-            validator_list=validator_list,
-            validator_stake=validator_stake,
-            validator_vote=validator,
-            rent_sysvar=SYSVAR_RENT_PUBKEY,
-            clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-            stake_history_sysvar=SYSVAR_STAKE_HISTORY_PUBKEY,
-            stake_config_sysvar=SYSVAR_STAKE_CONFIG_ID,
-            system_program_id=SYS_PROGRAM_ID,
-            stake_program_id=STAKE_PROGRAM_ID,
-            seed=validator_stake_seed,
-        )
-    )
-
-
-def remove_validator_from_pool(params: RemoveValidatorFromPoolParams) -> TransactionInstruction:
-    """Creates instruction to remove a validator from the pool."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.REMOVE_VALIDATOR_FROM_POOL,
-                args=None
-            )
-        )
-    )
-
-
-def remove_validator_from_pool_with_vote(
-    program_id: PublicKey,
-    stake_pool: PublicKey,
-    staker: PublicKey,
-    validator_list: PublicKey,
-    validator: PublicKey,
-    validator_stake_seed: Optional[int],
-    transient_stake_seed: int,
-) -> TransactionInstruction:
-    """Creates instruction to remove a validator based on their vote account address."""
-    (withdraw_authority, seed) = find_withdraw_authority_program_address(program_id, stake_pool)
-    (validator_stake, seed) = find_stake_program_address(program_id, validator, stake_pool, validator_stake_seed)
-    (transient_stake, seed) = find_transient_stake_program_address(
-        program_id, validator, stake_pool, transient_stake_seed)
-    return remove_validator_from_pool(
-        RemoveValidatorFromPoolParams(
-            program_id=STAKE_POOL_PROGRAM_ID,
-            stake_pool=stake_pool,
-            staker=staker,
-            withdraw_authority=withdraw_authority,
-            validator_list=validator_list,
-            validator_stake=validator_stake,
-            transient_stake=transient_stake,
-            clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-            stake_program_id=STAKE_PROGRAM_ID,
-        )
-    )
-
-
-def deposit_stake(params: DepositStakeParams) -> TransactionInstruction:
-    """Creates a transaction instruction to deposit a stake account into a stake pool."""
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.deposit_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.deposit_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.destination_pool_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.referral_pool_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.token_program_id, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-    ]
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DEPOSIT_STAKE,
-                args=None,
-            )
-        )
-    )
-
-
-def withdraw_stake(params: WithdrawStakeParams) -> TransactionInstruction:
-    """Creates a transaction instruction to withdraw active stake from a stake pool."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.destination_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.destination_stake_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.source_transfer_authority, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.source_pool_account, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.token_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.WITHDRAW_STAKE,
-                args={'amount': params.amount}
-            )
-        )
-    )
-
-
-def deposit_sol(params: DepositSolParams) -> TransactionInstruction:
-    """Creates a transaction instruction to deposit SOL into a stake pool."""
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.funding_account, is_signer=True, is_writable=True),
-        AccountMeta(pubkey=params.destination_pool_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.referral_pool_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.token_program_id, is_signer=False, is_writable=False),
-    ]
-    if params.deposit_authority:
-        keys.append(AccountMeta(pubkey=params.deposit_authority, is_signer=True, is_writable=False))
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DEPOSIT_SOL,
-                args={'amount': params.amount}
-            )
-        )
-    )
-
-
-def withdraw_sol(params: WithdrawSolParams) -> TransactionInstruction:
-    """Creates a transaction instruction to withdraw SOL from a stake pool."""
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.source_transfer_authority, is_signer=True, is_writable=False),
-        AccountMeta(pubkey=params.source_pool_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.destination_system_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.token_program_id, is_signer=False, is_writable=False),
-    ]
-
-    if params.sol_withdraw_authority:
-        AccountMeta(pubkey=params.sol_withdraw_authority, is_signer=True, is_writable=False)
-
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.WITHDRAW_SOL,
-                args={'amount': params.amount}
-            )
-        )
-    )
-
-
-def update_validator_list_balance(params: UpdateValidatorListBalanceParams) -> TransactionInstruction:
-    """Creates instruction to update a set of validators in the stake pool."""
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-    ]
-    keys.extend([
-        AccountMeta(pubkey=pubkey, is_signer=False, is_writable=True)
-        for pubkey in params.validator_and_transient_stake_pairs
-    ])
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.UPDATE_VALIDATOR_LIST_BALANCE,
-                args={'start_index': params.start_index, 'no_merge': params.no_merge}
-            )
-        )
-    )
-
-
-def update_stake_pool_balance(params: UpdateStakePoolBalanceParams) -> TransactionInstruction:
-    """Creates instruction to update the overall stake pool balance."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.manager_fee_account, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.token_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.UPDATE_STAKE_POOL_BALANCE,
-                args=None,
-            )
-        )
-    )
-
-
-def cleanup_removed_validator_entries(params: CleanupRemovedValidatorEntriesParams) -> TransactionInstruction:
-    """Creates instruction to cleanup removed validator entries."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.CLEANUP_REMOVED_VALIDATOR_ENTRIES,
-                args=None,
-            )
-        )
-    )
-
-
-def increase_validator_stake(params: IncreaseValidatorStakeParams) -> TransactionInstruction:
-    """Creates instruction to increase the stake on a validator."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_vote, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.rent_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_config_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.INCREASE_VALIDATOR_STAKE,
-                args={
-                    'lamports': params.lamports,
-                    'transient_stake_seed': params.transient_stake_seed
-                }
-            )
-        )
-    )
-
-
-def increase_additional_validator_stake(
-    params: IncreaseAdditionalValidatorStakeParams,
-  ) -> TransactionInstruction:
-
-    """Creates `IncreaseAdditionalValidatorStake` instruction (rebalance from reserve account to transient account)"""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.ephemeral_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_vote, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_config_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.INCREASE_ADDITIONAL_VALIDATOR_STAKE,
-                args={
-                    'lamports': params.lamports,
-                    'transient_stake_seed': params.transient_stake_seed,
-                    'ephemeral_stake_seed': params.ephemeral_stake_seed
-                }
-            )
-        )
-    )
-
-
-def decrease_validator_stake(params: DecreaseValidatorStakeParams) -> TransactionInstruction:
-    """Creates instruction to decrease the stake on a validator."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.rent_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DECREASE_VALIDATOR_STAKE,
-                args={
-                    'lamports': params.lamports,
-                    'transient_stake_seed': params.transient_stake_seed
-                }
-            )
-        )
-    )
-
-
-def decrease_additional_validator_stake(params: DecreaseAdditionalValidatorStakeParams) -> TransactionInstruction:
-    """ Creates `DecreaseAdditionalValidatorStake` instruction (rebalance from validator account to
-    transient account)."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.ephemeral_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DECREASE_ADDITIONAL_VALIDATOR_STAKE,
-                args={
-                    'lamports': params.lamports,
-                    'transient_stake_seed': params.transient_stake_seed,
-                    'ephemeral_stake_seed': params.ephemeral_stake_seed
-                }
-            )
-        )
-    )
-
-
-def decrease_validator_stake_with_reserve(params: DecreaseValidatorStakeWithReserveParams) -> TransactionInstruction:
-    """Creates instruction to decrease the stake on a validator."""
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.staker, is_signer=True, is_writable=False),
-            AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.validator_list, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.reserve_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.validator_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.transient_stake, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.clock_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_history_sysvar, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.stake_program_id, is_signer=False, is_writable=False),
-        ],
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.DECREASE_VALIDATOR_STAKE_WITH_RESERVE,
-                args={
-                    'lamports': params.lamports,
-                    'transient_stake_seed': params.transient_stake_seed
-                }
-            )
-        )
-    )
-
-
-def create_token_metadata(params: CreateTokenMetadataParams) -> TransactionInstruction:
-    """Creates an instruction to create metadata using the mpl token metadata program for the pool token."""
-
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.manager, is_signer=True, is_writable=False),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.pool_mint, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.payer, is_signer=True, is_writable=True),
-        AccountMeta(pubkey=params.token_metadata, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.metadata_program_id, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.system_program_id, is_signer=False, is_writable=False),
-    ]
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.CREATE_TOKEN_METADATA,
-                args={
-                    'name': params.name,
-                    'symbol': params.symbol,
-                    'uri': params.uri
-                }
-            )
-        )
-    )
-
-
-def update_token_metadata(params: UpdateTokenMetadataParams) -> TransactionInstruction:
-    """Creates an instruction to update metadata in the mpl token metadata program account for the pool token."""
-
-    keys = [
-        AccountMeta(pubkey=params.stake_pool, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.manager, is_signer=True, is_writable=False),
-        AccountMeta(pubkey=params.withdraw_authority, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=params.token_metadata, is_signer=False, is_writable=True),
-        AccountMeta(pubkey=params.metadata_program_id, is_signer=False, is_writable=False)
-    ]
-    return TransactionInstruction(
-        keys=keys,
-        program_id=params.program_id,
-        data=INSTRUCTIONS_LAYOUT.build(
-            dict(
-                instruction_type=InstructionType.UPDATE_TOKEN_METADATA,
-                args={
-                    "name": params.name,
-                    "symbol": params.symbol,
-                    "uri": params.uri
-                }
-            )
-        )
-    )
diff --git a/stake-pool/py/stake_pool/state.py b/stake-pool/py/stake_pool/state.py
deleted file mode 100644
index 36be8a11de8..00000000000
--- a/stake-pool/py/stake_pool/state.py
+++ /dev/null
@@ -1,330 +0,0 @@
-"""SPL Stake Pool State."""
-
-from enum import IntEnum
-from typing import List, NamedTuple, Optional
-from construct import Bytes, Container, Struct, Switch, Int8ul, Int32ul, Int64ul, Pass  # type: ignore
-
-from solana.publickey import PublicKey
-from solana.utils.helpers import decode_byte_string
-from stake.state import Lockup, LOCKUP_LAYOUT
-
-PUBLIC_KEY_LAYOUT = Bytes(32)
-
-
-def decode_optional_publickey(container: Container) -> Optional[PublicKey]:
-    if container:
-        return PublicKey(container.popitem()[1])
-    else:
-        return None
-
-
-class Fee(NamedTuple):
-    """Fee assessed by the stake pool, expressed as numerator / denominator."""
-    numerator: int
-    denominator: int
-
-    @classmethod
-    def decode_container(cls, container: Container):
-        return Fee(
-            numerator=container['numerator'],
-            denominator=container['denominator'],
-        )
-
-    @classmethod
-    def decode_optional_container(cls, container: Container):
-        if container:
-            return cls.decode_container(container)
-        else:
-            return None
-
-
-class StakePool(NamedTuple):
-    """Stake pool and all its data."""
-    manager: PublicKey
-    staker: PublicKey
-    stake_deposit_authority: PublicKey
-    stake_withdraw_bump_seed: int
-    validator_list: PublicKey
-    reserve_stake: PublicKey
-    pool_mint: PublicKey
-    manager_fee_account: PublicKey
-    token_program_id: PublicKey
-    total_lamports: int
-    pool_token_supply: int
-    last_update_epoch: int
-    lockup: Lockup
-    epoch_fee: Fee
-    next_epoch_fee: Optional[Fee]
-    preferred_deposit_validator: Optional[PublicKey]
-    preferred_withdraw_validator: Optional[PublicKey]
-    stake_deposit_fee: Fee
-    stake_withdrawal_fee: Fee
-    next_stake_withdrawal_fee: Optional[Fee]
-    stake_referral_fee: int
-    sol_deposit_authority: Optional[PublicKey]
-    sol_deposit_fee: Fee
-    sol_referral_fee: int
-    sol_withdraw_authority: Optional[PublicKey]
-    sol_withdrawal_fee: Fee
-    next_sol_withdrawal_fee: Optional[Fee]
-    last_epoch_pool_token_supply: int
-    last_epoch_total_lamports: int
-
-    @classmethod
-    def decode(cls, data: str, encoding: str):
-        data_bytes = decode_byte_string(data, encoding)
-        parsed = DECODE_STAKE_POOL_LAYOUT.parse(data_bytes)
-        return StakePool(
-            manager=PublicKey(parsed['manager']),
-            staker=PublicKey(parsed['staker']),
-            stake_deposit_authority=PublicKey(parsed['stake_deposit_authority']),
-            stake_withdraw_bump_seed=parsed['stake_withdraw_bump_seed'],
-            validator_list=PublicKey(parsed['validator_list']),
-            reserve_stake=PublicKey(parsed['reserve_stake']),
-            pool_mint=PublicKey(parsed['pool_mint']),
-            manager_fee_account=PublicKey(parsed['manager_fee_account']),
-            token_program_id=PublicKey(parsed['token_program_id']),
-            total_lamports=parsed['total_lamports'],
-            pool_token_supply=parsed['pool_token_supply'],
-            last_update_epoch=parsed['last_update_epoch'],
-            lockup=Lockup.decode_container(parsed['lockup']),
-            epoch_fee=Fee.decode_container(parsed['epoch_fee']),
-            next_epoch_fee=Fee.decode_optional_container(parsed['next_epoch_fee']),
-            preferred_deposit_validator=decode_optional_publickey(parsed['preferred_deposit_validator']),
-            preferred_withdraw_validator=decode_optional_publickey(parsed['preferred_withdraw_validator']),
-            stake_deposit_fee=Fee.decode_container(parsed['stake_deposit_fee']),
-            stake_withdrawal_fee=Fee.decode_container(parsed['stake_withdrawal_fee']),
-            next_stake_withdrawal_fee=Fee.decode_optional_container(parsed['next_stake_withdrawal_fee']),
-            stake_referral_fee=parsed['stake_referral_fee'],
-            sol_deposit_authority=decode_optional_publickey(parsed['sol_deposit_authority']),
-            sol_deposit_fee=Fee.decode_container(parsed['sol_deposit_fee']),
-            sol_referral_fee=parsed['sol_referral_fee'],
-            sol_withdraw_authority=decode_optional_publickey(parsed['sol_withdraw_authority']),
-            sol_withdrawal_fee=Fee.decode_container(parsed['sol_withdrawal_fee']),
-            next_sol_withdrawal_fee=Fee.decode_optional_container(parsed['next_sol_withdrawal_fee']),
-            last_epoch_pool_token_supply=parsed['last_epoch_pool_token_supply'],
-            last_epoch_total_lamports=parsed['last_epoch_total_lamports'],
-        )
-
-
-class StakeStatus(IntEnum):
-    """Specifies the status of a stake on a validator in a stake pool."""
-
-    ACTIVE = 0
-    """Stake is active and normal."""
-    DEACTIVATING_TRANSIENT = 1
-    """Stake has been removed, but a deactivating transient stake still exists."""
-    READY_FOR_REMOVAL = 2
-    """No more validator stake accounts exist, entry ready for removal."""
-    DEACTIVATING_VALIDATOR = 3
-    """Validator stake account is deactivating to be merged into the reserve next epoch."""
-    DEACTIVATING_ALL = 3
-    """All alidator stake accounts are deactivating to be merged into the reserve next epoch."""
-
-
-class ValidatorStakeInfo(NamedTuple):
-    active_stake_lamports: int
-    """Amount of active stake delegated to this validator."""
-
-    transient_stake_lamports: int
-    """Amount of transient stake delegated to this validator."""
-
-    last_update_epoch: int
-    """Last epoch the active and transient stake lamports fields were updated."""
-
-    transient_seed_suffix: int
-    """Transient account seed suffix."""
-
-    unused: int
-    """Unused space, initially meant to specify the range of transient stake account suffixes."""
-
-    validator_seed_suffix: int
-    """Validator account seed suffix."""
-
-    status: StakeStatus
-    """Status of the validator stake account."""
-
-    vote_account_address: PublicKey
-    """Validator vote account address."""
-
-    @classmethod
-    def decode_container(cls, container: Container):
-        return ValidatorStakeInfo(
-            active_stake_lamports=container['active_stake_lamports'],
-            transient_stake_lamports=container['transient_stake_lamports'],
-            last_update_epoch=container['last_update_epoch'],
-            transient_seed_suffix=container['transient_seed_suffix'],
-            unused=container['unused'],
-            validator_seed_suffix=container['validator_seed_suffix'],
-            status=container['status'],
-            vote_account_address=PublicKey(container['vote_account_address']),
-        )
-
-
-class ValidatorList(NamedTuple):
-    """List of validators and amount staked, associated to a stake pool."""
-
-    max_validators: int
-    """Maximum number of validators possible in the list."""
-
-    validators: List[ValidatorStakeInfo]
-    """Info for each validator in the stake pool."""
-
-    @staticmethod
-    def calculate_validator_list_size(max_validators: int) -> int:
-        layout = VALIDATOR_LIST_LAYOUT + VALIDATOR_INFO_LAYOUT[max_validators]
-        return layout.sizeof()
-
-    @classmethod
-    def decode(cls, data: str, encoding: str):
-        data_bytes = decode_byte_string(data, encoding)
-        parsed = DECODE_VALIDATOR_LIST_LAYOUT.parse(data_bytes)
-        return ValidatorList(
-            max_validators=parsed['max_validators'],
-            validators=[ValidatorStakeInfo.decode_container(container) for container in parsed['validators']],
-        )
-
-
-FEE_LAYOUT = Struct(
-    "denominator" / Int64ul,
-    "numerator" / Int64ul,
-)
-
-STAKE_POOL_LAYOUT = Struct(
-    "account_type" / Int8ul,
-    "manager" / PUBLIC_KEY_LAYOUT,
-    "staker" / PUBLIC_KEY_LAYOUT,
-    "stake_deposit_authority" / PUBLIC_KEY_LAYOUT,
-    "stake_withdraw_bump_seed" / Int8ul,
-    "validator_list" / PUBLIC_KEY_LAYOUT,
-    "reserve_stake" / PUBLIC_KEY_LAYOUT,
-    "pool_mint" / PUBLIC_KEY_LAYOUT,
-    "manager_fee_account" / PUBLIC_KEY_LAYOUT,
-    "token_program_id" / PUBLIC_KEY_LAYOUT,
-    "total_lamports" / Int64ul,
-    "pool_token_supply" / Int64ul,
-    "last_update_epoch" / Int64ul,
-    "lockup" / LOCKUP_LAYOUT,
-    "epoch_fee" / FEE_LAYOUT,
-    "next_epoch_fee_option" / Int8ul,
-    "next_epoch_fee" / FEE_LAYOUT,
-    "preferred_deposit_validator_option" / Int8ul,
-    "preferred_deposit_validator" / PUBLIC_KEY_LAYOUT,
-    "preferred_withdraw_validator_option" / Int8ul,
-    "preferred_withdraw_validator" / PUBLIC_KEY_LAYOUT,
-    "stake_deposit_fee" / FEE_LAYOUT,
-    "stake_withdrawal_fee" / FEE_LAYOUT,
-    "next_stake_withdrawal_fee_option" / Int8ul,
-    "next_stake_withdrawal_fee" / FEE_LAYOUT,
-    "stake_referral_fee" / Int8ul,
-    "sol_deposit_authority_option" / Int8ul,
-    "sol_deposit_authority" / PUBLIC_KEY_LAYOUT,
-    "sol_deposit_fee" / FEE_LAYOUT,
-    "sol_referral_fee" / Int8ul,
-    "sol_withdraw_authority_option" / Int8ul,
-    "sol_withdraw_authority" / PUBLIC_KEY_LAYOUT,
-    "sol_withdrawal_fee" / FEE_LAYOUT,
-    "next_sol_withdrawal_fee_option" / Int8ul,
-    "next_sol_withdrawal_fee" / FEE_LAYOUT,
-    "last_epoch_pool_token_supply" / Int64ul,
-    "last_epoch_total_lamports" / Int64ul,
-)
-
-DECODE_STAKE_POOL_LAYOUT = Struct(
-    "account_type" / Int8ul,
-    "manager" / PUBLIC_KEY_LAYOUT,
-    "staker" / PUBLIC_KEY_LAYOUT,
-    "stake_deposit_authority" / PUBLIC_KEY_LAYOUT,
-    "stake_withdraw_bump_seed" / Int8ul,
-    "validator_list" / PUBLIC_KEY_LAYOUT,
-    "reserve_stake" / PUBLIC_KEY_LAYOUT,
-    "pool_mint" / PUBLIC_KEY_LAYOUT,
-    "manager_fee_account" / PUBLIC_KEY_LAYOUT,
-    "token_program_id" / PUBLIC_KEY_LAYOUT,
-    "total_lamports" / Int64ul,
-    "pool_token_supply" / Int64ul,
-    "last_update_epoch" / Int64ul,
-    "lockup" / LOCKUP_LAYOUT,
-    "epoch_fee" / FEE_LAYOUT,
-    "next_epoch_fee_option" / Int8ul,
-    "next_epoch_fee" / Switch(
-        lambda this: this.next_epoch_fee_option,
-        {
-            0: Pass,
-            1: FEE_LAYOUT,
-        }),
-    "preferred_deposit_validator_option" / Int8ul,
-    "preferred_deposit_validator" / Switch(
-        lambda this: this.preferred_deposit_validator_option,
-        {
-            0: Pass,
-            1: PUBLIC_KEY_LAYOUT,
-        }),
-    "preferred_withdraw_validator_option" / Int8ul,
-    "preferred_withdraw_validator" / Switch(
-        lambda this: this.preferred_withdraw_validator_option,
-        {
-            0: Pass,
-            1: PUBLIC_KEY_LAYOUT,
-        }),
-    "stake_deposit_fee" / FEE_LAYOUT,
-    "stake_withdrawal_fee" / FEE_LAYOUT,
-    "next_stake_withdrawal_fee_option" / Int8ul,
-    "next_stake_withdrawal_fee" / Switch(
-        lambda this: this.next_stake_withdrawal_fee_option,
-        {
-            0: Pass,
-            1: FEE_LAYOUT,
-        }),
-    "stake_referral_fee" / Int8ul,
-    "sol_deposit_authority_option" / Int8ul,
-    "sol_deposit_authority" / Switch(
-        lambda this: this.sol_deposit_authority_option,
-        {
-            0: Pass,
-            1: PUBLIC_KEY_LAYOUT,
-        }),
-    "sol_deposit_fee" / FEE_LAYOUT,
-    "sol_referral_fee" / Int8ul,
-    "sol_withdraw_authority_option" / Int8ul,
-    "sol_withdraw_authority" / Switch(
-        lambda this: this.sol_withdraw_authority_option,
-        {
-            0: Pass,
-            1: PUBLIC_KEY_LAYOUT,
-        }),
-    "sol_withdrawal_fee" / FEE_LAYOUT,
-    "next_sol_withdrawal_fee_option" / Int8ul,
-    "next_sol_withdrawal_fee" / Switch(
-        lambda this: this.next_sol_withdrawal_fee_option,
-        {
-            0: Pass,
-            1: FEE_LAYOUT,
-        }),
-    "last_epoch_pool_token_supply" / Int64ul,
-    "last_epoch_total_lamports" / Int64ul,
-)
-
-VALIDATOR_INFO_LAYOUT = Struct(
-    "active_stake_lamports" / Int64ul,
-    "transient_stake_lamports" / Int64ul,
-    "last_update_epoch" / Int64ul,
-    "transient_seed_suffix" / Int64ul,
-    "unused" / Int32ul,
-    "validator_seed_suffix" / Int32ul,
-    "status" / Int8ul,
-    "vote_account_address" / PUBLIC_KEY_LAYOUT,
-)
-
-VALIDATOR_LIST_LAYOUT = Struct(
-    "account_type" / Int8ul,
-    "max_validators" / Int32ul,
-    "validators_len" / Int32ul,
-)
-
-DECODE_VALIDATOR_LIST_LAYOUT = Struct(
-    "account_type" / Int8ul,
-    "max_validators" / Int32ul,
-    "validators_len" / Int32ul,
-    "validators" / VALIDATOR_INFO_LAYOUT[lambda this: this.validators_len],
-)
diff --git a/stake-pool/py/system/__init__.py b/stake-pool/py/system/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/system/actions.py b/stake-pool/py/system/actions.py
deleted file mode 100644
index 0b16a04587f..00000000000
--- a/stake-pool/py/system/actions.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from solana.publickey import PublicKey
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-
-
-async def airdrop(client: AsyncClient, receiver: PublicKey, lamports: int):
-    print(f"Airdropping {lamports} lamports to {receiver}...")
-    resp = await client.request_airdrop(receiver, lamports, Confirmed)
-    await client.confirm_transaction(resp['result'], Confirmed)
diff --git a/stake-pool/py/tests/conftest.py b/stake-pool/py/tests/conftest.py
deleted file mode 100644
index 24212678822..00000000000
--- a/stake-pool/py/tests/conftest.py
+++ /dev/null
@@ -1,121 +0,0 @@
-import asyncio
-import pytest
-import pytest_asyncio
-import os
-import shutil
-import tempfile
-from typing import AsyncIterator, List, Tuple
-from subprocess import Popen
-
-from solana.keypair import Keypair
-from solana.publickey import PublicKey
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-
-from spl.token.instructions import get_associated_token_address
-
-from vote.actions import create_vote
-from system.actions import airdrop
-from stake_pool.actions import deposit_sol, create_all, add_validator_to_pool
-from stake_pool.state import Fee
-
-NUM_SLOTS_PER_EPOCH: int = 32
-AIRDROP_LAMPORTS: int = 30_000_000_000
-
-
-@pytest.fixture(scope="session")
-def solana_test_validator():
-    old_cwd = os.getcwd()
-    newpath = tempfile.mkdtemp()
-    os.chdir(newpath)
-    validator = Popen([
-        "solana-test-validator",
-        "--reset", "--quiet",
-        "--bpf-program", "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy",
-        f"{old_cwd}/../../target/deploy/spl_stake_pool.so",
-        "--bpf-program", "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s",
-        f"{old_cwd}/../program/tests/fixtures/mpl_token_metadata.so",
-        "--slots-per-epoch", str(NUM_SLOTS_PER_EPOCH),
-    ],)
-    yield
-    validator.kill()
-    os.chdir(old_cwd)
-    shutil.rmtree(newpath)
-
-
-@pytest_asyncio.fixture
-async def validators(async_client, payer) -> List[PublicKey]:
-    num_validators = 3
-    validators = []
-    for i in range(num_validators):
-        vote = Keypair()
-        node = Keypair()
-        await create_vote(async_client, payer, vote, node, payer.public_key, payer.public_key, 10)
-        validators.append(vote.public_key)
-    return validators
-
-
-@pytest_asyncio.fixture
-async def stake_pool_addresses(
-    async_client, payer, validators, waiter
-) -> Tuple[PublicKey, PublicKey, PublicKey]:
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    # Change back to `wait_for_next_epoch_if_soon` once https://github.com/solana-labs/solana/pull/26851 is available
-    await waiter.wait_for_next_epoch(async_client)
-    stake_pool_addresses = await create_all(async_client, payer, fee, referral_fee)
-    stake_pool = stake_pool_addresses[0]
-    pool_mint = stake_pool_addresses[2]
-    token_account = get_associated_token_address(payer.public_key, pool_mint)
-    await deposit_sol(async_client, payer, stake_pool, token_account, AIRDROP_LAMPORTS // 2)
-    for validator in validators:
-        await add_validator_to_pool(async_client, payer, stake_pool, validator)
-    return stake_pool_addresses
-
-
-@pytest_asyncio.fixture
-async def async_client(solana_test_validator) -> AsyncIterator[AsyncClient]:
-    async_client = AsyncClient(commitment=Confirmed)
-    total_attempts = 20
-    current_attempt = 0
-    while not await async_client.is_connected():
-        if current_attempt == total_attempts:
-            raise Exception("Could not connect to test validator")
-        else:
-            current_attempt += 1
-        await asyncio.sleep(1.0)
-    yield async_client
-    await async_client.close()
-
-
-@pytest_asyncio.fixture
-async def payer(async_client) -> Keypair:
-    payer = Keypair()
-    await airdrop(async_client, payer.public_key, AIRDROP_LAMPORTS)
-    return payer
-
-
-class Waiter:
-    @staticmethod
-    async def wait_for_next_epoch(async_client: AsyncClient):
-        resp = await async_client.get_epoch_info(commitment=Confirmed)
-        current_epoch = resp['result']['epoch']
-        next_epoch = current_epoch
-        while current_epoch == next_epoch:
-            await asyncio.sleep(1.0)
-            resp = await async_client.get_epoch_info(commitment=Confirmed)
-            next_epoch = resp['result']['epoch']
-
-    @staticmethod
-    async def wait_for_next_epoch_if_soon(async_client: AsyncClient):
-        resp = await async_client.get_epoch_info(commitment=Confirmed)
-        if resp['result']['slotsInEpoch'] - resp['result']['slotIndex'] < NUM_SLOTS_PER_EPOCH // 2:
-            await Waiter.wait_for_next_epoch(async_client)
-            return True
-        else:
-            return False
-
-
-@pytest.fixture
-def waiter() -> Waiter:
-    return Waiter()
diff --git a/stake-pool/py/tests/test_a_time_sensitive.py b/stake-pool/py/tests/test_a_time_sensitive.py
deleted file mode 100644
index 682d1202bea..00000000000
--- a/stake-pool/py/tests/test_a_time_sensitive.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""Time sensitive test, so run it first out of the bunch."""
-import asyncio
-import pytest
-from solana.rpc.commitment import Confirmed
-from spl.token.instructions import get_associated_token_address
-
-from stake.constants import STAKE_LEN
-from stake_pool.actions import deposit_sol, decrease_validator_stake, increase_validator_stake, update_stake_pool
-from stake_pool.constants import MINIMUM_ACTIVE_STAKE
-from stake_pool.state import StakePool, ValidatorList
-
-
-@pytest.mark.asyncio
-async def test_increase_decrease_this_is_very_slow(async_client, validators, payer, stake_pool_addresses, waiter):
-    (stake_pool_address, validator_list_address, _) = stake_pool_addresses
-
-    resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-    minimum_amount = MINIMUM_ACTIVE_STAKE + stake_rent_exemption
-    increase_amount = MINIMUM_ACTIVE_STAKE * 4
-    decrease_amount = increase_amount // 2
-    deposit_amount = (increase_amount + stake_rent_exemption) * len(validators)
-
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    token_account = get_associated_token_address(payer.public_key, stake_pool.pool_mint)
-    await deposit_sol(async_client, payer, stake_pool_address, token_account, deposit_amount)
-
-    # increase to all
-    futures = [
-        increase_validator_stake(async_client, payer, payer, stake_pool_address, validator, increase_amount // 2)
-        for validator in validators
-    ]
-    await asyncio.gather(*futures)
-
-    # validate the increase is now on the transient account
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.transient_stake_lamports == increase_amount // 2 + stake_rent_exemption
-        assert validator.active_stake_lamports == minimum_amount
-
-    # increase the same amount to test the increase additional instruction
-    futures = [
-        increase_validator_stake(async_client, payer, payer, stake_pool_address, validator, increase_amount // 2,
-                                 ephemeral_stake_seed=0)
-        for validator in validators
-    ]
-    await asyncio.gather(*futures)
-
-    # validate the additional increase is now on the transient account
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.transient_stake_lamports == increase_amount + stake_rent_exemption * 2
-        assert validator.active_stake_lamports == minimum_amount
-
-    print("Waiting for epoch to roll over")
-    await waiter.wait_for_next_epoch(async_client)
-    await update_stake_pool(async_client, payer, stake_pool_address)
-
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.last_update_epoch != 0
-        assert validator.transient_stake_lamports == 0
-        assert validator.active_stake_lamports == increase_amount + minimum_amount + stake_rent_exemption
-
-    # decrease from all
-    futures = [
-        decrease_validator_stake(async_client, payer, payer, stake_pool_address, validator, decrease_amount)
-        for validator in validators
-    ]
-    await asyncio.gather(*futures)
-
-    # validate the decrease is now on the transient account
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.transient_stake_lamports == decrease_amount + stake_rent_exemption
-        assert validator.active_stake_lamports == increase_amount - decrease_amount + minimum_amount + \
-            stake_rent_exemption
-
-    # DO NOT test decrese additional instruction as it is confirmed NOT to be working as advertised
-
-    # roll over one epoch and verify we have the balances that we expect
-    expected_active_stake_lamports = increase_amount - decrease_amount + minimum_amount + stake_rent_exemption
-
-    print("Waiting for epoch to roll over")
-    await waiter.wait_for_next_epoch(async_client)
-    await update_stake_pool(async_client, payer, stake_pool_address)
-
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.transient_stake_lamports == 0
-        assert validator.active_stake_lamports == expected_active_stake_lamports
diff --git a/stake-pool/py/tests/test_add_remove.py b/stake-pool/py/tests/test_add_remove.py
deleted file mode 100644
index b2d96af3954..00000000000
--- a/stake-pool/py/tests/test_add_remove.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import asyncio
-import pytest
-from solana.rpc.commitment import Confirmed
-
-from stake.constants import STAKE_LEN
-from stake_pool.actions import remove_validator_from_pool
-from stake_pool.constants import MINIMUM_ACTIVE_STAKE
-from stake_pool.state import ValidatorList, StakeStatus
-
-
-@pytest.mark.asyncio
-async def test_add_remove_validators(async_client, validators, payer, stake_pool_addresses):
-    (stake_pool_address, validator_list_address, _) = stake_pool_addresses
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    assert len(validator_list.validators) == len(validators)
-    resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-    futures = []
-    for validator_info in validator_list.validators:
-        assert validator_info.vote_account_address in validators
-        assert validator_info.active_stake_lamports == stake_rent_exemption + MINIMUM_ACTIVE_STAKE
-        assert validator_info.transient_stake_lamports == 0
-        assert validator_info.status == StakeStatus.ACTIVE
-        futures.append(
-            remove_validator_from_pool(async_client, payer, stake_pool_address, validator_info.vote_account_address)
-        )
-    await asyncio.gather(*futures)
-
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator_info in validator_list.validators:
-        assert validator_info.status == StakeStatus.DEACTIVATING_VALIDATOR
diff --git a/stake-pool/py/tests/test_bot_rebalance.py b/stake-pool/py/tests/test_bot_rebalance.py
deleted file mode 100644
index c0283ef5f77..00000000000
--- a/stake-pool/py/tests/test_bot_rebalance.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""Time sensitive test, so run it first out of the bunch."""
-import pytest
-from solana.rpc.commitment import Confirmed
-from spl.token.instructions import get_associated_token_address
-
-from stake.constants import STAKE_LEN, LAMPORTS_PER_SOL
-from stake_pool.actions import deposit_sol
-from stake_pool.constants import MINIMUM_ACTIVE_STAKE, MINIMUM_RESERVE_LAMPORTS
-from stake_pool.state import StakePool, ValidatorList
-
-from bot.rebalance import rebalance
-
-
-ENDPOINT: str = "http://127.0.0.1:8899"
-
-
-@pytest.mark.asyncio
-async def test_rebalance_this_is_very_slow(async_client, validators, payer, stake_pool_addresses, waiter):
-    (stake_pool_address, validator_list_address, _) = stake_pool_addresses
-    resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-    # With minimum delegation at MINIMUM_DELEGATION + rent-exemption, when
-    # decreasing, we'll need rent exemption + minimum delegation delegated to
-    # cover all movements
-    minimum_amount = MINIMUM_ACTIVE_STAKE + stake_rent_exemption
-    increase_amount = MINIMUM_ACTIVE_STAKE + stake_rent_exemption
-    deposit_amount = (increase_amount + stake_rent_exemption) * len(validators)
-
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    total_lamports = stake_pool.total_lamports + deposit_amount
-    token_account = get_associated_token_address(payer.public_key, stake_pool.pool_mint)
-    await deposit_sol(async_client, payer, stake_pool_address, token_account, deposit_amount)
-
-    # Test case 1: Increase everywhere
-    await rebalance(ENDPOINT, stake_pool_address, payer, 0.0)
-
-    # should only have minimum left
-    resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
-    assert resp['result']['value']['lamports'] == stake_rent_exemption + MINIMUM_RESERVE_LAMPORTS
-
-    # should all be the same
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.active_stake_lamports == minimum_amount
-        assert validator.transient_stake_lamports == total_lamports / len(validators) - minimum_amount
-
-    # Test case 2: Decrease everything back to reserve
-    print('Waiting for next epoch')
-    await waiter.wait_for_next_epoch(async_client)
-    max_in_reserve = total_lamports - minimum_amount * len(validators)
-    await rebalance(ENDPOINT, stake_pool_address, payer, max_in_reserve / LAMPORTS_PER_SOL)
-
-    # should still only have minimum left
-    resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
-    reserve_lamports = resp['result']['value']['lamports']
-    assert reserve_lamports == stake_rent_exemption + MINIMUM_RESERVE_LAMPORTS
-
-    # should all be decreasing now
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.active_stake_lamports == minimum_amount
-        assert validator.transient_stake_lamports == max_in_reserve / len(validators)
-
-    # Test case 3: Do nothing
-    print('Waiting for next epoch')
-    await waiter.wait_for_next_epoch(async_client)
-    await rebalance(ENDPOINT, stake_pool_address, payer, max_in_reserve / LAMPORTS_PER_SOL)
-
-    # should still only have minimum left + rent exemptions from increase
-    resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
-    reserve_lamports = resp['result']['value']['lamports']
-    assert reserve_lamports == stake_rent_exemption + max_in_reserve + MINIMUM_RESERVE_LAMPORTS
-
-    # should all be decreased now
-    resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    validator_list = ValidatorList.decode(data[0], data[1])
-    for validator in validator_list.validators:
-        assert validator.active_stake_lamports == minimum_amount
-        assert validator.transient_stake_lamports == 0
diff --git a/stake-pool/py/tests/test_create.py b/stake-pool/py/tests/test_create.py
deleted file mode 100644
index 97600ae3926..00000000000
--- a/stake-pool/py/tests/test_create.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import pytest
-from solana.keypair import Keypair
-from solana.rpc.commitment import Confirmed
-from spl.token.constants import TOKEN_PROGRAM_ID
-
-from stake_pool.constants import \
-    find_withdraw_authority_program_address, \
-    MINIMUM_RESERVE_LAMPORTS, \
-    STAKE_POOL_PROGRAM_ID
-from stake_pool.state import StakePool, Fee
-
-from stake.actions import create_stake
-from stake_pool.actions import create
-from spl_token.actions import create_mint, create_associated_token_account
-
-
-@pytest.mark.asyncio
-async def test_create_stake_pool(async_client, payer):
-    stake_pool = Keypair()
-    validator_list = Keypair()
-    (pool_withdraw_authority, seed) = find_withdraw_authority_program_address(
-        STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
-
-    reserve_stake = Keypair()
-    await create_stake(async_client, payer, reserve_stake, pool_withdraw_authority, MINIMUM_RESERVE_LAMPORTS)
-
-    pool_mint = Keypair()
-    await create_mint(async_client, payer, pool_mint, pool_withdraw_authority)
-
-    manager_fee_account = await create_associated_token_account(
-        async_client,
-        payer,
-        payer.public_key,
-        pool_mint.public_key,
-    )
-
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    await create(
-        async_client, payer, stake_pool, validator_list, pool_mint.public_key,
-        reserve_stake.public_key, manager_fee_account, fee, referral_fee)
-    resp = await async_client.get_account_info(stake_pool.public_key, commitment=Confirmed)
-    assert resp['result']['value']['owner'] == str(STAKE_POOL_PROGRAM_ID)
-    data = resp['result']['value']['data']
-    pool_data = StakePool.decode(data[0], data[1])
-    assert pool_data.manager == payer.public_key
-    assert pool_data.staker == payer.public_key
-    assert pool_data.stake_withdraw_bump_seed == seed
-    assert pool_data.validator_list == validator_list.public_key
-    assert pool_data.reserve_stake == reserve_stake.public_key
-    assert pool_data.pool_mint == pool_mint.public_key
-    assert pool_data.manager_fee_account == manager_fee_account
-    assert pool_data.token_program_id == TOKEN_PROGRAM_ID
-    assert pool_data.total_lamports == 0
-    assert pool_data.pool_token_supply == 0
-    assert pool_data.epoch_fee == fee
-    assert pool_data.next_epoch_fee is None
-    assert pool_data.preferred_deposit_validator is None
-    assert pool_data.preferred_withdraw_validator is None
-    assert pool_data.stake_deposit_fee == fee
-    assert pool_data.stake_withdrawal_fee == fee
-    assert pool_data.next_stake_withdrawal_fee is None
-    assert pool_data.stake_referral_fee == referral_fee
-    assert pool_data.sol_deposit_authority is None
-    assert pool_data.sol_deposit_fee == fee
-    assert pool_data.sol_referral_fee == referral_fee
-    assert pool_data.sol_withdraw_authority is None
-    assert pool_data.sol_withdrawal_fee == fee
-    assert pool_data.next_sol_withdrawal_fee is None
-    assert pool_data.last_epoch_pool_token_supply == 0
-    assert pool_data.last_epoch_total_lamports == 0
diff --git a/stake-pool/py/tests/test_create_update_token_metadata.py b/stake-pool/py/tests/test_create_update_token_metadata.py
deleted file mode 100644
index 10ae24f6963..00000000000
--- a/stake-pool/py/tests/test_create_update_token_metadata.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import pytest
-from stake_pool.actions import create_all, create_token_metadata, update_token_metadata
-from stake_pool.state import Fee, StakePool
-from solana.rpc.commitment import Confirmed
-from solana.rpc.async_api import AsyncClient
-from solana.keypair import Keypair
-from stake_pool.constants import find_metadata_account
-from solana.utils.helpers import decode_byte_string
-
-
-@pytest.mark.asyncio
-async def test_create_metadata_success(async_client: AsyncClient, payer: Keypair):
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    (stake_pool_address, _validator_list_address, _) = await create_all(async_client, payer, fee, referral_fee)
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    name = "test_name"
-    symbol = "SYM"
-    uri = "test_uri"
-    await create_token_metadata(async_client, payer, stake_pool_address, name, symbol, uri)
-
-    (metadata_program_address, _seed) = find_metadata_account(stake_pool.pool_mint)
-    resp = await async_client.get_account_info(metadata_program_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    raw_data = decode_byte_string(data[0], data[1])
-    assert name == str(raw_data[69:101], "utf-8")[:len(name)]
-    assert symbol == str(raw_data[105:115], "utf-8")[:len(symbol)]
-    assert uri == str(raw_data[119:319], "utf-8")[:len(uri)]
-
-
-@pytest.mark.asyncio
-async def test_update_metadata_success(async_client: AsyncClient, payer: Keypair):
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    (stake_pool_address, _validator_list_address, _) = await create_all(async_client, payer, fee, referral_fee)
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-
-    name = "test_name"
-    symbol = "SYM"
-    uri = "test_uri"
-    await create_token_metadata(async_client, payer, stake_pool_address, name, symbol, uri)
-
-    (metadata_program_address, _seed) = find_metadata_account(stake_pool.pool_mint)
-    resp = await async_client.get_account_info(metadata_program_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    raw_data = decode_byte_string(data[0], data[1])
-    assert name == str(raw_data[69:101], "utf-8")[:len(name)]
-    assert symbol == str(raw_data[105:115], "utf-8")[:len(symbol)]
-    assert uri == str(raw_data[119:319], "utf-8")[:len(uri)]
-
-    updated_name = "updated_name"
-    updated_symbol = "USM"
-    updated_uri = "updated_uri"
-    await update_token_metadata(async_client, payer, stake_pool_address, updated_name, updated_symbol, updated_uri)
-
-    (metadata_program_address, _seed) = find_metadata_account(stake_pool.pool_mint)
-    resp = await async_client.get_account_info(metadata_program_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    raw_data = decode_byte_string(data[0], data[1])
-    assert updated_name == str(raw_data[69:101], "utf-8")[:len(updated_name)]
-    assert updated_symbol == str(raw_data[105:115], "utf-8")[:len(updated_symbol)]
-    assert updated_uri == str(raw_data[119:319], "utf-8")[:len(updated_uri)]
diff --git a/stake-pool/py/tests/test_deposit_withdraw_sol.py b/stake-pool/py/tests/test_deposit_withdraw_sol.py
deleted file mode 100644
index 8057101e37b..00000000000
--- a/stake-pool/py/tests/test_deposit_withdraw_sol.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import pytest
-from solana.rpc.commitment import Confirmed, Processed
-from solana.keypair import Keypair
-from spl.token.instructions import get_associated_token_address
-
-from stake_pool.state import Fee, StakePool
-from stake_pool.actions import create_all, deposit_sol, withdraw_sol
-
-
-@pytest.mark.asyncio
-async def test_deposit_withdraw_sol(async_client, payer):
-    fee = Fee(numerator=1, denominator=1000)
-    referral_fee = 20
-    (stake_pool_address, validator_list_address, _) = await create_all(async_client, payer, fee, referral_fee)
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    token_account = get_associated_token_address(payer.public_key, stake_pool.pool_mint)
-    deposit_amount = 100_000_000
-    await deposit_sol(async_client, payer, stake_pool_address, token_account, deposit_amount)
-    pool_token_balance = await async_client.get_token_account_balance(token_account, Confirmed)
-    assert pool_token_balance['result']['value']['amount'] == str(deposit_amount)
-    recipient = Keypair()
-    await withdraw_sol(async_client, payer, token_account, stake_pool_address, recipient.public_key, deposit_amount)
-    # for some reason, this is not always in sync when running all tests
-    pool_token_balance = await async_client.get_token_account_balance(token_account, Processed)
-    assert pool_token_balance['result']['value']['amount'] == str('0')
diff --git a/stake-pool/py/tests/test_deposit_withdraw_stake.py b/stake-pool/py/tests/test_deposit_withdraw_stake.py
deleted file mode 100644
index 890fb9d1f4d..00000000000
--- a/stake-pool/py/tests/test_deposit_withdraw_stake.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import pytest
-from solana.rpc.commitment import Confirmed
-from solana.keypair import Keypair
-from spl.token.instructions import get_associated_token_address
-
-from stake.actions import create_stake, delegate_stake
-from stake.constants import STAKE_LEN
-from stake.state import StakeStake
-from stake_pool.actions import deposit_stake, withdraw_stake, update_stake_pool
-from stake_pool.constants import MINIMUM_ACTIVE_STAKE
-from stake_pool.state import StakePool
-
-
-@pytest.mark.asyncio
-async def test_deposit_withdraw_stake(async_client, validators, payer, stake_pool_addresses, waiter):
-    (stake_pool_address, validator_list_address, _) = stake_pool_addresses
-    resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_pool = StakePool.decode(data[0], data[1])
-    validator = next(iter(validators))
-    stake_amount = MINIMUM_ACTIVE_STAKE
-    stake = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, stake_amount)
-    stake = stake.public_key
-    await delegate_stake(async_client, payer, payer, stake, validator)
-    resp = await async_client.get_account_info(stake, commitment=Confirmed)
-    data = resp['result']['value']['data']
-    stake_state = StakeStake.decode(data[0], data[1])
-    token_account = get_associated_token_address(payer.public_key, stake_pool.pool_mint)
-    pre_pool_token_balance = await async_client.get_token_account_balance(token_account, Confirmed)
-    pre_pool_token_balance = int(pre_pool_token_balance['result']['value']['amount'])
-    print(stake_state)
-
-    await waiter.wait_for_next_epoch(async_client)
-
-    await update_stake_pool(async_client, payer, stake_pool_address)
-    await deposit_stake(async_client, payer, stake_pool_address, validator, stake, token_account)
-    pool_token_balance = await async_client.get_token_account_balance(token_account, Confirmed)
-    pool_token_balance = pool_token_balance['result']['value']['amount']
-    resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
-    stake_rent_exemption = resp['result']
-    assert pool_token_balance == str(stake_amount + stake_rent_exemption + pre_pool_token_balance)
-
-    destination_stake = Keypair()
-    await withdraw_stake(
-        async_client, payer, payer, destination_stake, stake_pool_address, validator,
-        payer.public_key, token_account, stake_amount
-    )
-
-    pool_token_balance = await async_client.get_token_account_balance(token_account, Confirmed)
-    pool_token_balance = pool_token_balance['result']['value']['amount']
-    assert pool_token_balance == str(stake_rent_exemption + pre_pool_token_balance)
diff --git a/stake-pool/py/tests/test_stake.py b/stake-pool/py/tests/test_stake.py
deleted file mode 100644
index ab7cc3a4494..00000000000
--- a/stake-pool/py/tests/test_stake.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import asyncio
-import pytest
-from solana.keypair import Keypair
-
-from stake.actions import authorize, create_stake, delegate_stake
-from stake.constants import MINIMUM_DELEGATION
-from stake.state import StakeAuthorize
-
-
-@pytest.mark.asyncio
-async def test_create_stake(async_client, payer):
-    stake = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, 1)
-
-
-@pytest.mark.asyncio
-async def test_delegate_stake(async_client, validators, payer):
-    validator = validators[0]
-    stake = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, MINIMUM_DELEGATION)
-    await delegate_stake(async_client, payer, payer, stake.public_key, validator)
-
-
-@pytest.mark.asyncio
-async def test_authorize_stake(async_client, payer):
-    stake = Keypair()
-    new_authority = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, MINIMUM_DELEGATION)
-    await asyncio.gather(
-        authorize(async_client, payer, payer, stake.public_key, new_authority.public_key, StakeAuthorize.STAKER),
-        authorize(async_client, payer, payer, stake.public_key, new_authority.public_key, StakeAuthorize.WITHDRAWER)
-    )
-    await authorize(async_client, payer, new_authority, stake.public_key, payer.public_key, StakeAuthorize.WITHDRAWER)
diff --git a/stake-pool/py/tests/test_system.py b/stake-pool/py/tests/test_system.py
deleted file mode 100644
index 31d2af3437a..00000000000
--- a/stake-pool/py/tests/test_system.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import pytest
-from solana.keypair import Keypair
-from solana.rpc.commitment import Confirmed
-
-import system.actions
-
-
-@pytest.mark.asyncio
-async def test_airdrop(async_client):
-    manager = Keypair()
-    airdrop_lamports = 1_000_000
-    await system.actions.airdrop(async_client, manager.public_key, airdrop_lamports)
-    resp = await async_client.get_balance(manager.public_key, commitment=Confirmed)
-    assert resp['result']['value'] == airdrop_lamports
diff --git a/stake-pool/py/tests/test_token.py b/stake-pool/py/tests/test_token.py
deleted file mode 100644
index 1d92c179db7..00000000000
--- a/stake-pool/py/tests/test_token.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import pytest
-from solana.keypair import Keypair
-
-from spl_token.actions import create_mint, create_associated_token_account
-
-
-@pytest.mark.asyncio
-async def test_create_mint(async_client, payer):
-    pool_mint = Keypair()
-    await create_mint(async_client, payer, pool_mint, payer.public_key)
-    await create_associated_token_account(
-        async_client,
-        payer,
-        payer.public_key,
-        pool_mint.public_key,
-    )
diff --git a/stake-pool/py/tests/test_vote.py b/stake-pool/py/tests/test_vote.py
deleted file mode 100644
index b0861d465fd..00000000000
--- a/stake-pool/py/tests/test_vote.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import pytest
-from solana.keypair import Keypair
-from solana.publickey import PublicKey
-from solana.rpc.commitment import Confirmed
-
-from vote.actions import create_vote
-from vote.constants import VOTE_PROGRAM_ID
-
-
-@pytest.mark.asyncio
-async def test_create_vote(async_client, payer):
-    vote = Keypair()
-    node = Keypair()
-    await create_vote(async_client, payer, vote, node, payer.public_key, payer.public_key, 10)
-    resp = await async_client.get_account_info(vote.public_key, commitment=Confirmed)
-    assert PublicKey(resp['result']['value']['owner']) == VOTE_PROGRAM_ID
diff --git a/stake-pool/py/vote/__init__.py b/stake-pool/py/vote/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/stake-pool/py/vote/actions.py b/stake-pool/py/vote/actions.py
deleted file mode 100644
index 9f3fc49f197..00000000000
--- a/stake-pool/py/vote/actions.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from solana.publickey import PublicKey
-from solana.keypair import Keypair
-from solana.rpc.async_api import AsyncClient
-from solana.rpc.commitment import Confirmed
-from solana.rpc.types import TxOpts
-from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY
-from solana.transaction import Transaction
-import solana.system_program as sys
-
-from vote.constants import VOTE_PROGRAM_ID, VOTE_STATE_LEN
-from vote.instructions import initialize, InitializeParams
-
-
-async def create_vote(
-        client: AsyncClient, payer: Keypair, vote: Keypair, node: Keypair,
-        voter: PublicKey, withdrawer: PublicKey, commission: int):
-    print(f"Creating vote account {vote.public_key}")
-    resp = await client.get_minimum_balance_for_rent_exemption(VOTE_STATE_LEN)
-    txn = Transaction()
-    txn.add(
-        sys.create_account(
-            sys.CreateAccountParams(
-                from_pubkey=payer.public_key,
-                new_account_pubkey=vote.public_key,
-                lamports=resp['result'],
-                space=VOTE_STATE_LEN,
-                program_id=VOTE_PROGRAM_ID,
-            )
-        )
-    )
-    txn.add(
-        initialize(
-            InitializeParams(
-                vote=vote.public_key,
-                rent_sysvar=SYSVAR_RENT_PUBKEY,
-                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
-                node=node.public_key,
-                authorized_voter=voter,
-                authorized_withdrawer=withdrawer,
-                commission=commission,
-            )
-        )
-    )
-    await client.send_transaction(
-        txn, payer, vote, node, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
diff --git a/stake-pool/py/vote/constants.py b/stake-pool/py/vote/constants.py
deleted file mode 100644
index 701c90a022f..00000000000
--- a/stake-pool/py/vote/constants.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from solana.publickey import PublicKey
-
-
-VOTE_PROGRAM_ID = PublicKey("Vote111111111111111111111111111111111111111")
-"""Program id for the native vote program."""
-
-VOTE_STATE_LEN: int = 3762
-"""Size of vote account."""
diff --git a/stake-pool/py/vote/instructions.py b/stake-pool/py/vote/instructions.py
deleted file mode 100644
index 267aeb4aa46..00000000000
--- a/stake-pool/py/vote/instructions.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""Vote Program Instructions."""
-
-from enum import IntEnum
-from typing import NamedTuple
-
-from construct import Bytes, Struct, Switch, Int8ul, Int32ul, Pass  # type: ignore
-
-from solana.publickey import PublicKey
-from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY
-from solana.transaction import AccountMeta, TransactionInstruction
-
-from vote.constants import VOTE_PROGRAM_ID
-
-PUBLIC_KEY_LAYOUT = Bytes(32)
-
-
-class InitializeParams(NamedTuple):
-    """Initialize vote account params."""
-
-    vote: PublicKey
-    """`[w]` Uninitialized vote account"""
-    rent_sysvar: PublicKey
-    """`[]` Rent sysvar."""
-    clock_sysvar: PublicKey
-    """`[]` Clock sysvar."""
-    node: PublicKey
-    """`[s]` New validator identity."""
-
-    authorized_voter: PublicKey
-    """The authorized voter for this vote account."""
-    authorized_withdrawer: PublicKey
-    """The authorized withdrawer for this vote account."""
-    commission: int
-    """Commission, represented as a percentage"""
-
-
-class InstructionType(IntEnum):
-    """Vote Instruction Types."""
-
-    INITIALIZE = 0
-    AUTHORIZE = 1
-    VOTE = 2
-    WITHDRAW = 3
-    UPDATE_VALIDATOR_IDENTITY = 4
-    UPDATE_COMMISSION = 5
-    VOTE_SWITCH = 6
-    AUTHORIZE_CHECKED = 7
-
-
-INITIALIZE_LAYOUT = Struct(
-    "node" / PUBLIC_KEY_LAYOUT,
-    "authorized_voter" / PUBLIC_KEY_LAYOUT,
-    "authorized_withdrawer" / PUBLIC_KEY_LAYOUT,
-    "commission" / Int8ul,
-)
-
-INSTRUCTIONS_LAYOUT = Struct(
-    "instruction_type" / Int32ul,
-    "args"
-    / Switch(
-        lambda this: this.instruction_type,
-        {
-            InstructionType.INITIALIZE: INITIALIZE_LAYOUT,
-            InstructionType.AUTHORIZE: Pass,  # TODO
-            InstructionType.VOTE: Pass,  # TODO
-            InstructionType.WITHDRAW: Pass,  # TODO
-            InstructionType.UPDATE_VALIDATOR_IDENTITY: Pass,  # TODO
-            InstructionType.UPDATE_COMMISSION: Pass,  # TODO
-            InstructionType.VOTE_SWITCH: Pass,  # TODO
-            InstructionType.AUTHORIZE_CHECKED: Pass,  # TODO
-        },
-    ),
-)
-
-
-def initialize(params: InitializeParams) -> TransactionInstruction:
-    """Creates a transaction instruction to initialize a new stake."""
-    data = INSTRUCTIONS_LAYOUT.build(
-        dict(
-            instruction_type=InstructionType.INITIALIZE,
-            args=dict(
-                node=bytes(params.node),
-                authorized_voter=bytes(params.authorized_voter),
-                authorized_withdrawer=bytes(params.authorized_withdrawer),
-                commission=params.commission,
-            ),
-        )
-    )
-    return TransactionInstruction(
-        keys=[
-            AccountMeta(pubkey=params.vote, is_signer=False, is_writable=True),
-            AccountMeta(pubkey=params.rent_sysvar or SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.clock_sysvar or SYSVAR_CLOCK_PUBKEY, is_signer=False, is_writable=False),
-            AccountMeta(pubkey=params.node, is_signer=True, is_writable=False),
-        ],
-        program_id=VOTE_PROGRAM_ID,
-        data=data,
-    )
diff --git a/stateless-asks/program/Cargo.toml b/stateless-asks/program/Cargo.toml
index f03f38eb2c0..2d4288f74c0 100644
--- a/stateless-asks/program/Cargo.toml
+++ b/stateless-asks/program/Cargo.toml
@@ -11,22 +11,23 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-borsh = "1.5.1"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [
+borsh = "1.5.3"
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [
   "no-entrypoint",
 ] }
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-thiserror = "1.0"
+spl-associated-token-account-client = { version = "2.0.0" }
+thiserror = "2.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[lints]
+workspace = true
diff --git a/stateless-asks/program/src/validation_utils.rs b/stateless-asks/program/src/validation_utils.rs
index 6014693672d..6e61b0d43f2 100644
--- a/stateless-asks/program/src/validation_utils.rs
+++ b/stateless-asks/program/src/validation_utils.rs
@@ -7,7 +7,7 @@ use {
         program_pack::{IsInitialized, Pack},
         pubkey::Pubkey,
     },
-    spl_associated_token_account::get_associated_token_address,
+    spl_associated_token_account_client::address::get_associated_token_address,
     spl_token::{self, state::Account},
 };
 
diff --git a/token-collection/program/Cargo.toml b/token-collection/program/Cargo.toml
index 9799aa97a4a..535315a2ae3 100644
--- a/token-collection/program/Cargo.toml
+++ b/token-collection/program/Cargo.toml
@@ -12,20 +12,20 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-solana-program = ">=1.18.11,<=2"
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-spl-program-error = { version = "0.4.0" , path = "../../libraries/program-error" }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-spl-token-group-example = { version = "0.2", path = "../../token-group/example", features = ["no-entrypoint"] }
-spl-token-group-interface = { version = "0.2.3", path = "../../token-group/interface" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-spl-type-length-value = { version = "0.4.3", path = "../../libraries/type-length-value" }
+solana-program = "2.1.0"
+spl-pod = { version = "0.5.0" }
+spl-program-error = { version = "0.6.0" }
+spl-token-2022 = { version = "6.0.0", features = ["no-entrypoint"] }
+spl-token-group-example = { version = "0.2", features = ["no-entrypoint"] }
+spl-token-group-interface = { version = "0.5.0" }
+spl-token-metadata-interface = { version = "0.6.0" }
+spl-type-length-value = { version = "0.7.0" }
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2", path = "../../libraries/discriminator" }
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
+spl-discriminator = { version = "0.4.0" }
+spl-token-client = { version = "0.13.0" }
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/token-collection/program/tests/setup.rs b/token-collection/program/tests/setup.rs
index 709f6f92943..363fc5c1b5a 100644
--- a/token-collection/program/tests/setup.rs
+++ b/token-collection/program/tests/setup.rs
@@ -89,7 +89,7 @@ pub async fn setup_group(
     mint: &Keypair,
     mint_authority: &Keypair,
     update_authority: Option<Pubkey>,
-    max_size: u32,
+    max_size: u64,
     rent_lamports: u64,
     space: usize,
 ) {
diff --git a/token-collection/program/tests/token_collection.rs b/token-collection/program/tests/token_collection.rs
index aeff8994ef8..79505163a43 100644
--- a/token-collection/program/tests/token_collection.rs
+++ b/token-collection/program/tests/token_collection.rs
@@ -325,7 +325,7 @@ async fn test_token_collection() {
         .data;
     let state = TlvStateBorrowed::unpack(&buffer).unwrap();
     let collection = state.get_first_value::<TokenGroup>().unwrap();
-    assert_eq!(u32::from(collection.size), 3);
+    assert_eq!(u64::from(collection.size), 3);
 
     // The "Snakes" collection should have 2 members
     let buffer = context
@@ -337,7 +337,7 @@ async fn test_token_collection() {
         .data;
     let state = TlvStateBorrowed::unpack(&buffer).unwrap();
     let collection = state.get_first_value::<TokenGroup>().unwrap();
-    assert_eq!(u32::from(collection.size), 2);
+    assert_eq!(u64::from(collection.size), 2);
 
     // The "Python" should be a member of 2 collections
     let buffer = context
diff --git a/token-group/README.md b/token-group/README.md
new file mode 100644
index 00000000000..cd23e7d1c8e
--- /dev/null
+++ b/token-group/README.md
@@ -0,0 +1,2 @@
+NOTE: The token-group interface, program, and clients are now maintained at
+[solana-program/token-group](https://github.com/solana-program/token-group).
diff --git a/token-group/example/Cargo.toml b/token-group/example/Cargo.toml
deleted file mode 100644
index 9c4d5d0a265..00000000000
--- a/token-group/example/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-name = "spl-token-group-example"
-version = "0.2.1"
-description = "Solana Program Library Token Group Example"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-solana-program = ">=1.18.11,<=2"
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-spl-token-group-interface = { version = "0.2.3", path = "../interface" }
-spl-type-length-value = { version = "0.4.3", path = "../../libraries/type-length-value" }
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2", path = "../../libraries/discriminator" }
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token-group/example/src/entrypoint.rs b/token-group/example/src/entrypoint.rs
deleted file mode 100644
index 0336a5f1c99..00000000000
--- a/token-group/example/src/entrypoint.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! Program entrypoint
-
-use {
-    crate::processor,
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    spl_token_group_interface::error::TokenGroupError,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = processor::process(program_id, accounts, instruction_data) {
-        error.print::<TokenGroupError>();
-        return Err(error);
-    }
-    Ok(())
-}
diff --git a/token-group/example/src/lib.rs b/token-group/example/src/lib.rs
deleted file mode 100644
index bd0da38115d..00000000000
--- a/token-group/example/src/lib.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//! Crate defining an example program for creating SPL token groups
-//! using the SPL Token Group interface.
-
-#![deny(missing_docs)]
-#![forbid(unsafe_code)]
-
-pub mod processor;
-
-#[cfg(not(feature = "no-entrypoint"))]
-mod entrypoint;
diff --git a/token-group/example/src/processor.rs b/token-group/example/src/processor.rs
deleted file mode 100644
index 4b86defc781..00000000000
--- a/token-group/example/src/processor.rs
+++ /dev/null
@@ -1,226 +0,0 @@
-//! Program state processor
-
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_2022::{extension::StateWithExtensions, state::Mint},
-    spl_token_group_interface::{
-        error::TokenGroupError,
-        instruction::{
-            InitializeGroup, TokenGroupInstruction, UpdateGroupAuthority, UpdateGroupMaxSize,
-        },
-        state::{TokenGroup, TokenGroupMember},
-    },
-    spl_type_length_value::state::TlvStateMut,
-};
-
-fn check_update_authority(
-    update_authority_info: &AccountInfo,
-    expected_update_authority: &OptionalNonZeroPubkey,
-) -> Result<(), ProgramError> {
-    if !update_authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let update_authority = Option::<Pubkey>::from(*expected_update_authority)
-        .ok_or(TokenGroupError::ImmutableGroup)?;
-    if update_authority != *update_authority_info.key {
-        return Err(TokenGroupError::IncorrectUpdateAuthority.into());
-    }
-    Ok(())
-}
-
-/// Processes an [InitializeGroup](enum.GroupInterfaceInstruction.html)
-/// instruction
-pub fn process_initialize_group(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: InitializeGroup,
-) -> ProgramResult {
-    // Assumes one has already created a mint for the group.
-    let account_info_iter = &mut accounts.iter();
-
-    // Accounts expected by this instruction:
-    //
-    //   0. `[w]`   Group
-    //   1. `[]`    Mint
-    //   2. `[s]`   Mint authority
-    let group_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let mint_authority_info = next_account_info(account_info_iter)?;
-
-    {
-        // IMPORTANT: this example program is designed to work with any
-        // program that implements the SPL token interface, so there is no
-        // ownership check on the mint account.
-        let mint_data = mint_info.try_borrow_data()?;
-        let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-
-        if !mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if mint.base.mint_authority.as_ref() != COption::Some(mint_authority_info.key) {
-            return Err(TokenGroupError::IncorrectMintAuthority.into());
-        }
-    }
-
-    // Allocate a TLV entry for the space and write it in
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    let (group, _) = state.init_value::<TokenGroup>(false)?;
-    *group = TokenGroup::new(mint_info.key, data.update_authority, data.max_size.into());
-
-    Ok(())
-}
-
-/// Processes an
-/// [UpdateGroupMaxSize](enum.GroupInterfaceInstruction.html)
-/// instruction
-pub fn process_update_group_max_size(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateGroupMaxSize,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    // Accounts expected by this instruction:
-    //
-    //   0. `[w]`   Group
-    //   1. `[s]`   Update authority
-    let group_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    let group = state.get_first_value_mut::<TokenGroup>()?;
-
-    check_update_authority(update_authority_info, &group.update_authority)?;
-
-    // Update the max size (zero-copy)
-    group.update_max_size(data.max_size.into())?;
-
-    Ok(())
-}
-
-/// Processes an
-/// [UpdateGroupAuthority](enum.GroupInterfaceInstruction.html)
-/// instruction
-pub fn process_update_group_authority(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateGroupAuthority,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    // Accounts expected by this instruction:
-    //
-    //   0. `[w]`   Group
-    //   1. `[s]`   Current update authority
-    let group_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    let group = state.get_first_value_mut::<TokenGroup>()?;
-
-    check_update_authority(update_authority_info, &group.update_authority)?;
-
-    // Update the authority (zero-copy)
-    group.update_authority = data.new_authority;
-
-    Ok(())
-}
-
-/// Processes an [InitializeMember](enum.GroupInterfaceInstruction.html)
-/// instruction
-pub fn process_initialize_member(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    // For this group, we are going to assume the group has been
-    // initialized, and we're also assuming a mint has been created for the
-    // member.
-    // Group members in this example can have their own separate
-    // metadata that differs from the metadata of the group, since
-    // metadata is not involved here.
-    let account_info_iter = &mut accounts.iter();
-
-    // Accounts expected by this instruction:
-    //
-    //   0. `[w]`   Member
-    //   1. `[]`    Member Mint
-    //   2. `[s]`   Member Mint authority
-    //   3. `[w]`   Group
-    //   4. `[s]`   Group update authority
-    let member_info = next_account_info(account_info_iter)?;
-    let member_mint_info = next_account_info(account_info_iter)?;
-    let member_mint_authority_info = next_account_info(account_info_iter)?;
-    let group_info = next_account_info(account_info_iter)?;
-    let group_update_authority_info = next_account_info(account_info_iter)?;
-
-    // Mint checks on the member
-    {
-        // IMPORTANT: this example program is designed to work with any
-        // program that implements the SPL token interface, so there is no
-        // ownership check on the mint account.
-        let member_mint_data = member_mint_info.try_borrow_data()?;
-        let member_mint = StateWithExtensions::<Mint>::unpack(&member_mint_data)?;
-
-        if !member_mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if member_mint.base.mint_authority.as_ref() != COption::Some(member_mint_authority_info.key)
-        {
-            return Err(TokenGroupError::IncorrectMintAuthority.into());
-        }
-    }
-
-    // Make sure the member account is not the same as the group account
-    if member_info.key == group_info.key {
-        return Err(TokenGroupError::MemberAccountIsGroupAccount.into());
-    }
-
-    // Increment the size of the group
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    let group = state.get_first_value_mut::<TokenGroup>()?;
-
-    check_update_authority(group_update_authority_info, &group.update_authority)?;
-    let member_number = group.increment_size()?;
-
-    // Allocate a TLV entry for the space and write it in
-    let mut buffer = member_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    // Note if `allow_repetition: true` is instead used here, one can initialize
-    // the same token as a member of multiple groups!
-    let (member, _) = state.init_value::<TokenGroupMember>(false)?;
-    *member = TokenGroupMember::new(member_mint_info.key, group_info.key, member_number);
-
-    Ok(())
-}
-
-/// Processes an `SplTokenGroupInstruction`
-pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-    let instruction = TokenGroupInstruction::unpack(input)?;
-    match instruction {
-        TokenGroupInstruction::InitializeGroup(data) => {
-            msg!("Instruction: InitializeGroup");
-            process_initialize_group(program_id, accounts, data)
-        }
-        TokenGroupInstruction::UpdateGroupMaxSize(data) => {
-            msg!("Instruction: UpdateGroupMaxSize");
-            process_update_group_max_size(program_id, accounts, data)
-        }
-        TokenGroupInstruction::UpdateGroupAuthority(data) => {
-            msg!("Instruction: UpdateGroupAuthority");
-            process_update_group_authority(program_id, accounts, data)
-        }
-        TokenGroupInstruction::InitializeMember(_) => {
-            msg!("Instruction: InitializeMember");
-            process_initialize_member(program_id, accounts)
-        }
-    }
-}
diff --git a/token-group/example/tests/initialize_group.rs b/token-group/example/tests/initialize_group.rs
deleted file mode 100644
index a6461324eb8..00000000000
--- a/token-group/example/tests/initialize_group.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod setup;
-
-use {
-    setup::{setup_mint, setup_program_test},
-    solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction},
-    solana_program_test::tokio,
-    solana_sdk::{
-        signature::Keypair,
-        signer::Signer,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_client::token::Token,
-    spl_token_group_interface::{instruction::initialize_group, state::TokenGroup},
-    spl_type_length_value::{
-        error::TlvError,
-        state::{TlvState, TlvStateBorrowed},
-    },
-};
-
-#[tokio::test]
-async fn test_initialize_group() {
-    let program_id = Pubkey::new_unique();
-    let group = Keypair::new();
-    let group_mint = Keypair::new();
-    let group_mint_authority = Keypair::new();
-
-    let group_state = TokenGroup::new(&group_mint.pubkey(), None.try_into().unwrap(), 50);
-
-    let (context, client, payer) = setup_program_test(&program_id).await;
-
-    let token_client = Token::new(
-        client,
-        &spl_token_2022::id(),
-        &group_mint.pubkey(),
-        Some(0),
-        payer.clone(),
-    );
-    setup_mint(&token_client, &group_mint, &group_mint_authority).await;
-
-    let mut context = context.lock().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroup>();
-    let rent_lamports = rent.minimum_balance(space);
-
-    // Fail: mint authority not signer
-    let mut init_group_ix = initialize_group(
-        &program_id,
-        &group.pubkey(),
-        &group_mint.pubkey(),
-        &group_mint_authority.pubkey(),
-        group_state.update_authority.try_into().unwrap(),
-        group_state.max_size.into(),
-    );
-    init_group_ix.accounts[2].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            init_group_ix,
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature)
-    );
-
-    // Success: create the group
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_group(
-                &program_id,
-                &group.pubkey(),
-                &group_mint.pubkey(),
-                &group_mint_authority.pubkey(),
-                group_state.update_authority.try_into().unwrap(),
-                group_state.max_size.into(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority, &group],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fetch the group account and ensure it matches our state
-    let fetched_group_account = context
-        .banks_client
-        .get_account(group.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
-    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
-    assert_eq!(fetched_group_state, &group_state);
-
-    // Fail: can't initialize twice
-    let transaction = Transaction::new_signed_with_payer(
-        &[initialize_group(
-            &program_id,
-            &group.pubkey(),
-            &group_mint.pubkey(),
-            &group_mint_authority.pubkey(),
-            Pubkey::new_unique().into(), // Intentionally changed
-            group_state.max_size.into(),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TlvError::TypeAlreadyExists as u32)
-        )
-    );
-}
diff --git a/token-group/example/tests/initialize_member.rs b/token-group/example/tests/initialize_member.rs
deleted file mode 100644
index b0f7193d3cc..00000000000
--- a/token-group/example/tests/initialize_member.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod setup;
-
-use {
-    setup::{setup_mint, setup_program_test},
-    solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction},
-    solana_program_test::tokio,
-    solana_sdk::{
-        signature::Keypair,
-        signer::Signer,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_client::token::Token,
-    spl_token_group_interface::{
-        error::TokenGroupError,
-        instruction::{initialize_group, initialize_member},
-        state::{TokenGroup, TokenGroupMember},
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
-};
-
-#[tokio::test]
-async fn test_initialize_group_member() {
-    let program_id = Pubkey::new_unique();
-    let group = Keypair::new();
-    let group_mint = Keypair::new();
-    let group_mint_authority = Keypair::new();
-    let group_update_authority = Keypair::new();
-    let member = Keypair::new();
-    let member_mint = Keypair::new();
-    let member_mint_authority = Keypair::new();
-
-    let group_state = TokenGroup::new(
-        &group_mint.pubkey(),
-        Some(group_update_authority.pubkey()).try_into().unwrap(),
-        50,
-    );
-
-    let (context, client, payer) = setup_program_test(&program_id).await;
-
-    setup_mint(
-        &Token::new(
-            client.clone(),
-            &spl_token_2022::id(),
-            &group_mint.pubkey(),
-            Some(0),
-            payer.clone(),
-        ),
-        &group_mint,
-        &group_mint_authority,
-    )
-    .await;
-    setup_mint(
-        &Token::new(
-            client.clone(),
-            &spl_token_2022::id(),
-            &member_mint.pubkey(),
-            Some(0),
-            payer.clone(),
-        ),
-        &member_mint,
-        &member_mint_authority,
-    )
-    .await;
-
-    let mut context = context.lock().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroup>();
-    let rent_lamports = rent.minimum_balance(space);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_group(
-                &program_id,
-                &group.pubkey(),
-                &group_mint.pubkey(),
-                &group_mint_authority.pubkey(),
-                group_state.update_authority.try_into().unwrap(),
-                group_state.max_size.into(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority, &group],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let member_space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroupMember>();
-    let member_rent_lamports = rent.minimum_balance(member_space);
-
-    // Fail: member mint authority not signer
-    let mut init_member_ix = initialize_member(
-        &program_id,
-        &member.pubkey(),
-        &member_mint.pubkey(),
-        &member_mint_authority.pubkey(),
-        &group.pubkey(),
-        &group_update_authority.pubkey(),
-    );
-    init_member_ix.accounts[2].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &member.pubkey(),
-                member_rent_lamports,
-                member_space.try_into().unwrap(),
-                &program_id,
-            ),
-            init_member_ix,
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &member, &group_update_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature)
-    );
-
-    // Fail: group update authority not signer
-    let mut init_member_ix = initialize_member(
-        &program_id,
-        &member.pubkey(),
-        &member_mint.pubkey(),
-        &member_mint_authority.pubkey(),
-        &group.pubkey(),
-        &group_update_authority.pubkey(),
-    );
-    init_member_ix.accounts[4].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &member.pubkey(),
-                member_rent_lamports,
-                member_space.try_into().unwrap(),
-                &program_id,
-            ),
-            init_member_ix,
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &member, &member_mint_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature)
-    );
-
-    // Fail: member account is group account
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &member.pubkey(),
-                member_rent_lamports,
-                member_space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_member(
-                &program_id,
-                &member.pubkey(),
-                &member_mint.pubkey(),
-                &member_mint_authority.pubkey(),
-                &member.pubkey(),
-                &group_update_authority.pubkey(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[
-            &context.payer,
-            &member,
-            &member_mint_authority,
-            &group_update_authority,
-        ],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            1,
-            InstructionError::Custom(TokenGroupError::MemberAccountIsGroupAccount as u32)
-        )
-    );
-
-    // Success: initialize member
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &member.pubkey(),
-                member_rent_lamports,
-                member_space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_member(
-                &program_id,
-                &member.pubkey(),
-                &member_mint.pubkey(),
-                &member_mint_authority.pubkey(),
-                &group.pubkey(),
-                &group_update_authority.pubkey(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[
-            &context.payer,
-            &member,
-            &member_mint_authority,
-            &group_update_authority,
-        ],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fetch the member account and ensure it matches our state
-    let member_account = context
-        .banks_client
-        .get_account(member.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let fetched_meta = TlvStateBorrowed::unpack(&member_account.data).unwrap();
-    let fetched_group_member_state = fetched_meta.get_first_value::<TokenGroupMember>().unwrap();
-    assert_eq!(fetched_group_member_state.group, group.pubkey());
-    assert_eq!(u32::from(fetched_group_member_state.member_number), 1);
-}
diff --git a/token-group/example/tests/setup.rs b/token-group/example/tests/setup.rs
deleted file mode 100644
index 14cb091830c..00000000000
--- a/token-group/example/tests/setup.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio::sync::Mutex, ProgramTest, ProgramTestContext},
-    solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer},
-    spl_token_client::{
-        client::{
-            ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient,
-            SendTransaction, SimulateTransaction,
-        },
-        token::Token,
-    },
-    std::sync::Arc,
-};
-
-/// Set up a program test
-pub async fn setup_program_test(
-    program_id: &Pubkey,
-) -> (
-    Arc<Mutex<ProgramTestContext>>,
-    Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>>,
-    Arc<Keypair>,
-) {
-    let mut program_test = ProgramTest::new(
-        "spl_token_group_example",
-        *program_id,
-        processor!(spl_token_group_example::processor::process),
-    );
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(spl_token_2022::processor::Processor::process),
-    );
-    let context = program_test.start_with_context().await;
-    let payer = Arc::new(context.payer.insecure_clone());
-    let context = Arc::new(Mutex::new(context));
-    let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
-        Arc::new(ProgramBanksClient::new_from_context(
-            Arc::clone(&context),
-            ProgramBanksClientProcessTransaction,
-        ));
-    (context, client, payer)
-}
-
-/// Set up a Token-2022 mint
-pub async fn setup_mint<T: SendTransaction + SimulateTransaction>(
-    token_client: &Token<T>,
-    mint_keypair: &Keypair,
-    mint_authority_keypair: &Keypair,
-) {
-    token_client
-        .create_mint(
-            &mint_authority_keypair.pubkey(),
-            None,
-            vec![],
-            &[mint_keypair],
-        )
-        .await
-        .unwrap();
-}
diff --git a/token-group/example/tests/update_group_authority.rs b/token-group/example/tests/update_group_authority.rs
deleted file mode 100644
index 35c74ec8682..00000000000
--- a/token-group/example/tests/update_group_authority.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod setup;
-
-use {
-    setup::{setup_mint, setup_program_test},
-    solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction},
-    solana_program_test::tokio,
-    solana_sdk::{
-        signature::Keypair,
-        signer::Signer,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_client::token::Token,
-    spl_token_group_interface::{
-        error::TokenGroupError,
-        instruction::{initialize_group, update_group_authority},
-        state::TokenGroup,
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
-};
-
-#[tokio::test]
-async fn test_update_group_authority() {
-    let program_id = Pubkey::new_unique();
-    let group = Keypair::new();
-    let group_mint = Keypair::new();
-    let group_mint_authority = Keypair::new();
-    let group_update_authority = Keypair::new();
-
-    let group_state = TokenGroup::new(
-        &group_mint.pubkey(),
-        Some(group_update_authority.pubkey()).try_into().unwrap(),
-        50,
-    );
-
-    let (context, client, payer) = setup_program_test(&program_id).await;
-
-    let token_client = Token::new(
-        client,
-        &spl_token_2022::id(),
-        &group_mint.pubkey(),
-        Some(0),
-        payer.clone(),
-    );
-    setup_mint(&token_client, &group_mint, &group_mint_authority).await;
-
-    let mut context = context.lock().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroup>();
-    let rent_lamports = rent.minimum_balance(space);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_group(
-                &program_id,
-                &group.pubkey(),
-                &group_mint.pubkey(),
-                &group_mint_authority.pubkey(),
-                group_state.update_authority.try_into().unwrap(),
-                group_state.max_size.into(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority, &group],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fail: update authority not signer
-    let mut update_ix = update_group_authority(
-        &program_id,
-        &group.pubkey(),
-        &group_update_authority.pubkey(),
-        None,
-    );
-    update_ix.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-
-    // Fail: incorrect update authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_authority(
-            &program_id,
-            &group.pubkey(),
-            &group.pubkey(),
-            None,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32)
-        )
-    );
-
-    // Success: update authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_authority(
-            &program_id,
-            &group.pubkey(),
-            &group_update_authority.pubkey(),
-            None,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_update_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fetch the account and assert the new authority
-    let fetched_group_account = context
-        .banks_client
-        .get_account(group.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
-    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
-    assert_eq!(
-        fetched_group_state.update_authority,
-        None.try_into().unwrap(),
-    );
-
-    // Fail: immutable group
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_authority(
-            &program_id,
-            &group.pubkey(),
-            &group_update_authority.pubkey(),
-            Some(group_update_authority.pubkey()),
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_update_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenGroupError::ImmutableGroup as u32)
-        )
-    );
-}
diff --git a/token-group/example/tests/update_group_max_size.rs b/token-group/example/tests/update_group_max_size.rs
deleted file mode 100644
index 412335bfc18..00000000000
--- a/token-group/example/tests/update_group_max_size.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod setup;
-
-use {
-    setup::{setup_mint, setup_program_test},
-    solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction},
-    solana_program_test::tokio,
-    solana_sdk::{
-        account::Account as SolanaAccount,
-        signature::Keypair,
-        signer::Signer,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_client::token::Token,
-    spl_token_group_interface::{
-        error::TokenGroupError,
-        instruction::{initialize_group, update_group_max_size},
-        state::TokenGroup,
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut},
-};
-
-#[tokio::test]
-async fn test_update_group_max_size() {
-    let program_id = Pubkey::new_unique();
-    let group = Keypair::new();
-    let group_mint = Keypair::new();
-    let group_mint_authority = Keypair::new();
-    let group_update_authority = Keypair::new();
-
-    let group_state = TokenGroup::new(
-        &group_mint.pubkey(),
-        Some(group_update_authority.pubkey()).try_into().unwrap(),
-        50,
-    );
-
-    let (context, client, payer) = setup_program_test(&program_id).await;
-
-    let token_client = Token::new(
-        client,
-        &spl_token_2022::id(),
-        &group_mint.pubkey(),
-        Some(0),
-        payer.clone(),
-    );
-    setup_mint(&token_client, &group_mint, &group_mint_authority).await;
-
-    let mut context = context.lock().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroup>();
-    let rent_lamports = rent.minimum_balance(space);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_group(
-                &program_id,
-                &group.pubkey(),
-                &group_mint.pubkey(),
-                &group_mint_authority.pubkey(),
-                group_state.update_authority.try_into().unwrap(),
-                group_state.max_size.into(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority, &group],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fail: update authority not signer
-    let mut update_ix = update_group_max_size(&program_id, &group.pubkey(), &group.pubkey(), 100);
-    update_ix.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_ix],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-    );
-
-    // Fail: incorrect update authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_max_size(
-            &program_id,
-            &group.pubkey(),
-            &group.pubkey(),
-            100,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32)
-        )
-    );
-
-    // Fail: size exceeds new max size
-    let fetched_group_account = context
-        .banks_client
-        .get_account(group.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let mut data = fetched_group_account.data;
-    let mut state = TlvStateMut::unpack(&mut data).unwrap();
-    let group_data = state.get_first_value_mut::<TokenGroup>().unwrap();
-    group_data.size = 30.into();
-    context.set_account(
-        &group.pubkey(),
-        &SolanaAccount {
-            data,
-            ..fetched_group_account
-        }
-        .into(),
-    );
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_max_size(
-            &program_id,
-            &group.pubkey(),
-            &group_update_authority.pubkey(),
-            20,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_update_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenGroupError::SizeExceedsNewMaxSize as u32)
-        )
-    );
-
-    // Success: update max size
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_max_size(
-            &program_id,
-            &group.pubkey(),
-            &group_update_authority.pubkey(),
-            100,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_update_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Fetch the account and assert the new max size
-    let fetched_group_account = context
-        .banks_client
-        .get_account(group.pubkey())
-        .await
-        .unwrap()
-        .unwrap();
-    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
-    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
-    assert_eq!(fetched_group_state.max_size, 100.into());
-}
-
-// Fail: immutable group
-#[tokio::test]
-async fn test_update_group_max_size_fail_immutable_group() {
-    let program_id = Pubkey::new_unique();
-    let group = Keypair::new();
-    let group_mint = Keypair::new();
-    let group_mint_authority = Keypair::new();
-    let group_update_authority = Keypair::new();
-
-    let group_state = TokenGroup::new(
-        &group_mint.pubkey(),
-        Some(group_update_authority.pubkey()).try_into().unwrap(),
-        50,
-    );
-
-    let (context, client, payer) = setup_program_test(&program_id).await;
-
-    let token_client = Token::new(
-        client,
-        &spl_token_2022::id(),
-        &group_mint.pubkey(),
-        Some(0),
-        payer.clone(),
-    );
-    setup_mint(&token_client, &group_mint, &group_mint_authority).await;
-
-    let mut context = context.lock().await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroup>();
-    let rent_lamports = rent.minimum_balance(space);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &group.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_group(
-                &program_id,
-                &group.pubkey(),
-                &group_mint.pubkey(),
-                &group_mint_authority.pubkey(),
-                None,
-                group_state.max_size.into(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_mint_authority, &group],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_group_max_size(
-            &program_id,
-            &group.pubkey(),
-            &group_update_authority.pubkey(),
-            100,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &group_update_authority],
-        context.last_blockhash,
-    );
-    assert_eq!(
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenGroupError::ImmutableGroup as u32)
-        )
-    );
-}
diff --git a/token-group/interface/Cargo.toml b/token-group/interface/Cargo.toml
deleted file mode 100644
index f06024adea9..00000000000
--- a/token-group/interface/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-[package]
-name = "spl-token-group-interface"
-version = "0.2.3"
-description = "Solana Program Library Token Group Interface"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-bytemuck = "1.16.0"
-solana-program = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2" , path = "../../libraries/discriminator" }
-spl-pod = { version = "0.2.2" , path = "../../libraries/pod", features = ["borsh"] }
-spl-program-error = { version = "0.4.0" , path = "../../libraries/program-error" }
-
-[dev-dependencies]
-spl-type-length-value = { version = "0.4.3", path = "../../libraries/type-length-value", features = ["derive"] }
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token-group/interface/README.md b/token-group/interface/README.md
deleted file mode 100644
index e221d7f7d63..00000000000
--- a/token-group/interface/README.md
+++ /dev/null
@@ -1,138 +0,0 @@
-## Token-Group Interface
-
-An interface describing the instructions required for a program to implement
-to be considered a "token-group" program for SPL token mints. The interface can
-be implemented by any program.
-
-With a common interface, any wallet, dapp, or on-chain program can read the
-group or member configurations, and any tool that creates or modifies group
-or member configurations will just work with any program that implements the
-interface.
-
-This interface is compatible with any program that implements the SPL Token
-interface. However, other program implementations that are not SPL Token
-programs may still be compatible with an SPL Token Group program should that
-program's token standard support the proper components such as mint and mint
-authority accounts (see [Required Instructions](#required-instructions)).
-
-There are also structs for `TokenGroup` and `TokenGroupMember` that may
-optionally be implemented, but are not required.
-
-### Example program
-
-An example program demonstrating how to implement the SPL Token-Group Interface
-can be found in the
-[example](https://github.com/solana-labs/solana-program-library/tree/master/token-group/example)
-directory alongside this interface's directory.
-
-In addition to demonstrating what a token-group program might look like, it
-also provides some reference examples for using the SPL Type Length Value
-library to manage TLV-encoded data within account data.
-
-For more information on SPL Type Length Value you can reference the library's
-[source code](https://github.com/solana-labs/solana-program-library/tree/master/libraries/type-length-value).
-
-### Motivation
-
-As developers have engineered more creative ways to customize tokens and use
-them to power applications, communities, and more, the reliance on tokens that
-are intrinsically related through on-chain mapping has continued to strengthen.
-
-Token-group provides developers with the minimum necessary interface components
-required to create these relational mappings, allowing for reliable
-composability as well as the freedom to customize these groups of tokens
-however one might please.
-
-By implementing token-group, on-chain programs can build brand-new kinds of
-token groups, which can all overlap with each other and share common tooling.
-
-### Required Instructions
-
-All of the following instructions are listed in greater detail in the source code.
-
-- [`InitializeGroup`](https://github.com/solana-labs/solana-program-library/blob/master/token-group/interface/src/instruction.rs#L22)
-- [`UpdateGroupMaxSize`](https://github.com/solana-labs/solana-program-library/blob/master/token-group/interface/src/instruction.rs#L33)
-- [`UpdateGroupAuthority`](https://github.com/solana-labs/solana-program-library/blob/master/token-group/interface/src/instruction.rs#L42)
-- [`InitializeMember`](https://github.com/solana-labs/solana-program-library/blob/master/token-group/interface/src/instruction.rs#L51)
-
-#### Initialize Group
-
-Initializes a token-group TLV entry in an account for group configurations with
-a provided maximum group size and update authority.
-
-Must provide an SPL token mint and be signed by the mint authority.
-
-#### Update Group Max Size
-
-Updates the maximum size limit of a group.
-
-Must be signed by the update authority.
-
-#### Update Group Authority
-
-Sets or unsets the token-group update authority, which signs any future updates
-to the group configurations.
-
-Must be signed by the update authority.
-
-#### Initialize Member
-
-Initializes a token-group TLV entry in an account for group member
-configurations.
-
-Must provide an SPL token mint for both the group and the group member.
-
-Must be signed by the member mint's mint authority _and_ the group's update
-authority.
-
-### (Optional) State
-
-A program that implements the interface may write the following data fields
-into a type-length-value entry into an account. Note the type discriminants
-for each.
-
-For a group:
-
-```rust
-type OptionalNonZeroPubkey = Pubkey; // if all zeroes, interpreted as `None`
-type PodU32 = [u8; 4];
-type Pubkey = [u8; 32];
-
-/// Type discriminant: [214, 15, 63, 132, 49, 119, 209, 40]
-/// First 8 bytes of `hash("spl_token_group_interface:group")`
-pub struct TokenGroup {
-    /// The authority that can sign to update the group
-    pub update_authority: OptionalNonZeroPubkey,
-    /// The associated mint, used to counter spoofing to be sure that group
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The current number of group members
-    pub size: PodU32,
-    /// The maximum number of group members
-    pub max_size: PodU32,
-}
-```
-
-For a group member:
-
-```rust
-/// Type discriminant: [254, 50, 168, 134, 88, 126, 100, 186]
-/// First 8 bytes of `hash("spl_token_group_interface:member")`
-pub struct TokenGroupMember {
-    /// The associated mint, used to counter spoofing to be sure that member
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The pubkey of the `TokenGroup`
-    pub group: Pubkey,
-    /// The member number
-    pub member_number: PodU32,
-}
-```
-
-By storing the configurations for either groups or group members in a TLV
-structure, a developer who implements this interface can freely add any other
-data fields in a different TLV entry.
-
-As mentioned previously, you can find more information about
-TLV / type-length-value structures at the
-[spl-type-length-value repo](https://github.com/solana-labs/solana-program-library/tree/master/libraries/type-length-value).
\ No newline at end of file
diff --git a/token-group/interface/src/error.rs b/token-group/interface/src/error.rs
deleted file mode 100644
index ee9892fca37..00000000000
--- a/token-group/interface/src/error.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//! Interface error types
-
-use spl_program_error::*;
-
-/// Errors that may be returned by the interface.
-#[spl_program_error(hash_error_code_start = 3_406_457_176)]
-pub enum TokenGroupError {
-    /// Size is greater than proposed max size
-    #[error("Size is greater than proposed max size")]
-    SizeExceedsNewMaxSize,
-    /// Size is greater than max size
-    #[error("Size is greater than max size")]
-    SizeExceedsMaxSize,
-    /// Group is immutable
-    #[error("Group is immutable")]
-    ImmutableGroup,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-    /// Incorrect update authority has signed the instruction
-    #[error("Incorrect update authority has signed the instruction")]
-    IncorrectUpdateAuthority,
-    /// Member account should not be the same as the group account
-    #[error("Member account should not be the same as the group account")]
-    MemberAccountIsGroupAccount,
-}
diff --git a/token-group/interface/src/instruction.rs b/token-group/interface/src/instruction.rs
deleted file mode 100644
index 67536d896bd..00000000000
--- a/token-group/interface/src/instruction.rs
+++ /dev/null
@@ -1,308 +0,0 @@
-//! Instruction types
-
-use {
-    bytemuck::{Pod, Zeroable},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_pod::{
-        bytemuck::{pod_bytes_of, pod_from_bytes},
-        optional_keys::OptionalNonZeroPubkey,
-        primitives::PodU32,
-    },
-};
-
-/// Instruction data for initializing a new `Group`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:initialize_token_group")]
-pub struct InitializeGroup {
-    /// Update authority for the group
-    pub update_authority: OptionalNonZeroPubkey,
-    /// The maximum number of group members
-    pub max_size: PodU32,
-}
-
-/// Instruction data for updating the max size of a `Group`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:update_group_max_size")]
-pub struct UpdateGroupMaxSize {
-    /// New max size for the group
-    pub max_size: PodU32,
-}
-
-/// Instruction data for updating the authority of a `Group`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:update_authority")]
-pub struct UpdateGroupAuthority {
-    /// New authority for the group, or unset if `None`
-    pub new_authority: OptionalNonZeroPubkey,
-}
-
-/// Instruction data for initializing a new `Member` of a `Group`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:initialize_member")]
-pub struct InitializeMember;
-
-/// All instructions that must be implemented in the SPL Token Group Interface
-#[derive(Clone, Debug, PartialEq)]
-pub enum TokenGroupInstruction {
-    /// Initialize a new `Group`
-    ///
-    /// Assumes one has already initialized a mint for the
-    /// group.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]`  Group
-    ///   1. `[]`   Mint
-    ///   2. `[s]`  Mint authority
-    InitializeGroup(InitializeGroup),
-
-    /// Update the max size of a `Group`
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]`  Group
-    ///   1. `[s]`  Update authority
-    UpdateGroupMaxSize(UpdateGroupMaxSize),
-
-    /// Update the authority of a `Group`
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]`  Group
-    ///   1. `[s]`  Current update authority
-    UpdateGroupAuthority(UpdateGroupAuthority),
-
-    /// Initialize a new `Member` of a `Group`
-    ///
-    /// Assumes the `Group` has already been initialized,
-    /// as well as the mint for the member.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]`  Member
-    ///   1. `[]`   Member mint
-    ///   1. `[s]`  Member mint authority
-    ///   2. `[w]`  Group
-    ///   3. `[s]`  Group update authority
-    InitializeMember(InitializeMember),
-}
-impl TokenGroupInstruction {
-    /// Unpacks a byte buffer into a `TokenGroupInstruction`
-    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
-        if input.len() < ArrayDiscriminator::LENGTH {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-        let (discriminator, rest) = input.split_at(ArrayDiscriminator::LENGTH);
-        Ok(match discriminator {
-            InitializeGroup::SPL_DISCRIMINATOR_SLICE => {
-                let data = pod_from_bytes::<InitializeGroup>(rest)?;
-                Self::InitializeGroup(*data)
-            }
-            UpdateGroupMaxSize::SPL_DISCRIMINATOR_SLICE => {
-                let data = pod_from_bytes::<UpdateGroupMaxSize>(rest)?;
-                Self::UpdateGroupMaxSize(*data)
-            }
-            UpdateGroupAuthority::SPL_DISCRIMINATOR_SLICE => {
-                let data = pod_from_bytes::<UpdateGroupAuthority>(rest)?;
-                Self::UpdateGroupAuthority(*data)
-            }
-            InitializeMember::SPL_DISCRIMINATOR_SLICE => {
-                let data = pod_from_bytes::<InitializeMember>(rest)?;
-                Self::InitializeMember(*data)
-            }
-            _ => return Err(ProgramError::InvalidInstructionData),
-        })
-    }
-
-    /// Packs a `TokenGroupInstruction` into a byte buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = vec![];
-        match self {
-            Self::InitializeGroup(data) => {
-                buf.extend_from_slice(InitializeGroup::SPL_DISCRIMINATOR_SLICE);
-                buf.extend_from_slice(pod_bytes_of(data));
-            }
-            Self::UpdateGroupMaxSize(data) => {
-                buf.extend_from_slice(UpdateGroupMaxSize::SPL_DISCRIMINATOR_SLICE);
-                buf.extend_from_slice(pod_bytes_of(data));
-            }
-            Self::UpdateGroupAuthority(data) => {
-                buf.extend_from_slice(UpdateGroupAuthority::SPL_DISCRIMINATOR_SLICE);
-                buf.extend_from_slice(pod_bytes_of(data));
-            }
-            Self::InitializeMember(data) => {
-                buf.extend_from_slice(InitializeMember::SPL_DISCRIMINATOR_SLICE);
-                buf.extend_from_slice(pod_bytes_of(data));
-            }
-        };
-        buf
-    }
-}
-
-/// Creates a `InitializeGroup` instruction
-pub fn initialize_group(
-    program_id: &Pubkey,
-    group: &Pubkey,
-    mint: &Pubkey,
-    mint_authority: &Pubkey,
-    update_authority: Option<Pubkey>,
-    max_size: u32,
-) -> Instruction {
-    let update_authority = OptionalNonZeroPubkey::try_from(update_authority)
-        .expect("Failed to deserialize `Option<Pubkey>`");
-    let data = TokenGroupInstruction::InitializeGroup(InitializeGroup {
-        update_authority,
-        max_size: max_size.into(),
-    })
-    .pack();
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*group, false),
-            AccountMeta::new_readonly(*mint, false),
-            AccountMeta::new_readonly(*mint_authority, true),
-        ],
-        data,
-    }
-}
-
-/// Creates a `UpdateGroupMaxSize` instruction
-pub fn update_group_max_size(
-    program_id: &Pubkey,
-    group: &Pubkey,
-    update_authority: &Pubkey,
-    max_size: u32,
-) -> Instruction {
-    let data = TokenGroupInstruction::UpdateGroupMaxSize(UpdateGroupMaxSize {
-        max_size: max_size.into(),
-    })
-    .pack();
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*group, false),
-            AccountMeta::new_readonly(*update_authority, true),
-        ],
-        data,
-    }
-}
-
-/// Creates a `UpdateGroupAuthority` instruction
-pub fn update_group_authority(
-    program_id: &Pubkey,
-    group: &Pubkey,
-    current_authority: &Pubkey,
-    new_authority: Option<Pubkey>,
-) -> Instruction {
-    let new_authority = OptionalNonZeroPubkey::try_from(new_authority)
-        .expect("Failed to deserialize `Option<Pubkey>`");
-    let data =
-        TokenGroupInstruction::UpdateGroupAuthority(UpdateGroupAuthority { new_authority }).pack();
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*group, false),
-            AccountMeta::new_readonly(*current_authority, true),
-        ],
-        data,
-    }
-}
-
-/// Creates a `InitializeMember` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn initialize_member(
-    program_id: &Pubkey,
-    member: &Pubkey,
-    member_mint: &Pubkey,
-    member_mint_authority: &Pubkey,
-    group: &Pubkey,
-    group_update_authority: &Pubkey,
-) -> Instruction {
-    let data = TokenGroupInstruction::InitializeMember(InitializeMember {}).pack();
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*member, false),
-            AccountMeta::new_readonly(*member_mint, false),
-            AccountMeta::new_readonly(*member_mint_authority, true),
-            AccountMeta::new(*group, false),
-            AccountMeta::new_readonly(*group_update_authority, true),
-        ],
-        data,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, crate::NAMESPACE, solana_program::hash};
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable, SplDiscriminate)]
-    #[discriminator_hash_input("mock_group")]
-    struct MockGroup;
-
-    fn instruction_pack_unpack<I>(instruction: TokenGroupInstruction, discriminator: &[u8], data: I)
-    where
-        I: core::fmt::Debug + PartialEq + Pod + Zeroable + SplDiscriminate,
-    {
-        let mut expect = vec![];
-        expect.extend_from_slice(discriminator.as_ref());
-        expect.extend_from_slice(pod_bytes_of(&data));
-        let packed = instruction.pack();
-        assert_eq!(packed, expect);
-        let unpacked = TokenGroupInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, instruction);
-    }
-
-    #[test]
-    fn initialize_group_pack() {
-        let data = InitializeGroup {
-            update_authority: OptionalNonZeroPubkey::default(),
-            max_size: 100.into(),
-        };
-        let instruction = TokenGroupInstruction::InitializeGroup(data);
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:initialize_token_group").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        instruction_pack_unpack::<InitializeGroup>(instruction, discriminator, data);
-    }
-
-    #[test]
-    fn update_group_max_size_pack() {
-        let data = UpdateGroupMaxSize {
-            max_size: 200.into(),
-        };
-        let instruction = TokenGroupInstruction::UpdateGroupMaxSize(data);
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:update_group_max_size").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        instruction_pack_unpack::<UpdateGroupMaxSize>(instruction, discriminator, data);
-    }
-
-    #[test]
-    fn update_authority_pack() {
-        let data = UpdateGroupAuthority {
-            new_authority: OptionalNonZeroPubkey::default(),
-        };
-        let instruction = TokenGroupInstruction::UpdateGroupAuthority(data);
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:update_authority").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        instruction_pack_unpack::<UpdateGroupAuthority>(instruction, discriminator, data);
-    }
-
-    #[test]
-    fn initialize_member_pack() {
-        let data = InitializeMember {};
-        let instruction = TokenGroupInstruction::InitializeMember(data);
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:initialize_member").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        instruction_pack_unpack::<InitializeMember>(instruction, discriminator, data);
-    }
-}
diff --git a/token-group/interface/src/lib.rs b/token-group/interface/src/lib.rs
deleted file mode 100644
index 6867b86acf8..00000000000
--- a/token-group/interface/src/lib.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Crate defining the SPL Token Group Interface
-
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod error;
-pub mod instruction;
-pub mod state;
-
-/// Namespace for all programs implementing spl-token-group
-pub const NAMESPACE: &str = "spl_token_group_interface";
diff --git a/token-group/interface/src/state.rs b/token-group/interface/src/state.rs
deleted file mode 100644
index 9f73ecc442b..00000000000
--- a/token-group/interface/src/state.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-//! Interface state types
-
-use {
-    crate::error::TokenGroupError,
-    bytemuck::{Pod, Zeroable},
-    solana_program::{program_error::ProgramError, pubkey::Pubkey},
-    spl_discriminator::SplDiscriminate,
-    spl_pod::{error::PodSliceError, optional_keys::OptionalNonZeroPubkey, primitives::PodU32},
-};
-
-/// Data struct for a `TokenGroup`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:group")]
-pub struct TokenGroup {
-    /// The authority that can sign to update the group
-    pub update_authority: OptionalNonZeroPubkey,
-    /// The associated mint, used to counter spoofing to be sure that group
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The current number of group members
-    pub size: PodU32,
-    /// The maximum number of group members
-    pub max_size: PodU32,
-}
-
-impl TokenGroup {
-    /// Creates a new `TokenGroup` state
-    pub fn new(mint: &Pubkey, update_authority: OptionalNonZeroPubkey, max_size: u32) -> Self {
-        Self {
-            mint: *mint,
-            update_authority,
-            size: PodU32::default(), // [0, 0, 0, 0]
-            max_size: max_size.into(),
-        }
-    }
-
-    /// Updates the max size for a group
-    pub fn update_max_size(&mut self, new_max_size: u32) -> Result<(), ProgramError> {
-        // The new max size cannot be less than the current size
-        if new_max_size < u32::from(self.size) {
-            return Err(TokenGroupError::SizeExceedsNewMaxSize.into());
-        }
-        self.max_size = new_max_size.into();
-        Ok(())
-    }
-
-    /// Increment the size for a group, returning the new size
-    pub fn increment_size(&mut self) -> Result<u32, ProgramError> {
-        // The new size cannot be greater than the max size
-        let new_size = u32::from(self.size)
-            .checked_add(1)
-            .ok_or::<ProgramError>(PodSliceError::CalculationFailure.into())?;
-        if new_size > u32::from(self.max_size) {
-            return Err(TokenGroupError::SizeExceedsMaxSize.into());
-        }
-        self.size = new_size.into();
-        Ok(new_size)
-    }
-}
-
-/// Data struct for a `TokenGroupMember`
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_group_interface:member")]
-pub struct TokenGroupMember {
-    /// The associated mint, used to counter spoofing to be sure that member
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The pubkey of the `TokenGroup`
-    pub group: Pubkey,
-    /// The member number
-    pub member_number: PodU32,
-}
-impl TokenGroupMember {
-    /// Creates a new `TokenGroupMember` state
-    pub fn new(mint: &Pubkey, group: &Pubkey, member_number: u32) -> Self {
-        Self {
-            mint: *mint,
-            group: *group,
-            member_number: member_number.into(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::NAMESPACE,
-        solana_program::hash,
-        spl_discriminator::ArrayDiscriminator,
-        spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut},
-        std::mem::size_of,
-    };
-
-    #[test]
-    fn discriminators() {
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:group").as_bytes()]);
-        let discriminator =
-            ArrayDiscriminator::try_from(&preimage.as_ref()[..ArrayDiscriminator::LENGTH]).unwrap();
-        assert_eq!(TokenGroup::SPL_DISCRIMINATOR, discriminator);
-
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:member").as_bytes()]);
-        let discriminator =
-            ArrayDiscriminator::try_from(&preimage.as_ref()[..ArrayDiscriminator::LENGTH]).unwrap();
-        assert_eq!(TokenGroupMember::SPL_DISCRIMINATOR, discriminator);
-    }
-
-    #[test]
-    fn tlv_state_pack() {
-        // Make sure we can pack more than one instance of each type
-        let group = TokenGroup {
-            mint: Pubkey::new_unique(),
-            update_authority: OptionalNonZeroPubkey::try_from(Some(Pubkey::new_unique())).unwrap(),
-            size: 10.into(),
-            max_size: 20.into(),
-        };
-
-        let member = TokenGroupMember {
-            mint: Pubkey::new_unique(),
-            group: Pubkey::new_unique(),
-            member_number: 0.into(),
-        };
-
-        let account_size = TlvStateBorrowed::get_base_len()
-            + size_of::<TokenGroup>()
-            + TlvStateBorrowed::get_base_len()
-            + size_of::<TokenGroupMember>();
-        let mut buffer = vec![0; account_size];
-        let mut state = TlvStateMut::unpack(&mut buffer).unwrap();
-
-        let group_data = state.init_value::<TokenGroup>(false).unwrap().0;
-        *group_data = group;
-
-        let member_data = state.init_value::<TokenGroupMember>(false).unwrap().0;
-        *member_data = member;
-
-        assert_eq!(state.get_first_value::<TokenGroup>().unwrap(), &group);
-        assert_eq!(
-            state.get_first_value::<TokenGroupMember>().unwrap(),
-            &member
-        );
-    }
-
-    #[test]
-    fn update_max_size() {
-        // Test with a `Some` max size
-        let max_size = 10;
-        let mut group = TokenGroup {
-            mint: Pubkey::new_unique(),
-            update_authority: OptionalNonZeroPubkey::try_from(Some(Pubkey::new_unique())).unwrap(),
-            size: 0.into(),
-            max_size: max_size.into(),
-        };
-
-        let new_max_size = 30;
-        group.update_max_size(new_max_size).unwrap();
-        assert_eq!(u32::from(group.max_size), new_max_size);
-
-        // Change the current size to 30
-        group.size = 30.into();
-
-        // Try to set the max size to 20, which is less than the current size
-        let new_max_size = 20;
-        assert_eq!(
-            group.update_max_size(new_max_size),
-            Err(ProgramError::from(TokenGroupError::SizeExceedsNewMaxSize))
-        );
-
-        let new_max_size = 30;
-        group.update_max_size(new_max_size).unwrap();
-        assert_eq!(u32::from(group.max_size), new_max_size);
-    }
-
-    #[test]
-    fn increment_current_size() {
-        let mut group = TokenGroup {
-            mint: Pubkey::new_unique(),
-            update_authority: OptionalNonZeroPubkey::try_from(Some(Pubkey::new_unique())).unwrap(),
-            size: 0.into(),
-            max_size: 1.into(),
-        };
-
-        group.increment_size().unwrap();
-        assert_eq!(u32::from(group.size), 1);
-
-        // Try to increase the current size to 2, which is greater than the max size
-        assert_eq!(
-            group.increment_size(),
-            Err(ProgramError::from(TokenGroupError::SizeExceedsMaxSize))
-        );
-    }
-}
diff --git a/token-group/js/.eslintignore b/token-group/js/.eslintignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token-group/js/.eslintignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token-group/js/.eslintrc b/token-group/js/.eslintrc
deleted file mode 100644
index 5aef10a4729..00000000000
--- a/token-group/js/.eslintrc
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "root": true,
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended",
-        "plugin:require-extensions/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier",
-        "require-extensions"
-    ],
-    "rules": {
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/consistent-type-imports": "error"
-    },
-    "overrides": [
-        {
-            "files": [
-                "examples/**/*",
-                "test/**/*"
-            ],
-            "rules": {
-                "require-extensions/require-extensions": "off",
-                "require-extensions/require-index": "off"
-            }
-        }
-    ]
-}
diff --git a/token-group/js/.gitignore b/token-group/js/.gitignore
deleted file mode 100644
index 21f33db819c..00000000000
--- a/token-group/js/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.idea
-.vscode
-.DS_Store
-
-node_modules
-
-pnpm-lock.yaml
-yarn.lock
-
-docs
-lib
-test-ledger
-*.tsbuildinfo
diff --git a/token-group/js/.mocharc.json b/token-group/js/.mocharc.json
deleted file mode 100644
index 451c14c3016..00000000000
--- a/token-group/js/.mocharc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "extension": ["ts"],
-    "node-option": ["experimental-specifier-resolution=node", "loader=ts-node/esm"],
-    "timeout": 5000
-}
diff --git a/token-group/js/.nojekyll b/token-group/js/.nojekyll
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/token-group/js/.prettierignore b/token-group/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token-group/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token-group/js/.prettierrc b/token-group/js/.prettierrc
deleted file mode 100644
index b9ce4c1923a..00000000000
--- a/token-group/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "printWidth": 120,
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}
\ No newline at end of file
diff --git a/token-group/js/LICENSE b/token-group/js/LICENSE
deleted file mode 100644
index d6456956733..00000000000
--- a/token-group/js/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/token-group/js/README.md b/token-group/js/README.md
deleted file mode 100644
index bb5bd337bc0..00000000000
--- a/token-group/js/README.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# `@solana/spl-token-group`
-
-A TypeScript interface describing the instructions required for a program to implement to be considered a "token-group" program for SPL token mints. The interface can be implemented by any program.
-
-## Links
-
-- [TypeScript Docs](https://solana-labs.github.io/solana-program-library/token-group/js/)
-- [FAQs (Frequently Asked Questions)](#faqs)
-- [Install](#install)
-- [Build from Source](#build-from-source)
-
-## FAQs
-
-### How can I get support?
-
-Please ask questions in the Solana Stack Exchange: https://solana.stackexchange.com/
-
-If you've found a bug or you'd like to request a feature, please
-[open an issue](https://github.com/solana-labs/solana-program-library/issues/new).
-
-## Install
-
-```shell
-npm install --save @solana/spl-token-group @solana/web3.js
-```
-_OR_
-```shell
-yarn add @solana/spl-token-group @solana/web3.js
-```
-
-## Build from Source
-
-0. Prerequisites
-
-* Node 16+
-* NPM 8+
-
-1. Clone the project:
-```shell
-git clone https://github.com/solana-labs/solana-program-library.git
-```
-
-2. Navigate to the library:
-```shell
-cd solana-program-library/token-group/js
-```
-
-3. Install the dependencies:
-```shell
-npm install
-```
-
-4. Build the library:
-```shell
-npm run build
-```
-
-5. Build the on-chain programs:
-```shell
-npm run test:build-programs
-```
diff --git a/token-group/js/package.json b/token-group/js/package.json
deleted file mode 100644
index 80581ae91df..00000000000
--- a/token-group/js/package.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-    "name": "@solana/spl-token-group",
-    "description": "SPL Token Group Interface JS API",
-    "version": "0.0.3",
-    "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "repository": "https://github.com/solana-labs/solana-program-library",
-    "license": "Apache-2.0",
-    "type": "module",
-    "sideEffects": false,
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "lib",
-        "src",
-        "LICENSE",
-        "README.md"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "./lib/cjs/index.js",
-    "module": "./lib/esm/index.js",
-    "types": "./lib/types/index.d.ts",
-    "exports": {
-        "types": "./lib/types/index.d.ts",
-        "require": "./lib/cjs/index.js",
-        "import": "./lib/esm/index.js"
-    },
-    "scripts": {
-        "build": "tsc --build --verbose tsconfig.all.json",
-        "clean": "shx rm -rf lib **/*.tsbuildinfo || true",
-        "deploy": "npm run deploy:docs",
-        "deploy:docs": "npm run docs && gh-pages --dest token-group/js --dist docs --dotfiles",
-        "docs": "shx rm -rf docs && typedoc && shx cp .nojekyll docs/",
-        "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-        "lint": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}' && eslint --max-warnings 0 .",
-        "lint:fix": "npm run fmt && eslint --fix .",
-        "nuke": "shx rm -rf node_modules package-lock.json || true",
-        "postbuild": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json",
-        "reinstall": "npm run nuke && npm install",
-        "release": "npm run clean && npm run build",
-        "test": "mocha test",
-        "watch": "tsc --build --verbose --watch tsconfig.all.json"
-    },
-    "peerDependencies": {
-        "@solana/web3.js": "^1.93.0"
-    },
-    "dependencies": {
-        "@solana/codecs": "2.0.0-preview.3",
-        "@solana/spl-type-length-value": "0.1.0"
-    },
-    "devDependencies": {
-        "@solana/web3.js": "^1.93.0",
-        "@types/chai": "^4.3.16",
-        "@types/mocha": "^10.0.6",
-        "@types/node": "^20.14.5",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
-        "chai": "^5.1.1",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "eslint-plugin-require-extensions": "^0.1.1",
-        "gh-pages": "^6.1.1",
-        "mocha": "^10.4.0",
-        "prettier": "^3.3.2",
-        "shx": "^0.3.4",
-        "ts-node": "^10.9.2",
-        "tslib": "^2.6.3",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
-    }
-}
diff --git a/token-group/js/src/errors.ts b/token-group/js/src/errors.ts
deleted file mode 100644
index fc93a33960d..00000000000
--- a/token-group/js/src/errors.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-export class TokenGroupError extends Error {
-    constructor(message?: string) {
-        super(message);
-    }
-}
-
-/** Thrown if size is greater than proposed max size */
-export class SizeExceedsNewMaxSizeError extends TokenGroupError {
-    name = 'SizeExceedsNewMaxSizeError';
-}
-
-/** Thrown if size is greater than max size */
-export class SizeExceedsMaxSizeError extends TokenGroupError {
-    name = 'SizeExceedsMaxSizeError';
-}
-
-/** Thrown if group is immutable */
-export class ImmutableGroupError extends TokenGroupError {
-    name = 'ImmutableGroupError';
-}
-
-/** Thrown if incorrect mint authority has signed the instruction */
-export class IncorrectMintAuthorityError extends TokenGroupError {
-    name = 'IncorrectMintAuthorityError';
-}
-
-/** Thrown if incorrect update authority has signed the instruction */
-export class IncorrectUpdateAuthorityError extends TokenGroupError {
-    name = 'IncorrectUpdateAuthorityError';
-}
-
-/** Thrown if member account is the same as the group account */
-export class MemberAccountIsGroupAccountError extends TokenGroupError {
-    name = 'MemberAccountIsGroupAccountError';
-}
diff --git a/token-group/js/src/index.ts b/token-group/js/src/index.ts
deleted file mode 100644
index 5bc9f496131..00000000000
--- a/token-group/js/src/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './errors.js';
-export * from './instruction.js';
-export * from './state/index.js';
diff --git a/token-group/js/src/instruction.ts b/token-group/js/src/instruction.ts
deleted file mode 100644
index ab08a770da0..00000000000
--- a/token-group/js/src/instruction.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import type { Encoder } from '@solana/codecs';
-import type { PublicKey } from '@solana/web3.js';
-import {
-    fixEncoderSize,
-    getBytesEncoder,
-    getStructEncoder,
-    getTupleEncoder,
-    getU32Encoder,
-    transformEncoder,
-} from '@solana/codecs';
-import { splDiscriminate } from '@solana/spl-type-length-value';
-import { SystemProgram, TransactionInstruction } from '@solana/web3.js';
-
-function getInstructionEncoder<T extends object>(discriminator: Uint8Array, dataEncoder: Encoder<T>): Encoder<T> {
-    return transformEncoder(getTupleEncoder([getBytesEncoder(), dataEncoder]), (data: T): [Uint8Array, T] => [
-        discriminator,
-        data,
-    ]);
-}
-
-function getPublicKeyEncoder(): Encoder<PublicKey> {
-    return transformEncoder(fixEncoderSize(getBytesEncoder(), 32), (publicKey: PublicKey) => publicKey.toBytes());
-}
-
-export interface InitializeGroupInstruction {
-    programId: PublicKey;
-    group: PublicKey;
-    mint: PublicKey;
-    mintAuthority: PublicKey;
-    updateAuthority: PublicKey | null;
-    maxSize: number;
-}
-
-export function createInitializeGroupInstruction(args: InitializeGroupInstruction): TransactionInstruction {
-    const { programId, group, mint, mintAuthority, updateAuthority, maxSize } = args;
-
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: group },
-            { isSigner: false, isWritable: false, pubkey: mint },
-            { isSigner: true, isWritable: false, pubkey: mintAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_group_interface:initialize_token_group'),
-                getStructEncoder([
-                    ['updateAuthority', getPublicKeyEncoder()],
-                    ['maxSize', getU32Encoder()],
-                ])
-            ).encode({ updateAuthority: updateAuthority ?? SystemProgram.programId, maxSize })
-        ),
-    });
-}
-
-export interface UpdateGroupMaxSize {
-    programId: PublicKey;
-    group: PublicKey;
-    updateAuthority: PublicKey;
-    maxSize: number;
-}
-
-export function createUpdateGroupMaxSizeInstruction(args: UpdateGroupMaxSize): TransactionInstruction {
-    const { programId, group, updateAuthority, maxSize } = args;
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: group },
-            { isSigner: true, isWritable: false, pubkey: updateAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_group_interface:update_group_max_size'),
-                getStructEncoder([['maxSize', getU32Encoder()]])
-            ).encode({ maxSize })
-        ),
-    });
-}
-
-export interface UpdateGroupAuthority {
-    programId: PublicKey;
-    group: PublicKey;
-    currentAuthority: PublicKey;
-    newAuthority: PublicKey | null;
-}
-
-export function createUpdateGroupAuthorityInstruction(args: UpdateGroupAuthority): TransactionInstruction {
-    const { programId, group, currentAuthority, newAuthority } = args;
-
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: group },
-            { isSigner: true, isWritable: false, pubkey: currentAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_group_interface:update_authority'),
-                getStructEncoder([['newAuthority', getPublicKeyEncoder()]])
-            ).encode({ newAuthority: newAuthority ?? SystemProgram.programId })
-        ),
-    });
-}
-
-export interface InitializeMember {
-    programId: PublicKey;
-    member: PublicKey;
-    memberMint: PublicKey;
-    memberMintAuthority: PublicKey;
-    group: PublicKey;
-    groupUpdateAuthority: PublicKey;
-}
-
-export function createInitializeMemberInstruction(args: InitializeMember): TransactionInstruction {
-    const { programId, member, memberMint, memberMintAuthority, group, groupUpdateAuthority } = args;
-
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: member },
-            { isSigner: false, isWritable: false, pubkey: memberMint },
-            { isSigner: true, isWritable: false, pubkey: memberMintAuthority },
-            { isSigner: false, isWritable: true, pubkey: group },
-            { isSigner: true, isWritable: false, pubkey: groupUpdateAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_group_interface:initialize_member'),
-                getStructEncoder([])
-            ).encode({})
-        ),
-    });
-}
diff --git a/token-group/js/src/state/index.ts b/token-group/js/src/state/index.ts
deleted file mode 100644
index e5db1ace95d..00000000000
--- a/token-group/js/src/state/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './tokenGroup.js';
-export * from './tokenGroupMember.js';
diff --git a/token-group/js/src/state/tokenGroup.ts b/token-group/js/src/state/tokenGroup.ts
deleted file mode 100644
index ecc51254268..00000000000
--- a/token-group/js/src/state/tokenGroup.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import type { ReadonlyUint8Array } from '@solana/codecs';
-import { fixCodecSize, getBytesCodec, getStructCodec, getU32Codec } from '@solana/codecs';
-
-const tokenGroupCodec = getStructCodec([
-    ['updateAuthority', fixCodecSize(getBytesCodec(), 32)],
-    ['mint', fixCodecSize(getBytesCodec(), 32)],
-    ['size', getU32Codec()],
-    ['maxSize', getU32Codec()],
-]);
-
-export const TOKEN_GROUP_SIZE = tokenGroupCodec.fixedSize;
-
-export interface TokenGroup {
-    /** The authority that can sign to update the group */
-    updateAuthority?: PublicKey;
-    /** The associated mint, used to counter spoofing to be sure that group belongs to a particular mint */
-    mint: PublicKey;
-    /** The current number of group members */
-    size: number;
-    /** The maximum number of group members */
-    maxSize: number;
-}
-
-// Checks if all elements in the array are 0
-function isNonePubkey(buffer: ReadonlyUint8Array): boolean {
-    for (let i = 0; i < buffer.length; i++) {
-        if (buffer[i] !== 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-// Pack TokenGroup into byte slab
-export function packTokenGroup(group: TokenGroup): ReadonlyUint8Array {
-    // If no updateAuthority given, set it to the None/Zero PublicKey for encoding
-    const updateAuthority = group.updateAuthority ?? PublicKey.default;
-    return tokenGroupCodec.encode({
-        updateAuthority: updateAuthority.toBuffer(),
-        mint: group.mint.toBuffer(),
-        size: group.size,
-        maxSize: group.maxSize,
-    });
-}
-
-// unpack byte slab into TokenGroup
-export function unpackTokenGroup(buffer: Buffer | Uint8Array | ReadonlyUint8Array): TokenGroup {
-    const data = tokenGroupCodec.decode(buffer);
-
-    return isNonePubkey(data.updateAuthority)
-        ? {
-              mint: new PublicKey(data.mint),
-              size: data.size,
-              maxSize: data.maxSize,
-          }
-        : {
-              updateAuthority: new PublicKey(data.updateAuthority),
-              mint: new PublicKey(data.mint),
-              size: data.size,
-              maxSize: data.maxSize,
-          };
-}
diff --git a/token-group/js/src/state/tokenGroupMember.ts b/token-group/js/src/state/tokenGroupMember.ts
deleted file mode 100644
index 8d49a0316a7..00000000000
--- a/token-group/js/src/state/tokenGroupMember.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import type { ReadonlyUint8Array } from '@solana/codecs';
-import { fixCodecSize, getBytesCodec, getStructCodec, getU32Codec } from '@solana/codecs';
-
-const tokenGroupMemberCodec = getStructCodec([
-    ['mint', fixCodecSize(getBytesCodec(), 32)],
-    ['group', fixCodecSize(getBytesCodec(), 32)],
-    ['memberNumber', getU32Codec()],
-]);
-
-export const TOKEN_GROUP_MEMBER_SIZE = tokenGroupMemberCodec.fixedSize;
-
-export interface TokenGroupMember {
-    /** The associated mint, used to counter spoofing to be sure that member belongs to a particular mint */
-    mint: PublicKey;
-    /** The pubkey of the `TokenGroup` */
-    group: PublicKey;
-    /** The member number */
-    memberNumber: number;
-}
-
-// Pack TokenGroupMember into byte slab
-export function packTokenGroupMember(member: TokenGroupMember): ReadonlyUint8Array {
-    return tokenGroupMemberCodec.encode({
-        mint: member.mint.toBuffer(),
-        group: member.group.toBuffer(),
-        memberNumber: member.memberNumber,
-    });
-}
-
-// unpack byte slab into TokenGroupMember
-export function unpackTokenGroupMember(buffer: Buffer | Uint8Array | ReadonlyUint8Array): TokenGroupMember {
-    const data = tokenGroupMemberCodec.decode(buffer);
-    return {
-        mint: new PublicKey(data.mint),
-        group: new PublicKey(data.group),
-        memberNumber: data.memberNumber,
-    };
-}
diff --git a/token-group/js/test/instruction.test.ts b/token-group/js/test/instruction.test.ts
deleted file mode 100644
index a0454cf4a91..00000000000
--- a/token-group/js/test/instruction.test.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import { expect } from 'chai';
-import type { Decoder } from '@solana/codecs';
-import { fixDecoderSize, getBytesDecoder, getStructDecoder, getU32Decoder } from '@solana/codecs';
-import { splDiscriminate } from '@solana/spl-type-length-value';
-import { PublicKey, type TransactionInstruction } from '@solana/web3.js';
-
-import {
-    createInitializeGroupInstruction,
-    createInitializeMemberInstruction,
-    createUpdateGroupMaxSizeInstruction,
-    createUpdateGroupAuthorityInstruction,
-} from '../src';
-
-function checkPackUnpack<T extends object>(
-    instruction: TransactionInstruction,
-    discriminator: Uint8Array,
-    decoder: Decoder<T>,
-    values: T
-) {
-    expect(instruction.data.subarray(0, 8)).to.deep.equal(discriminator);
-    const unpacked = decoder.decode(instruction.data.subarray(8));
-    expect(unpacked).to.deep.equal(values);
-}
-
-describe('Token Group Instructions', () => {
-    const programId = new PublicKey('22222222222222222222222222222222222222222222');
-    const group = new PublicKey('33333333333333333333333333333333333333333333');
-    const updateAuthority = new PublicKey('44444444444444444444444444444444444444444444');
-    const mint = new PublicKey('55555555555555555555555555555555555555555555');
-    const mintAuthority = new PublicKey('66666666666666666666666666666666666666666666');
-    const maxSize = 100;
-
-    it('Can create InitializeGroup Instruction', () => {
-        checkPackUnpack(
-            createInitializeGroupInstruction({
-                programId,
-                group,
-                mint,
-                mintAuthority,
-                updateAuthority,
-                maxSize,
-            }),
-            splDiscriminate('spl_token_group_interface:initialize_token_group'),
-            getStructDecoder([
-                ['updateAuthority', fixDecoderSize(getBytesDecoder(), 32)],
-                ['maxSize', getU32Decoder()],
-            ]),
-            { updateAuthority: Uint8Array.from(updateAuthority.toBuffer()), maxSize }
-        );
-    });
-
-    it('Can create UpdateGroupMaxSize Instruction', () => {
-        checkPackUnpack(
-            createUpdateGroupMaxSizeInstruction({
-                programId,
-                group,
-                updateAuthority,
-                maxSize,
-            }),
-            splDiscriminate('spl_token_group_interface:update_group_max_size'),
-            getStructDecoder([['maxSize', getU32Decoder()]]),
-            { maxSize }
-        );
-    });
-
-    it('Can create UpdateGroupAuthority Instruction', () => {
-        checkPackUnpack(
-            createUpdateGroupAuthorityInstruction({
-                programId,
-                group,
-                currentAuthority: updateAuthority,
-                newAuthority: PublicKey.default,
-            }),
-            splDiscriminate('spl_token_group_interface:update_authority'),
-            getStructDecoder([['newAuthority', fixDecoderSize(getBytesDecoder(), 32)]]),
-            { newAuthority: Uint8Array.from(PublicKey.default.toBuffer()) }
-        );
-    });
-
-    it('Can create InitializeMember Instruction', () => {
-        const member = new PublicKey('22222222222222222222222222222222222222222222');
-        const memberMint = new PublicKey('33333333333333333333333333333333333333333333');
-        const memberMintAuthority = new PublicKey('44444444444444444444444444444444444444444444');
-        const group = new PublicKey('55555555555555555555555555555555555555555555');
-        const groupUpdateAuthority = new PublicKey('66666666666666666666666666666666666666666666');
-
-        checkPackUnpack(
-            createInitializeMemberInstruction({
-                programId,
-                member,
-                memberMint,
-                memberMintAuthority,
-                group,
-                groupUpdateAuthority,
-            }),
-            splDiscriminate('spl_token_group_interface:initialize_member'),
-            getStructDecoder([]),
-            {}
-        );
-    });
-});
diff --git a/token-group/js/test/state.test.ts b/token-group/js/test/state.test.ts
deleted file mode 100644
index 36f874b5209..00000000000
--- a/token-group/js/test/state.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { expect } from 'chai';
-
-import type { TokenGroup, TokenGroupMember } from '../src/state';
-import { unpackTokenGroupMember, packTokenGroupMember, unpackTokenGroup, packTokenGroup } from '../src';
-
-describe('Token Group State', () => {
-    describe('Token Group', () => {
-        function checkPackUnpack(tokenGroup: TokenGroup) {
-            const packed = packTokenGroup(tokenGroup);
-            const unpacked = unpackTokenGroup(packed);
-            expect(unpacked).to.deep.equal(tokenGroup);
-        }
-
-        it('Can pack and unpack TokenGroup with updateAuthoritygroup', () => {
-            checkPackUnpack({
-                mint: new PublicKey('44444444444444444444444444444444444444444444'),
-                updateAuthority: new PublicKey('55555555555555555555555555555555555555555555'),
-                size: 10,
-                maxSize: 20,
-            });
-        });
-
-        it('Can pack and unpack TokenGroup without updateAuthoritygroup', () => {
-            checkPackUnpack({
-                mint: new PublicKey('44444444444444444444444444444444444444444444'),
-                size: 10,
-                maxSize: 20,
-            });
-        });
-    });
-
-    describe('Token Group Member', () => {
-        function checkPackUnpack(tokenGroupMember: TokenGroupMember) {
-            const packed = packTokenGroupMember(tokenGroupMember);
-            const unpacked = unpackTokenGroupMember(packed);
-            expect(unpacked).to.deep.equal(tokenGroupMember);
-        }
-        it('Can pack and unpack TokenGroupMembergroup', () => {
-            checkPackUnpack({
-                mint: new PublicKey('55555555555555555555555555555555555555555555'),
-                group: new PublicKey('66666666666666666666666666666666666666666666'),
-                memberNumber: 8,
-            });
-        });
-    });
-});
diff --git a/token-group/js/tsconfig.all.json b/token-group/js/tsconfig.all.json
deleted file mode 100644
index 985513259e2..00000000000
--- a/token-group/js/tsconfig.all.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.root.json",
-    "references": [
-        {
-            "path": "./tsconfig.cjs.json"
-        },
-        {
-            "path": "./tsconfig.esm.json"
-        }
-    ]
-}
diff --git a/token-group/js/tsconfig.base.json b/token-group/js/tsconfig.base.json
deleted file mode 100644
index 90620c4e485..00000000000
--- a/token-group/js/tsconfig.base.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "include": [],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "stripInternal": true
-    }
-}
diff --git a/token-group/js/tsconfig.cjs.json b/token-group/js/tsconfig.cjs.json
deleted file mode 100644
index 2db9b71569e..00000000000
--- a/token-group/js/tsconfig.cjs.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/cjs",
-        "target": "ES2016",
-        "module": "CommonJS",
-        "sourceMap": true
-    }
-}
diff --git a/token-group/js/tsconfig.esm.json b/token-group/js/tsconfig.esm.json
deleted file mode 100644
index 25e7e25e751..00000000000
--- a/token-group/js/tsconfig.esm.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/esm",
-        "declarationDir": "lib/types",
-        "target": "ES2020",
-        "module": "ES2020",
-        "sourceMap": true,
-        "declaration": true,
-        "declarationMap": true
-    }
-}
diff --git a/token-group/js/tsconfig.json b/token-group/js/tsconfig.json
deleted file mode 100644
index 2f9b239bfca..00000000000
--- a/token-group/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig.all.json",
-    "include": ["src", "test"],
-    "compilerOptions": {
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
diff --git a/token-group/js/tsconfig.root.json b/token-group/js/tsconfig.root.json
deleted file mode 100644
index fadf294ab43..00000000000
--- a/token-group/js/tsconfig.root.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "compilerOptions": {
-        "composite": true
-    }
-}
diff --git a/token-group/js/typedoc.json b/token-group/js/typedoc.json
deleted file mode 100644
index c39fc53aee1..00000000000
--- a/token-group/js/typedoc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md"
-}
diff --git a/token-lending/cli/Cargo.toml b/token-lending/cli/Cargo.toml
index 95b1e0ac1d4..9181e0c0285 100644
--- a/token-lending/cli/Cargo.toml
+++ b/token-lending/cli/Cargo.toml
@@ -10,14 +10,14 @@ version = "0.2.0"
 
 [dependencies]
 clap = "2.33.3"
-solana-clap-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-solana-program = ">=1.18.11,<=2"
+solana-clap-utils = "2.1.0"
+solana-cli-config = "2.1.0"
+solana-client = "2.1.0"
+solana-logger = "2.1.0"
+solana-sdk = "2.1.0"
+solana-program = "2.1.0"
 spl-token-lending = { version = "0.2", path="../program", features = [ "no-entrypoint" ] }
-spl-token = { version = "4.0", path="../../token/program", features = [ "no-entrypoint" ]  }
+spl-token = { version = "7.0", features = [ "no-entrypoint" ]  }
 
 [[bin]]
 name = "spl-token-lending"
diff --git a/token-lending/flash_loan_receiver/Cargo.toml b/token-lending/flash_loan_receiver/Cargo.toml
index 5b2556a1a23..00ab194ba13 100644
--- a/token-lending/flash_loan_receiver/Cargo.toml
+++ b/token-lending/flash_loan_receiver/Cargo.toml
@@ -4,9 +4,9 @@ version = "1.0.0"
 edition = "2021"
 
 [dependencies]
-arrayref = "0.3.7"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features=["no-entrypoint"] }
+arrayref = "0.3.9"
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features=["no-entrypoint"] }
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/token-lending/flash_loan_receiver/src/processor.rs b/token-lending/flash_loan_receiver/src/processor.rs
index 8d895e8aa98..f9f9c350fbd 100644
--- a/token-lending/flash_loan_receiver/src/processor.rs
+++ b/token-lending/flash_loan_receiver/src/processor.rs
@@ -61,9 +61,8 @@ fn unpack_amount(input: &[u8]) -> Result<u64, ProgramError> {
         .and_then(|slice| slice.try_into().ok())
         .map(u64::from_le_bytes)
         .ok_or(ProgramError::InvalidInstructionData)
-        .map_err(|e| {
+        .inspect_err(|_| {
             msg!("Failed to unpack amount.");
-            e
         })?;
     Ok(amount)
 }
diff --git a/token-lending/js/.prettierignore b/token-lending/js/.prettierignore
deleted file mode 100644
index 741a987a650..00000000000
--- a/token-lending/js/.prettierignore
+++ /dev/null
@@ -1,2 +0,0 @@
-docs
-lib
diff --git a/token-lending/js/.prettierrc b/token-lending/js/.prettierrc
deleted file mode 100644
index f19e7945f9a..00000000000
--- a/token-lending/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "printWidth": 120,
-  "trailingComma": "es5",
-  "tabWidth": 4,
-  "semi": true,
-  "singleQuote": true
-}
\ No newline at end of file
diff --git a/token-lending/js/README.md b/token-lending/js/README.md
index eb306b2888a..71c1ce31f9f 100644
--- a/token-lending/js/README.md
+++ b/token-lending/js/README.md
@@ -8,12 +8,12 @@ Install the library and its peer dependencies in your app:
 
 ### Yarn
 ```shell
-yarn add @solana/spl-token-lending @solana/spl-token @solana/web3.js
+yarn add @solana/spl-token-lending @solana/spl-token @solana/web3.js@1
 ```
 
 ### NPM
 ```shell
-npm install @solana/spl-token-lending @solana/spl-token @solana/web3.js
+npm install @solana/spl-token-lending @solana/spl-token @solana/web3.js@1
 ```
 
 ## Documentation
diff --git a/token-lending/js/package.json b/token-lending/js/package.json
index 5b147d1e9ca..4da2598570c 100644
--- a/token-lending/js/package.json
+++ b/token-lending/js/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@solana/spl-token-lending",
-    "version": "0.3.9",
+    "version": "0.3.10",
     "description": "SPL Token Lending JavaScript API",
     "license": "MIT",
     "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
@@ -27,8 +27,8 @@
         "build": "tsc && rollup --configPlugin @rollup/plugin-typescript -c && rm lib/rollup.config.d.ts",
         "deploy": "npm docs && gh-pages -d docs -e token-lending",
         "docs": "typedoc",
-        "lint": "eslint . --ext .ts --max-warnings 0 && prettier --check '**/*.{ts,js,json}'",
-        "lint:fix": "eslint . --ext .ts --fix && prettier --write '**/*.{ts,js,json}'"
+        "lint": "eslint . --ext .ts --max-warnings 0",
+        "lint:fix": "eslint . --ext .ts --fix"
     },
     "dependencies": {
         "@solana/buffer-layout": "^4.0.0",
@@ -37,29 +37,25 @@
         "bignumber.js": "^9.0.1"
     },
     "peerDependencies": {
-        "@solana/spl-token": "0.4.6",
+        "@solana/spl-token": "0.4.9",
         "@solana/web3.js": "^1.20.3"
     },
     "devDependencies": {
-        "@rollup/plugin-commonjs": "^26.0.1",
-        "@rollup/plugin-node-resolve": "^15.0.2",
-        "@rollup/plugin-typescript": "^11.1.6",
-        "@solana/spl-token": "0.4.6",
-        "@solana/web3.js": "^1.93.0",
+        "@rollup/plugin-commonjs": "^28.0.2",
+        "@rollup/plugin-node-resolve": "^16.0.0",
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@solana/spl-token": "0.4.9",
+        "@solana/web3.js": "^1.95.5",
         "@types/eslint": "^8.56.7",
-        "@types/eslint-plugin-prettier": "^3.1.0",
-        "@types/node": "^20.14.5",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
+        "@types/node": "^22.10.5",
+        "@typescript-eslint/eslint-plugin": "^8.4.0",
+        "@typescript-eslint/parser": "^8.4.0",
         "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "gh-pages": "^6.1.1",
-        "prettier": "^3.3.2",
-        "rollup": "^4.18.0",
+        "gh-pages": "^6.3.0",
+        "rollup": "^4.30.1",
         "ts-node": "^10.9.2",
-        "tslib": "^2.6.3",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
+        "tslib": "^2.8.1",
+        "typedoc": "^0.27.6",
+        "typescript": "^5.7.2"
     }
 }
diff --git a/token-lending/js/src/instructions/borrowObligationLiquidity.ts b/token-lending/js/src/instructions/borrowObligationLiquidity.ts
index 0c7da66efd1..9b30eabc090 100644
--- a/token-lending/js/src/instructions/borrowObligationLiquidity.ts
+++ b/token-lending/js/src/instructions/borrowObligationLiquidity.ts
@@ -22,7 +22,7 @@ export const borrowObligationLiquidityInstruction = (
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
     obligationOwner: PublicKey,
-    hostFeeReceiver?: PublicKey
+    hostFeeReceiver?: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -30,7 +30,7 @@ export const borrowObligationLiquidityInstruction = (
             instruction: LendingInstruction.BorrowObligationLiquidity,
             liquidityAmount: BigInt(liquidityAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/depositObligationCollateral.ts b/token-lending/js/src/instructions/depositObligationCollateral.ts
index 3dca3dc6cff..ab960c70058 100644
--- a/token-lending/js/src/instructions/depositObligationCollateral.ts
+++ b/token-lending/js/src/instructions/depositObligationCollateral.ts
@@ -20,7 +20,7 @@ export const depositObligationCollateralInstruction = (
     obligation: PublicKey,
     lendingMarket: PublicKey,
     obligationOwner: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -28,7 +28,7 @@ export const depositObligationCollateralInstruction = (
             instruction: LendingInstruction.DepositObligationCollateral,
             collateralAmount: BigInt(collateralAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/depositReserveLiquidity.ts b/token-lending/js/src/instructions/depositReserveLiquidity.ts
index 588e63eb3bb..e61561c4761 100644
--- a/token-lending/js/src/instructions/depositReserveLiquidity.ts
+++ b/token-lending/js/src/instructions/depositReserveLiquidity.ts
@@ -21,7 +21,7 @@ export const depositReserveLiquidityInstruction = (
     reserveCollateralMint: PublicKey,
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -29,7 +29,7 @@ export const depositReserveLiquidityInstruction = (
             instruction: LendingInstruction.DepositReserveLiquidity,
             liquidityAmount: BigInt(liquidityAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/flashLoan.ts b/token-lending/js/src/instructions/flashLoan.ts
index 35d5bf01425..96d7cfc68d8 100644
--- a/token-lending/js/src/instructions/flashLoan.ts
+++ b/token-lending/js/src/instructions/flashLoan.ts
@@ -22,7 +22,7 @@ export const flashLoanInstruction = (
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
     flashLoanProgram: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -30,7 +30,7 @@ export const flashLoanInstruction = (
             instruction: LendingInstruction.FlashLoan,
             liquidityAmount: BigInt(liquidityAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/initLendingMarket.ts b/token-lending/js/src/instructions/initLendingMarket.ts
index 9c05c08bf47..f9f83f9f177 100644
--- a/token-lending/js/src/instructions/initLendingMarket.ts
+++ b/token-lending/js/src/instructions/initLendingMarket.ts
@@ -16,7 +16,7 @@ const DataLayout = struct<Data>([u8('instruction'), publicKey('owner'), blob(32,
 export const initLendingMarketInstruction = (
     owner: PublicKey,
     quoteCurrency: Uint8Array,
-    lendingMarket: PublicKey
+    lendingMarket: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -25,7 +25,7 @@ export const initLendingMarketInstruction = (
             owner,
             quoteCurrency,
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/initObligation.ts b/token-lending/js/src/instructions/initObligation.ts
index 60911f43326..b59ef1d5357 100644
--- a/token-lending/js/src/instructions/initObligation.ts
+++ b/token-lending/js/src/instructions/initObligation.ts
@@ -13,7 +13,7 @@ const DataLayout = struct<Data>([u8('instruction')]);
 export const initObligationInstruction = (
     obligation: PublicKey,
     lendingMarket: PublicKey,
-    obligationOwner: PublicKey
+    obligationOwner: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode({ instruction: LendingInstruction.InitObligation }, data);
diff --git a/token-lending/js/src/instructions/initReserve.ts b/token-lending/js/src/instructions/initReserve.ts
index 936459d619f..4d5c6ee567e 100644
--- a/token-lending/js/src/instructions/initReserve.ts
+++ b/token-lending/js/src/instructions/initReserve.ts
@@ -30,7 +30,7 @@ export const initReserveInstruction = (
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
     lendingMarketOwner: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -39,7 +39,7 @@ export const initReserveInstruction = (
             liquidityAmount: BigInt(liquidityAmount),
             config,
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/liquidateObligation.ts b/token-lending/js/src/instructions/liquidateObligation.ts
index df0f338a90e..77264289299 100644
--- a/token-lending/js/src/instructions/liquidateObligation.ts
+++ b/token-lending/js/src/instructions/liquidateObligation.ts
@@ -23,7 +23,7 @@ export const liquidateObligationInstruction = (
     obligation: PublicKey,
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -31,7 +31,7 @@ export const liquidateObligationInstruction = (
             instruction: LendingInstruction.LiquidateObligation,
             liquidityAmount: BigInt(liquidityAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/redeemReserveCollateral.ts b/token-lending/js/src/instructions/redeemReserveCollateral.ts
index 40c66a1350c..c4bbf09566e 100644
--- a/token-lending/js/src/instructions/redeemReserveCollateral.ts
+++ b/token-lending/js/src/instructions/redeemReserveCollateral.ts
@@ -21,7 +21,7 @@ export const redeemReserveCollateralInstruction = (
     reserveLiquiditySupply: PublicKey,
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -29,7 +29,7 @@ export const redeemReserveCollateralInstruction = (
             instruction: LendingInstruction.RedeemReserveCollateral,
             collateralAmount: BigInt(collateralAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/refreshObligation.ts b/token-lending/js/src/instructions/refreshObligation.ts
index e673dd5192b..f2eb43ee2e2 100644
--- a/token-lending/js/src/instructions/refreshObligation.ts
+++ b/token-lending/js/src/instructions/refreshObligation.ts
@@ -12,7 +12,7 @@ const DataLayout = struct<Data>([u8('instruction')]);
 export const refreshObligationInstruction = (
     obligation: PublicKey,
     depositReserves: PublicKey[],
-    borrowReserves: PublicKey[]
+    borrowReserves: PublicKey[],
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode({ instruction: LendingInstruction.RefreshObligation }, data);
diff --git a/token-lending/js/src/instructions/repayObligationLiquidity.ts b/token-lending/js/src/instructions/repayObligationLiquidity.ts
index 0a63173ff25..7af02463fb8 100644
--- a/token-lending/js/src/instructions/repayObligationLiquidity.ts
+++ b/token-lending/js/src/instructions/repayObligationLiquidity.ts
@@ -19,7 +19,7 @@ export const repayObligationLiquidityInstruction = (
     repayReserve: PublicKey,
     obligation: PublicKey,
     lendingMarket: PublicKey,
-    transferAuthority: PublicKey
+    transferAuthority: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -27,7 +27,7 @@ export const repayObligationLiquidityInstruction = (
             instruction: LendingInstruction.RepayObligationLiquidity,
             liquidityAmount: BigInt(liquidityAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/setLendingMarketOwner.ts b/token-lending/js/src/instructions/setLendingMarketOwner.ts
index b1b98a95299..9007d72e5a1 100644
--- a/token-lending/js/src/instructions/setLendingMarketOwner.ts
+++ b/token-lending/js/src/instructions/setLendingMarketOwner.ts
@@ -14,7 +14,7 @@ const DataLayout = struct<Data>([u8('instruction'), publicKey('newOwner')]);
 export const setLendingMarketOwnerInstruction = (
     newOwner: PublicKey,
     lendingMarket: PublicKey,
-    currentOwner: PublicKey
+    currentOwner: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -22,7 +22,7 @@ export const setLendingMarketOwnerInstruction = (
             instruction: LendingInstruction.SetLendingMarketOwner,
             newOwner,
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/instructions/withdrawObligationCollateral.ts b/token-lending/js/src/instructions/withdrawObligationCollateral.ts
index 1b8178c6cf5..9087fc316b3 100644
--- a/token-lending/js/src/instructions/withdrawObligationCollateral.ts
+++ b/token-lending/js/src/instructions/withdrawObligationCollateral.ts
@@ -20,7 +20,7 @@ export const withdrawObligationCollateralInstruction = (
     obligation: PublicKey,
     lendingMarket: PublicKey,
     lendingMarketAuthority: PublicKey,
-    obligationOwner: PublicKey
+    obligationOwner: PublicKey,
 ): TransactionInstruction => {
     const data = Buffer.alloc(DataLayout.span);
     DataLayout.encode(
@@ -28,7 +28,7 @@ export const withdrawObligationCollateralInstruction = (
             instruction: LendingInstruction.WithdrawObligationCollateral,
             collateralAmount: BigInt(collateralAmount),
         },
-        data
+        data,
     );
 
     const keys = [
diff --git a/token-lending/js/src/state/lendingMarket.ts b/token-lending/js/src/state/lendingMarket.ts
index 8768a3138f7..3a6530535b4 100644
--- a/token-lending/js/src/state/lendingMarket.ts
+++ b/token-lending/js/src/state/lendingMarket.ts
@@ -23,7 +23,7 @@ export const LendingMarketLayout = struct<LendingMarket>(
         publicKey('oracleProgramId'),
         blob(128, 'padding'),
     ],
-    'lendingMarket'
+    'lendingMarket',
 );
 
 export const LENDING_MARKET_SIZE = LendingMarketLayout.span;
diff --git a/token-lending/js/src/state/obligation.ts b/token-lending/js/src/state/obligation.ts
index ba455df1ab0..61949959e4e 100644
--- a/token-lending/js/src/state/obligation.ts
+++ b/token-lending/js/src/state/obligation.ts
@@ -49,7 +49,7 @@ export interface ObligationDataFlat {
 /** @internal */
 export const ObligationCollateralLayout = struct<ObligationCollateral>(
     [publicKey('depositReserve'), u64('depositedAmount'), decimal('marketValue')],
-    'collateral'
+    'collateral',
 );
 
 /** @internal */
@@ -60,7 +60,7 @@ export const ObligationLiquidityLayout = struct<ObligationLiquidity>(
         decimal('borrowedAmountWads'),
         decimal('marketValue'),
     ],
-    'liquidity'
+    'liquidity',
 );
 
 /** @internal */
@@ -78,7 +78,7 @@ export const ObligationLayout = struct<ObligationDataFlat>(
         u8('borrowsLen'),
         blob(ObligationCollateralLayout.span + 9 * ObligationLiquidityLayout.span, 'dataFlat'),
     ],
-    'obligation'
+    'obligation',
 );
 
 export const OBLIGATION_SIZE = ObligationLayout.span;
diff --git a/token-lending/js/src/state/reserve.ts b/token-lending/js/src/state/reserve.ts
index 1c242a67006..0c9ac718adb 100644
--- a/token-lending/js/src/state/reserve.ts
+++ b/token-lending/js/src/state/reserve.ts
@@ -63,19 +63,19 @@ export const ReserveLiquidityLayout = struct<ReserveLiquidity>(
         decimal('cumulativeBorrowRateWads'),
         decimal('marketPrice'),
     ],
-    'liquidity'
+    'liquidity',
 );
 
 /** @internal */
 export const ReserveCollateralLayout = struct<ReserveCollateral>(
     [publicKey('mintPubkey'), u64('mintTotalSupply'), publicKey('supplyPubkey')],
-    'collateral'
+    'collateral',
 );
 
 /** @internal */
 export const ReserveFeesLayout = struct<ReserveFees>(
     [u64('borrowFeeWad'), u64('flashLoanFeeWad'), u8('hostFeePercentage')],
-    'fees'
+    'fees',
 );
 
 /** @internal */
@@ -90,7 +90,7 @@ export const ReserveConfigLayout = struct<ReserveConfig>(
         u8('maxBorrowRate'),
         ReserveFeesLayout,
     ],
-    'config'
+    'config',
 );
 
 /** @internal */
diff --git a/token-lending/js/src/util/layout.ts b/token-lending/js/src/util/layout.ts
index dc55b09b82b..6d1a3cb8dec 100644
--- a/token-lending/js/src/util/layout.ts
+++ b/token-lending/js/src/util/layout.ts
@@ -2,7 +2,7 @@ import { AccountInfo, PublicKey } from '@solana/web3.js';
 
 export type Parser<T> = (
     pubkey: PublicKey,
-    info: AccountInfo<Uint8Array>
+    info: AccountInfo<Uint8Array>,
 ) =>
     | {
           pubkey: PublicKey;
diff --git a/token-lending/program/Cargo.toml b/token-lending/program/Cargo.toml
index b81bcca0a1d..07007776104 100644
--- a/token-lending/program/Cargo.toml
+++ b/token-lending/program/Cargo.toml
@@ -12,20 +12,23 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-arrayref = "0.3.7"
-bytemuck = "1.16.0"
+arrayref = "0.3.9"
+bytemuck = "1.21.0"
 num-derive = "0.4"
 num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = [ "no-entrypoint" ] }
-thiserror = "1.0"
-uint = "0.9"
+solana-program = "2.1.0"
+spl-token = { version = "7.0", features = [ "no-entrypoint" ] }
+thiserror = "2.0"
+uint = "0.10"
 
 [dev-dependencies]
 assert_matches = "1.5.0"
-proptest = "1.4"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
+proptest = "1.6"
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
+
+[lints]
+workspace = true
diff --git a/token-lending/program/src/instruction.rs b/token-lending/program/src/instruction.rs
index 5455ef92b7e..3ef6841230b 100644
--- a/token-lending/program/src/instruction.rs
+++ b/token-lending/program/src/instruction.rs
@@ -67,13 +67,13 @@ pub enum LendingInstruction {
     ///   8. `[]` Pyth product account.
     ///   9. `[]` Pyth price account. This will be used as the reserve liquidity
     ///      oracle account.
-    ///   10 `[]` Lending market account.
-    ///   11 `[]` Derived lending market authority.
-    ///   12 `[signer]` Lending market owner.
-    ///   13 `[signer]` User transfer authority ($authority).
-    ///   14 `[]` Clock sysvar.
-    ///   15 `[]` Rent sysvar.
-    ///   16 `[]` Token program id.
+    ///   10. `[]` Lending market account.
+    ///   11. `[]` Derived lending market authority.
+    ///   12. `[signer]` Lending market owner.
+    ///   13. `[signer]` User transfer authority ($authority).
+    ///   14. `[]` Clock sysvar.
+    ///   15. `[]` Rent sysvar.
+    ///   16. `[]` Token program id.
     InitReserve {
         /// Initial amount of liquidity to deposit into the new reserve
         liquidity_amount: u64,
@@ -158,9 +158,10 @@ pub enum LendingInstruction {
     ///
     ///   0. `[writable]` Obligation account.
     ///   1. `[]` Clock sysvar.
-    ///   .. `[]` Collateral deposit reserve accounts - refreshed, all, in
-    /// order.   .. `[]` Liquidity borrow reserve accounts - refreshed, all,
-    /// in order.
+    ///   2. .. `[]` Collateral deposit reserve accounts - refreshed, all, in
+    ///      order.
+    ///   3. .. `[]` Liquidity borrow reserve accounts - refreshed, all, in
+    ///      order.
     RefreshObligation,
 
     // 8
@@ -227,7 +228,7 @@ pub enum LendingInstruction {
     ///   7. `[signer]` Obligation owner.
     ///   8. `[]` Clock sysvar.
     ///   9. `[]` Token program id.
-    ///   10 `[optional, writable]` Host fee receiver account.
+    ///   10. `[optional, writable]` Host fee receiver account.
     BorrowObligationLiquidity {
         /// Amount of liquidity to borrow - u64::MAX for 100% of borrowing power
         liquidity_amount: u64,
@@ -276,8 +277,8 @@ pub enum LendingInstruction {
     ///   7. `[]` Lending market account.
     ///   8. `[]` Derived lending market authority.
     ///   9. `[signer]` User transfer authority ($authority).
-    ///   10 `[]` Clock sysvar.
-    ///   11 `[]` Token program id.
+    ///   10. `[]` Clock sysvar.
+    ///   11. `[]` Token program id.
     LiquidateObligation {
         /// Amount of liquidity to repay - u64::MAX for up to 100% of borrowed
         /// amount
@@ -303,8 +304,8 @@ pub enum LendingInstruction {
     ///   8. `[]` Flash loan receiver program id. Must implement an instruction
     ///      that has tag of 0 and a signature of `(amount: u64)` This
     ///      instruction must return the amount to the source liquidity account.
-    ///   .. `[any]` Additional accounts expected by the receiving program's
-    /// `ReceiveFlashLoan` instruction.
+    ///   9. .. `[any]` Additional accounts expected by the receiving program's
+    ///      `ReceiveFlashLoan` instruction.
     ///
     ///   The flash loan receiver program that is to be invoked should contain
     /// an instruction with   tag `0` and accept the total amount (including
@@ -319,11 +320,9 @@ pub enum LendingInstruction {
     ///   1. `[writable]` Destination liquidity (matching the source from
     ///      above).
     ///   2. `[]` Token program id
-    ///   .. `[any]` Additional accounts provided to the lending program's
-    /// `FlashLoan` instruction above.   ReceiveFlashLoan {
-    ///       // Amount that must be repaid by the receiver program
-    ///       amount: u64
-    ///   }
+    ///   3. .. `[any]` Additional accounts provided to the lending program's
+    ///      `FlashLoan` instruction above.   ReceiveFlashLoan { // Amount that
+    ///      must be repaid by the receiver program amount: u64 }
     FlashLoan {
         /// The amount that is to be borrowed - u64::MAX for up to 100% of
         /// available liquidity
diff --git a/token-lending/program/src/math/decimal.rs b/token-lending/program/src/math/decimal.rs
index 8e835b15981..957778ab163 100644
--- a/token-lending/program/src/math/decimal.rs
+++ b/token-lending/program/src/math/decimal.rs
@@ -11,6 +11,7 @@
 #![allow(clippy::assign_op_pattern)]
 #![allow(clippy::ptr_offset_with_cast)]
 #![allow(clippy::manual_range_contains)]
+#![allow(missing_docs)]
 
 use {
     crate::{
diff --git a/token-lending/program/src/math/rate.rs b/token-lending/program/src/math/rate.rs
index 166b6d5bf9f..12d3090486f 100644
--- a/token-lending/program/src/math/rate.rs
+++ b/token-lending/program/src/math/rate.rs
@@ -17,6 +17,7 @@
 #![allow(clippy::ptr_offset_with_cast)]
 #![allow(clippy::reversed_empty_ranges)]
 #![allow(clippy::manual_range_contains)]
+#![allow(missing_docs)]
 
 use {
     crate::{
diff --git a/token-lending/program/src/state/reserve.rs b/token-lending/program/src/state/reserve.rs
index e271f3b76f2..26b14b8f91c 100644
--- a/token-lending/program/src/state/reserve.rs
+++ b/token-lending/program/src/state/reserve.rs
@@ -755,7 +755,7 @@ impl ReserveFees {
     }
 }
 
-/// Calculate fees exlusive or inclusive of an amount
+/// Calculate fees exclusive or inclusive of an amount
 pub enum FeeCalculation {
     /// Fee added to amount: fee = rate * amount
     Exclusive,
diff --git a/token-lending/program/tests/borrow_obligation_liquidity.rs b/token-lending/program/tests/borrow_obligation_liquidity.rs
index 04cf626e884..8152350749e 100644
--- a/token-lending/program/tests/borrow_obligation_liquidity.rs
+++ b/token-lending/program/tests/borrow_obligation_liquidity.rs
@@ -18,7 +18,6 @@ use {
         processor::process_instruction,
         state::{FeeCalculation, INITIAL_COLLATERAL_RATIO},
     },
-    std::u64,
 };
 
 #[tokio::test]
@@ -373,7 +372,7 @@ async fn test_borrow_too_large() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[
@@ -627,7 +626,7 @@ async fn test_borrow_max_receive_less_than_slippage() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[
@@ -733,7 +732,7 @@ async fn test_borrow_less_than_max_with_slippage() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[
diff --git a/token-lending/program/tests/helpers/flash_loan_receiver.rs b/token-lending/program/tests/helpers/flash_loan_receiver.rs
index 2c8e50952a6..6d258d8213e 100644
--- a/token-lending/program/tests/helpers/flash_loan_receiver.rs
+++ b/token-lending/program/tests/helpers/flash_loan_receiver.rs
@@ -23,8 +23,8 @@ pub enum FlashLoanReceiverInstruction {
     ///   1. `[writable]` Destination liquidity (matching the source from
     ///      above).
     ///   2. `[]` Token program id
-    ///   .. `[any]` Additional accounts provided to the lending program's
-    /// `FlashLoan` instruction above.
+    ///   3. ..`[any]` Additional accounts provided to the lending program's
+    ///      `FlashLoan` instruction above.
     ReceiveFlashLoan {
         /// The amount that is loaned
         amount: u64,
diff --git a/token-lending/program/tests/init_lending_market.rs b/token-lending/program/tests/init_lending_market.rs
index ed0aebdd9bf..a4b8d48a429 100644
--- a/token-lending/program/tests/init_lending_market.rs
+++ b/token-lending/program/tests/init_lending_market.rs
@@ -43,7 +43,7 @@ async fn test_already_initialized() {
     );
 
     let existing_market = add_lending_market(&mut test);
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[init_lending_market(
diff --git a/token-lending/program/tests/init_obligation.rs b/token-lending/program/tests/init_obligation.rs
index 60d34a2bb0b..9ba184168a4 100644
--- a/token-lending/program/tests/init_obligation.rs
+++ b/token-lending/program/tests/init_obligation.rs
@@ -64,7 +64,7 @@ async fn test_already_initialized() {
         AddObligationArgs::default(),
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
     let mut transaction = Transaction::new_with_payer(
         &[init_obligation(
             spl_token_lending::id(),
diff --git a/token-lending/program/tests/init_reserve.rs b/token-lending/program/tests/init_reserve.rs
index 719c44dae46..134a7e5277c 100644
--- a/token-lending/program/tests/init_reserve.rs
+++ b/token-lending/program/tests/init_reserve.rs
@@ -107,7 +107,7 @@ async fn test_already_initialized() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[init_reserve(
diff --git a/token-lending/program/tests/modify_reserve_config.rs b/token-lending/program/tests/modify_reserve_config.rs
index d5679069a65..2fe71ce5038 100644
--- a/token-lending/program/tests/modify_reserve_config.rs
+++ b/token-lending/program/tests/modify_reserve_config.rs
@@ -137,7 +137,7 @@ async fn wrong_signer_of_lending_market_cannot_change_reserve_config() {
     let other_lending_market_owner = Keypair::new();
     other_lending_market.owner = other_lending_market_owner;
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     const OPTIMAL_UTILIZATION_RATE_CHANGE: u8 = 10;
 
diff --git a/token-lending/program/tests/redeem_reserve_collateral.rs b/token-lending/program/tests/redeem_reserve_collateral.rs
index 0340065bf68..61df380303c 100644
--- a/token-lending/program/tests/redeem_reserve_collateral.rs
+++ b/token-lending/program/tests/redeem_reserve_collateral.rs
@@ -52,7 +52,7 @@ async fn test_success() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let user_transfer_authority = Keypair::new();
     let mut transaction = Transaction::new_with_payer(
diff --git a/token-lending/program/tests/set_lending_market_owner.rs b/token-lending/program/tests/set_lending_market_owner.rs
index 9f120aa9b65..1a6302c091b 100644
--- a/token-lending/program/tests/set_lending_market_owner.rs
+++ b/token-lending/program/tests/set_lending_market_owner.rs
@@ -66,7 +66,7 @@ async fn test_invalid_owner() {
     );
 
     let lending_market = add_lending_market(&mut test);
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let invalid_owner = Keypair::new();
     let new_owner = Pubkey::new_unique();
@@ -104,7 +104,7 @@ async fn test_owner_not_signer() {
     );
 
     let lending_market = add_lending_market(&mut test);
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let new_owner = Pubkey::new_unique();
     let mut transaction = Transaction::new_with_payer(
diff --git a/token-lending/program/tests/withdraw_obligation_collateral.rs b/token-lending/program/tests/withdraw_obligation_collateral.rs
index f7ebba720de..bad6bb81130 100644
--- a/token-lending/program/tests/withdraw_obligation_collateral.rs
+++ b/token-lending/program/tests/withdraw_obligation_collateral.rs
@@ -17,7 +17,6 @@ use {
         processor::process_instruction,
         state::INITIAL_COLLATERAL_RATIO,
     },
-    std::u64,
 };
 
 #[tokio::test]
@@ -320,7 +319,7 @@ async fn test_withdraw_too_large() {
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let (banks_client, payer, recent_blockhash) = test.start().await;
 
     let mut transaction = Transaction::new_with_payer(
         &[
diff --git a/token-metadata/README.md b/token-metadata/README.md
new file mode 100644
index 00000000000..dc5a2bf8f62
--- /dev/null
+++ b/token-metadata/README.md
@@ -0,0 +1,2 @@
+NOTE: The token-metadat interface, program, and clients are now maintained at
+[solana-program/token-metadata](https://github.com/solana-program/token-metadata).
diff --git a/token-metadata/example/Cargo.toml b/token-metadata/example/Cargo.toml
deleted file mode 100644
index 175ebdb2d6c..00000000000
--- a/token-metadata/example/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "spl-token-metadata-example"
-version = "0.3.0"
-description = "Solana Program Library Token Metadata Example Program"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-solana-program = ">=1.18.11,<=2"
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-spl-token-metadata-interface = { version = "0.3.3", path = "../interface" }
-spl-type-length-value = { version = "0.4.3" , path = "../../libraries/type-length-value" }
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
-test-case = "3.3"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token-metadata/example/src/entrypoint.rs b/token-metadata/example/src/entrypoint.rs
deleted file mode 100644
index accd30f2c17..00000000000
--- a/token-metadata/example/src/entrypoint.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//! Program entrypoint
-
-use {
-    crate::processor,
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    spl_token_metadata_interface::error::TokenMetadataError,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<TokenMetadataError>();
-        return Err(error);
-    }
-    Ok(())
-}
diff --git a/token-metadata/example/src/lib.rs b/token-metadata/example/src/lib.rs
deleted file mode 100644
index db86409dad6..00000000000
--- a/token-metadata/example/src/lib.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//! Crate defining an example program for storing SPL token metadata
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod processor;
-
-#[cfg(not(feature = "no-entrypoint"))]
-mod entrypoint;
diff --git a/token-metadata/example/src/processor.rs b/token-metadata/example/src/processor.rs
deleted file mode 100644
index fe686e5e0da..00000000000
--- a/token-metadata/example/src/processor.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-//! Program state processor
-
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        borsh1::get_instance_packed_len,
-        entrypoint::ProgramResult,
-        msg,
-        program::set_return_data,
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_2022::{extension::StateWithExtensions, state::Mint},
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::{
-            Emit, Initialize, RemoveKey, TokenMetadataInstruction, UpdateAuthority, UpdateField,
-        },
-        state::TokenMetadata,
-    },
-    spl_type_length_value::state::{
-        realloc_and_pack_first_variable_len, TlvState, TlvStateBorrowed, TlvStateMut,
-    },
-};
-
-fn check_update_authority(
-    update_authority_info: &AccountInfo,
-    expected_update_authority: &OptionalNonZeroPubkey,
-) -> Result<(), ProgramError> {
-    if !update_authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let update_authority = Option::<Pubkey>::from(*expected_update_authority)
-        .ok_or(TokenMetadataError::ImmutableMetadata)?;
-    if update_authority != *update_authority_info.key {
-        return Err(TokenMetadataError::IncorrectUpdateAuthority.into());
-    }
-    Ok(())
-}
-
-/// Processes a [Initialize](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: Initialize,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let mint_authority_info = next_account_info(account_info_iter)?;
-
-    // scope the mint authority check, in case the mint is in the same account!
-    {
-        // IMPORTANT: this example metadata program is designed to work with any
-        // program that implements the SPL token interface, so there is no
-        // ownership check on the mint account.
-        let mint_data = mint_info.try_borrow_data()?;
-        let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-
-        if !mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if mint.base.mint_authority.as_ref() != COption::Some(mint_authority_info.key) {
-            return Err(TokenMetadataError::IncorrectMintAuthority.into());
-        }
-    }
-
-    // get the required size, assumes that there's enough space for the entry
-    let update_authority = OptionalNonZeroPubkey::try_from(Some(*update_authority_info.key))?;
-    let token_metadata = TokenMetadata {
-        name: data.name,
-        symbol: data.symbol,
-        uri: data.uri,
-        update_authority,
-        mint: *mint_info.key,
-        ..Default::default()
-    };
-    let instance_size = get_instance_packed_len(&token_metadata)?;
-
-    // allocate a TLV entry for the space and write it in
-    let mut buffer = metadata_info.try_borrow_mut_data()?;
-    let mut state = TlvStateMut::unpack(&mut buffer)?;
-    state.alloc::<TokenMetadata>(instance_size, false)?;
-    state.pack_first_variable_len_value(&token_metadata)?;
-
-    Ok(())
-}
-
-/// Processes an [UpdateField](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_update_field(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateField,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll probably
-    // realloc the account
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let state = TlvStateBorrowed::unpack(&buffer)?;
-        state.get_first_variable_len_value::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-
-    // Update the field
-    token_metadata.update(data.field, data.value);
-
-    // Update / realloc the account
-    realloc_and_pack_first_variable_len(metadata_info, &token_metadata)?;
-
-    Ok(())
-}
-
-/// Processes a [RemoveKey](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_remove_key(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: RemoveKey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll probably
-    // realloc the account
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let state = TlvStateBorrowed::unpack(&buffer)?;
-        state.get_first_variable_len_value::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-    if !token_metadata.remove_key(&data.key) && !data.idempotent {
-        return Err(TokenMetadataError::KeyNotFound.into());
-    }
-    realloc_and_pack_first_variable_len(metadata_info, &token_metadata)?;
-
-    Ok(())
-}
-
-/// Processes a [UpdateAuthority](enum.TokenMetadataInstruction.html)
-/// instruction.
-pub fn process_update_authority(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateAuthority,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll probably
-    // realloc the account
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let state = TlvStateBorrowed::unpack(&buffer)?;
-        state.get_first_variable_len_value::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-    token_metadata.update_authority = data.new_authority;
-    // Update the account, no realloc needed!
-    realloc_and_pack_first_variable_len(metadata_info, &token_metadata)?;
-
-    Ok(())
-}
-
-/// Processes an [Emit](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_emit(program_id: &Pubkey, accounts: &[AccountInfo], data: Emit) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-
-    if metadata_info.owner != program_id {
-        return Err(ProgramError::IllegalOwner);
-    }
-
-    let buffer = metadata_info.try_borrow_data()?;
-    let state = TlvStateBorrowed::unpack(&buffer)?;
-    let metadata_bytes = state.get_first_bytes::<TokenMetadata>()?;
-
-    if let Some(range) = TokenMetadata::get_slice(metadata_bytes, data.start, data.end) {
-        set_return_data(range);
-    }
-
-    Ok(())
-}
-
-/// Processes an [Instruction](enum.Instruction.html).
-pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-    let instruction = TokenMetadataInstruction::unpack(input)?;
-
-    match instruction {
-        TokenMetadataInstruction::Initialize(data) => {
-            msg!("Instruction: Initialize");
-            process_initialize(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::UpdateField(data) => {
-            msg!("Instruction: UpdateField");
-            process_update_field(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::RemoveKey(data) => {
-            msg!("Instruction: RemoveKey");
-            process_remove_key(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::UpdateAuthority(data) => {
-            msg!("Instruction: UpdateAuthority");
-            process_update_authority(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::Emit(data) => {
-            msg!("Instruction: Emit");
-            process_emit(program_id, accounts, data)
-        }
-    }
-}
diff --git a/token-metadata/example/tests/emit.rs b/token-metadata/example/tests/emit.rs
deleted file mode 100644
index bfac603451b..00000000000
--- a/token-metadata/example/tests/emit.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{setup, setup_metadata, setup_mint},
-    solana_program_test::tokio,
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked, program::MAX_RETURN_DATA, pubkey::Pubkey,
-        signature::Signer, signer::keypair::Keypair, transaction::Transaction,
-    },
-    spl_token_metadata_interface::{borsh, instruction::emit, state::TokenMetadata},
-    test_case::test_case,
-};
-
-#[test_case(Some(40), Some(40) ; "zero bytes")]
-#[test_case(Some(40), Some(41) ; "one byte")]
-#[test_case(Some(1_000_000), Some(1_000_001) ; "too far")]
-#[test_case(Some(50), Some(49) ; "wrong way")]
-#[test_case(Some(50), None ; "truncate start")]
-#[test_case(None, Some(50) ; "truncate end")]
-#[test_case(None, None ; "full data")]
-#[tokio::test]
-async fn success(start: Option<u64>, end: Option<u64>) {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Pubkey::new_unique();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[emit(&program_id, &metadata_pubkey, start, end)],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let simulation = context
-        .banks_client
-        .simulate_transaction(transaction)
-        .await
-        .unwrap();
-
-    let metadata_buffer = borsh::to_vec(&token_metadata).unwrap();
-    if let Some(check_buffer) = TokenMetadata::get_slice(&metadata_buffer, start, end) {
-        if !check_buffer.is_empty() {
-            // pad the data if necessary
-            let mut return_data = vec![0; MAX_RETURN_DATA];
-            let simulation_return_data =
-                simulation.simulation_details.unwrap().return_data.unwrap();
-            assert_eq!(simulation_return_data.program_id, program_id);
-            return_data[..simulation_return_data.data.len()]
-                .copy_from_slice(&simulation_return_data.data);
-
-            assert_eq!(*check_buffer, return_data[..check_buffer.len()]);
-            // we're sure that we're getting the full data, so also compare the deserialized
-            // type
-            if start.is_none() && end.is_none() {
-                let emitted_token_metadata =
-                    try_from_slice_unchecked::<TokenMetadata>(&return_data).unwrap();
-                assert_eq!(token_metadata, emitted_token_metadata);
-            }
-        } else {
-            assert!(simulation.simulation_details.unwrap().return_data.is_none());
-        }
-    } else {
-        assert!(simulation.simulation_details.unwrap().return_data.is_none());
-    }
-}
diff --git a/token-metadata/example/tests/initialize.rs b/token-metadata/example/tests/initialize.rs
deleted file mode 100644
index ccd50373e84..00000000000
--- a/token-metadata/example/tests/initialize.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{setup, setup_metadata, setup_mint},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_metadata_interface::{
-        error::TokenMetadataError, instruction::initialize, state::TokenMetadata,
-    },
-    spl_type_length_value::{
-        error::TlvError,
-        state::{TlvState, TlvStateBorrowed},
-    },
-};
-
-#[tokio::test]
-async fn success_initialize() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Pubkey::new_unique();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    // check that the data is correct
-    let fetched_metadata_account = context
-        .banks_client
-        .get_account(metadata_pubkey)
-        .await
-        .unwrap()
-        .unwrap();
-    let fetched_metadata_state = TlvStateBorrowed::unpack(&fetched_metadata_account.data).unwrap();
-    let fetched_metadata = fetched_metadata_state
-        .get_first_variable_len_value::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // fail doing it again, and reverse some params to ensure a new tx
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[initialize(
-                &program_id,
-                &metadata_pubkey,
-                &update_authority,
-                token.get_address(),
-                &mint_authority_pubkey,
-                token_metadata.symbol.clone(), // intentionally reversed!
-                token_metadata.name.clone(),
-                token_metadata.uri.clone(),
-            )],
-            Some(&payer.pubkey()),
-            &[&payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TlvError::TypeAlreadyExists as u32)
-            )
-        );
-    }
-}
-
-#[tokio::test]
-async fn fail_without_authority_signature() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Pubkey::new_unique();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = token_metadata.tlv_size_of().unwrap();
-    let rent_lamports = rent.minimum_balance(space);
-    let mut initialize_ix = initialize(
-        &program_id,
-        &metadata_pubkey,
-        &update_authority,
-        token.get_address(),
-        &mint_authority_pubkey,
-        token_metadata.name.clone(),
-        token_metadata.symbol.clone(),
-        token_metadata.uri.clone(),
-    );
-    initialize_ix.accounts[3].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &metadata_pubkey,
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_ix,
-        ],
-        Some(&payer.pubkey()),
-        &[&payer, &metadata_keypair],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature,)
-    );
-}
-
-#[tokio::test]
-async fn fail_incorrect_authority() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Pubkey::new_unique();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = token_metadata.tlv_size_of().unwrap();
-    let rent_lamports = rent.minimum_balance(space);
-    let mut initialize_ix = initialize(
-        &program_id,
-        &metadata_pubkey,
-        &update_authority,
-        token.get_address(),
-        &metadata_pubkey,
-        token_metadata.name.clone(),
-        token_metadata.symbol.clone(),
-        token_metadata.uri.clone(),
-    );
-    initialize_ix.accounts[3].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &metadata_pubkey,
-                rent_lamports,
-                space.try_into().unwrap(),
-                &program_id,
-            ),
-            initialize_ix,
-        ],
-        Some(&payer.pubkey()),
-        &[&payer, &metadata_keypair],
-        context.last_blockhash,
-    );
-
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            1,
-            InstructionError::Custom(TokenMetadataError::IncorrectMintAuthority as u32)
-        )
-    );
-}
diff --git a/token-metadata/example/tests/program_test.rs b/token-metadata/example/tests/program_test.rs
deleted file mode 100644
index 19e91eea18d..00000000000
--- a/token-metadata/example/tests/program_test.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio::sync::Mutex, ProgramTest, ProgramTestContext},
-    solana_sdk::{
-        pubkey::Pubkey, signature::Signer, signer::keypair::Keypair, system_instruction,
-        transaction::Transaction,
-    },
-    spl_token_client::{
-        client::{
-            ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient,
-            SendTransaction, SimulateTransaction,
-        },
-        token::Token,
-    },
-    spl_token_metadata_interface::{
-        instruction::{initialize, update_field},
-        state::{Field, TokenMetadata},
-    },
-    std::sync::Arc,
-};
-
-fn keypair_clone(kp: &Keypair) -> Keypair {
-    Keypair::from_bytes(&kp.to_bytes()).expect("failed to copy keypair")
-}
-
-pub async fn setup(
-    program_id: &Pubkey,
-) -> (
-    Arc<Mutex<ProgramTestContext>>,
-    Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>>,
-    Arc<Keypair>,
-) {
-    let mut program_test = ProgramTest::new(
-        "spl_token_metadata_example",
-        *program_id,
-        processor!(spl_token_metadata_example::processor::process),
-    );
-
-    program_test.prefer_bpf(false); // simplicity in the build
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(spl_token_2022::processor::Processor::process),
-    );
-
-    let context = program_test.start_with_context().await;
-    let payer = Arc::new(keypair_clone(&context.payer));
-    let context = Arc::new(Mutex::new(context));
-
-    let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
-        Arc::new(ProgramBanksClient::new_from_context(
-            Arc::clone(&context),
-            ProgramBanksClientProcessTransaction,
-        ));
-    (context, client, payer)
-}
-
-pub async fn setup_mint<T: SendTransaction + SimulateTransaction>(
-    program_id: &Pubkey,
-    mint_authority: &Pubkey,
-    decimals: u8,
-    payer: Arc<Keypair>,
-    client: Arc<dyn ProgramClient<T>>,
-) -> Token<T> {
-    let mint_account = Keypair::new();
-    let token = Token::new(
-        client,
-        program_id,
-        &mint_account.pubkey(),
-        Some(decimals),
-        payer,
-    );
-    token
-        .create_mint(mint_authority, None, vec![], &[&mint_account])
-        .await
-        .unwrap();
-    token
-}
-
-pub async fn setup_metadata(
-    context: &mut ProgramTestContext,
-    metadata_program_id: &Pubkey,
-    mint: &Pubkey,
-    token_metadata: &TokenMetadata,
-    metadata_keypair: &Keypair,
-    mint_authority: &Keypair,
-) {
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let space = token_metadata.tlv_size_of().unwrap();
-    let rent_lamports = rent.minimum_balance(space);
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &metadata_keypair.pubkey(),
-                rent_lamports,
-                space.try_into().unwrap(),
-                metadata_program_id,
-            ),
-            initialize(
-                metadata_program_id,
-                &metadata_keypair.pubkey(),
-                &Option::<Pubkey>::from(token_metadata.update_authority).unwrap(),
-                mint,
-                &mint_authority.pubkey(),
-                token_metadata.name.clone(),
-                token_metadata.symbol.clone(),
-                token_metadata.uri.clone(),
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, metadata_keypair, mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
-
-#[allow(dead_code)]
-pub async fn setup_update_field(
-    context: &mut ProgramTestContext,
-    metadata_program_id: &Pubkey,
-    token_metadata: &mut TokenMetadata,
-    metadata: &Pubkey,
-    update_authority: &Keypair,
-    field: Field,
-    value: String,
-) {
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let old_space = token_metadata.tlv_size_of().unwrap();
-    let old_rent_lamports = rent.minimum_balance(old_space);
-
-    token_metadata.update(field.clone(), value.clone());
-
-    let new_space = token_metadata.tlv_size_of().unwrap();
-    let new_rent_lamports = rent.minimum_balance(new_space);
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                metadata,
-                new_rent_lamports.saturating_sub(old_rent_lamports),
-            ),
-            update_field(
-                metadata_program_id,
-                metadata,
-                &update_authority.pubkey(),
-                field,
-                value,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, update_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
diff --git a/token-metadata/example/tests/remove_key.rs b/token-metadata/example/tests/remove_key.rs
deleted file mode 100644
index 505113fedd3..00000000000
--- a/token-metadata/example/tests/remove_key.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{setup, setup_metadata, setup_mint, setup_update_field},
-    solana_program_test::{tokio, ProgramTestBanksClientExt},
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::remove_key,
-        state::{Field, TokenMetadata},
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
-};
-
-#[tokio::test]
-async fn success_remove() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    let key = "key".to_string();
-    let value = "value".to_string();
-    let field = Field::Key(key.clone());
-    setup_update_field(
-        &mut context,
-        &program_id,
-        &mut token_metadata,
-        &metadata_pubkey,
-        &update_authority,
-        field,
-        value,
-    )
-    .await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[remove_key(
-            &program_id,
-            &metadata_pubkey,
-            &update_authority.pubkey(),
-            key.clone(),
-            false, // idempotent
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &update_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    token_metadata.remove_key(&key);
-    let fetched_metadata_account = context
-        .banks_client
-        .get_account(metadata_pubkey)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata_account.data.len(),
-        token_metadata.tlv_size_of().unwrap()
-    );
-    let fetched_metadata_state = TlvStateBorrowed::unpack(&fetched_metadata_account.data).unwrap();
-    let fetched_metadata = fetched_metadata_state
-        .get_first_variable_len_value::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // refresh blockhash before trying again
-    let last_blockhash = context.last_blockhash;
-    let last_blockhash = context
-        .banks_client
-        .get_new_latest_blockhash(&last_blockhash)
-        .await
-        .unwrap();
-
-    // fail doing it again without idempotent flag
-    let transaction = Transaction::new_signed_with_payer(
-        &[remove_key(
-            &program_id,
-            &metadata_pubkey,
-            &update_authority.pubkey(),
-            key.clone(),
-            false, // idempotent
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &update_authority],
-        last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenMetadataError::KeyNotFound as u32)
-        )
-    );
-
-    // succeed with idempotent flag
-    let transaction = Transaction::new_signed_with_payer(
-        &[remove_key(
-            &program_id,
-            &metadata_pubkey,
-            &update_authority.pubkey(),
-            key,
-            true, // idempotent
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &update_authority],
-        last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    // no signature
-    let mut instruction = remove_key(
-        &program_id,
-        &metadata_pubkey,
-        &update_authority.pubkey(),
-        "new_name".to_string(),
-        true, // idempotent
-    );
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-
-    // wrong authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[remove_key(
-            &program_id,
-            &metadata_pubkey,
-            &payer.pubkey(),
-            "new_name".to_string(),
-            true, // idempotent
-        )],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32),
-        )
-    );
-}
diff --git a/token-metadata/example/tests/update_authority.rs b/token-metadata/example/tests/update_authority.rs
deleted file mode 100644
index cb2251b8d30..00000000000
--- a/token-metadata/example/tests/update_authority.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{setup, setup_metadata, setup_mint},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_metadata_interface::{
-        error::TokenMetadataError, instruction::update_authority, state::TokenMetadata,
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
-};
-
-#[tokio::test]
-async fn success_update() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    let new_update_authority = Keypair::new();
-    let new_update_authority_pubkey =
-        OptionalNonZeroPubkey::try_from(Some(new_update_authority.pubkey())).unwrap();
-    token_metadata.update_authority = new_update_authority_pubkey;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_authority(
-            &program_id,
-            &metadata_pubkey,
-            &authority.pubkey(),
-            new_update_authority_pubkey,
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let fetched_metadata_account = context
-        .banks_client
-        .get_account(metadata_pubkey)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata_account.data.len(),
-        token_metadata.tlv_size_of().unwrap()
-    );
-    let fetched_metadata_state = TlvStateBorrowed::unpack(&fetched_metadata_account.data).unwrap();
-    let fetched_metadata = fetched_metadata_state
-        .get_first_variable_len_value::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // unset
-    token_metadata.update_authority = None.try_into().unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_authority(
-            &program_id,
-            &metadata_pubkey,
-            &new_update_authority.pubkey(),
-            None.try_into().unwrap(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &new_update_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let fetched_metadata_account = context
-        .banks_client
-        .get_account(metadata_pubkey)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata_account.data.len(),
-        token_metadata.tlv_size_of().unwrap()
-    );
-    let fetched_metadata_state = TlvStateBorrowed::unpack(&fetched_metadata_account.data).unwrap();
-    let fetched_metadata = fetched_metadata_state
-        .get_first_variable_len_value::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // fail to update
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_authority(
-            &program_id,
-            &metadata_pubkey,
-            &new_update_authority.pubkey(),
-            Some(new_update_authority.pubkey()).try_into().unwrap(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &new_update_authority],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenMetadataError::ImmutableMetadata as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    // no signature
-    let mut instruction = update_authority(
-        &program_id,
-        &metadata_pubkey,
-        &authority.pubkey(),
-        None.try_into().unwrap(),
-    );
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-
-    // wrong authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_authority(
-            &program_id,
-            &metadata_pubkey,
-            &payer.pubkey(),
-            None.try_into().unwrap(),
-        )],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32),
-        )
-    );
-}
diff --git a/token-metadata/example/tests/update_field.rs b/token-metadata/example/tests/update_field.rs
deleted file mode 100644
index d44356df91b..00000000000
--- a/token-metadata/example/tests/update_field.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-#![cfg(feature = "test-sbf")]
-#![allow(clippy::items_after_test_module)]
-
-mod program_test;
-use {
-    program_test::{setup, setup_metadata, setup_mint},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::update_field,
-        state::{Field, TokenMetadata},
-    },
-    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
-    test_case::test_case,
-};
-
-#[test_case(Field::Name, "This is my larger name".to_string() ; "larger name")]
-#[test_case(Field::Name, "Smaller".to_string() ; "smaller name")]
-#[test_case(Field::Key("my new field".to_string()), "Some data for the new field!".to_string() ; "new field")]
-#[tokio::test]
-async fn success_update(field: Field, value: String) {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let old_space = token_metadata.tlv_size_of().unwrap();
-    let old_rent_lamports = rent.minimum_balance(old_space);
-
-    token_metadata.update(field.clone(), value.clone());
-
-    let new_space = token_metadata.tlv_size_of().unwrap();
-
-    if new_space > old_space {
-        // fails without more lamports
-        let transaction = Transaction::new_signed_with_payer(
-            &[update_field(
-                &program_id,
-                &metadata_pubkey,
-                &update_authority.pubkey(),
-                field.clone(),
-                value.clone(),
-            )],
-            Some(&payer.pubkey()),
-            &[&payer, &update_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InsufficientFundsForRent { account_index: 2 }
-        );
-    }
-
-    // transfer required lamports
-    let new_rent_lamports = rent.minimum_balance(new_space);
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &payer.pubkey(),
-                &metadata_pubkey,
-                new_rent_lamports.saturating_sub(old_rent_lamports),
-            ),
-            update_field(
-                &program_id,
-                &metadata_pubkey,
-                &update_authority.pubkey(),
-                field.clone(),
-                value.clone(),
-            ),
-        ],
-        Some(&payer.pubkey()),
-        &[&payer, &update_authority],
-        context.last_blockhash,
-    );
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let fetched_metadata_account = context
-        .banks_client
-        .get_account(metadata_pubkey)
-        .await
-        .unwrap()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata_account.data.len(),
-        token_metadata.tlv_size_of().unwrap()
-    );
-    let fetched_metadata_state = TlvStateBorrowed::unpack(&fetched_metadata_account.data).unwrap();
-    let fetched_metadata = fetched_metadata_state
-        .get_first_variable_len_value::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = Pubkey::new_unique();
-    let (context, client, payer) = setup(&program_id).await;
-
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-
-    let token_program_id = spl_token_2022::id();
-    let decimals = 2;
-    let token = setup_mint(
-        &token_program_id,
-        &mint_authority_pubkey,
-        decimals,
-        payer.clone(),
-        client.clone(),
-    )
-    .await;
-    let mut context = context.lock().await;
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token.get_address(),
-        ..Default::default()
-    };
-
-    let metadata_keypair = Keypair::new();
-    let metadata_pubkey = metadata_keypair.pubkey();
-
-    setup_metadata(
-        &mut context,
-        &program_id,
-        token.get_address(),
-        &token_metadata,
-        &metadata_keypair,
-        &mint_authority,
-    )
-    .await;
-
-    // no signature
-    let mut instruction = update_field(
-        &program_id,
-        &metadata_pubkey,
-        &update_authority.pubkey(),
-        Field::Name,
-        "new_name".to_string(),
-    );
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-
-    // wrong authority
-    let transaction = Transaction::new_signed_with_payer(
-        &[update_field(
-            &program_id,
-            &metadata_pubkey,
-            &payer.pubkey(),
-            Field::Name,
-            "new_name".to_string(),
-        )],
-        Some(&payer.pubkey()),
-        &[payer.as_ref()],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32),
-        )
-    );
-}
diff --git a/token-metadata/interface/Cargo.toml b/token-metadata/interface/Cargo.toml
deleted file mode 100644
index fe654c82e9d..00000000000
--- a/token-metadata/interface/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "spl-token-metadata-interface"
-version = "0.3.3"
-description = "Solana Program Library Token Metadata Interface"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-serde-traits = ["dep:serde", "spl-pod/serde-traits"]
-
-[dependencies]
-borsh = "1.5.1"
-serde = { version = "1.0.203", optional = true }
-solana-program = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2", path = "../../libraries/discriminator" }
-spl-program-error = { version = "0.4.0", path = "../../libraries/program-error" }
-spl-type-length-value = { version = "0.4.3", path = "../../libraries/type-length-value" }
-spl-pod = { version = "0.2.2", path = "../../libraries/pod", features = [
-  "borsh",
-] }
-
-[dev-dependencies]
-serde_json = "1.0.117"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token-metadata/interface/README.md b/token-metadata/interface/README.md
deleted file mode 100644
index 3ee6d402999..00000000000
--- a/token-metadata/interface/README.md
+++ /dev/null
@@ -1,107 +0,0 @@
-## Token-Metadata Interface
-
-An interface describing the instructions required for a program to implement
-to be considered a "token-metadata" program for SPL token mints. The interface
-can be implemented by any program.
-
-With a common interface, any wallet, dapp, or on-chain program can read the metadata,
-and any tool that creates or modifies metadata will just work with any program
-that implements the interface.
-
-There is also a `TokenMetadata` struct that may optionally be implemented, but
-is not required because of the `Emit` instruction, which indexers and other off-chain
-users can call to get metadata.
-
-### Example program
-
-Coming soon!
-
-### Motivation
-
-Token creators on Solana need all sorts of functionality for their token-metadata,
-and the Metaplex Token-Metadata program has been the one place for all metadata
-needs, leading to a feature-rich program that still might not serve all needs.
-
-At its base, token-metadata is a set of data fields associated to a particular token
-mint, so we propose an interface that serves the simplest base case with some
-compatibility with existing solutions.
-
-With this proposal implemented, fungible and non-fungible token creators will
-have two options:
-
-* implement the interface in their own program, so they can eventually extend it
-with new functionality or even other interfaces
-* use a reference program that implements the simplest case
-
-### Required Instructions
-
-All of the following instructions are listed in greater detail in the source code.
-Once the interface is decided, the information in the source code will be copied
-here.
-
-#### Initialize
-
-Initializes the token-metadata TLV entry in an account with an update authority,
-name, symbol, and URI.
-
-Must provide an SPL token mint and be signed by the mint authority.
-
-#### Update Field
-
-Updates a field in a token-metadata account. This may be an existing or totally
-new field.
-
-Must be signed by the update authority.
-
-#### Remove Key
-
-Unsets a key-value pair, clearing an existing entry.
-
-Must be signed by the update authority.
-
-#### Update Authority
-
-Sets or unsets the token-metadata update authority, which signs any future updates
-to the metadata.
-
-Must be signed by the update authority.
-
-#### Emit
-
-Emits token-metadata in the expected `TokenMetadata` state format. Although
-implementing a struct that uses the exact state is optional, this instruction is
-required.
-
-### (Optional) State
-
-A program that implements the interface may write the following data fields
-into a type-length-value entry into an account:
-
-```rust
-type Pubkey = [u8; 32];
-type OptionalNonZeroPubkey = Pubkey; // if all zeroes, interpreted as `None`
-
-pub struct TokenMetadata {
-    /// The authority that can sign to update the metadata
-    pub update_authority: OptionalNonZeroPubkey,
-    /// The associated mint, used to counter spoofing to be sure that metadata
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The longer name of the token
-    pub name: String,
-    /// The shortened symbol for the token
-    pub symbol: String,
-    /// The URI pointing to richer metadata
-    pub uri: String,
-    /// Any additional metadata about the token as key-value pairs. The program
-    /// must avoid storing the same key twice.
-    pub additional_metadata: Vec<(String, String)>,
-}
-```
-
-By storing the metadata in a TLV structure, a developer who implements this
-interface in their program can freely add any other data fields in a different
-TLV entry.
-
-You can find more information about TLV / type-length-value structures at the
-[spl-type-length-value repo](https://github.com/solana-labs/solana-program-library/tree/master/libraries/type-length-value).
diff --git a/token-metadata/interface/src/error.rs b/token-metadata/interface/src/error.rs
deleted file mode 100644
index 3f5b2437865..00000000000
--- a/token-metadata/interface/src/error.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//! Interface error types
-
-use spl_program_error::*;
-
-/// Errors that may be returned by the interface.
-#[spl_program_error(hash_error_code_start = 901_952_957)]
-pub enum TokenMetadataError {
-    /// Incorrect account provided
-    #[error("Incorrect account provided")]
-    IncorrectAccount,
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-    /// Incorrect metadata update authority has signed the instruction
-    #[error("Incorrect metadata update authority has signed the instruction")]
-    IncorrectUpdateAuthority,
-    /// Token metadata has no update authority
-    #[error("Token metadata has no update authority")]
-    ImmutableMetadata,
-    /// Key not found in metadata account
-    #[error("Key not found in metadata account")]
-    KeyNotFound,
-}
diff --git a/token-metadata/interface/src/instruction.rs b/token-metadata/interface/src/instruction.rs
deleted file mode 100644
index bcb606b3a8b..00000000000
--- a/token-metadata/interface/src/instruction.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-//! Instruction types
-
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::state::Field,
-    borsh::{BorshDeserialize, BorshSerialize},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_discriminator::{discriminator::ArrayDiscriminator, SplDiscriminate},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Initialization instruction data
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_metadata_interface:initialize_account")]
-pub struct Initialize {
-    /// Longer name of the token
-    pub name: String,
-    /// Shortened symbol of the token
-    pub symbol: String,
-    /// URI pointing to more metadata (image, video, etc.)
-    pub uri: String,
-}
-
-/// Update field instruction data
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_metadata_interface:updating_field")]
-pub struct UpdateField {
-    /// Field to update in the metadata
-    pub field: Field,
-    /// Value to write for the field
-    pub value: String,
-}
-
-/// Remove key instruction data
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_metadata_interface:remove_key_ix")]
-pub struct RemoveKey {
-    /// If the idempotent flag is set to true, then the instruction will not
-    /// error if the key does not exist
-    pub idempotent: bool,
-    /// Key to remove in the additional metadata portion
-    pub key: String,
-}
-
-/// Update authority instruction data
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, SplDiscriminate)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[discriminator_hash_input("spl_token_metadata_interface:update_the_authority")]
-pub struct UpdateAuthority {
-    /// New authority for the token metadata, or unset if `None`
-    pub new_authority: OptionalNonZeroPubkey,
-}
-
-/// Instruction data for Emit
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize, SplDiscriminate)]
-#[discriminator_hash_input("spl_token_metadata_interface:emitter")]
-pub struct Emit {
-    /// Start of range of data to emit
-    pub start: Option<u64>,
-    /// End of range of data to emit
-    pub end: Option<u64>,
-}
-
-/// All instructions that must be implemented in the token-metadata interface
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq)]
-pub enum TokenMetadataInstruction {
-    /// Initializes a TLV entry with the basic token-metadata fields.
-    ///
-    /// Assumes that the provided mint is an SPL token mint, that the metadata
-    /// account is allocated and assigned to the program, and that the metadata
-    /// account has enough lamports to cover the rent-exempt reserve.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Metadata
-    ///   1. `[]` Update authority
-    ///   2. `[]` Mint
-    ///   3. `[s]` Mint authority
-    ///
-    /// Data: `Initialize` data, name / symbol / uri strings
-    Initialize(Initialize),
-
-    /// Updates a field in a token-metadata account.
-    ///
-    /// The field can be one of the required fields (name, symbol, URI), or a
-    /// totally new field denoted by a "key" string.
-    ///
-    /// By the end of the instruction, the metadata account must be properly
-    /// resized based on the new size of the TLV entry.
-    ///   * If the new size is larger, the program must first reallocate to
-    ///     avoid
-    ///   overwriting other TLV entries.
-    ///   * If the new size is smaller, the program must reallocate at the end
-    ///   so that it's possible to iterate over TLV entries
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Metadata account
-    ///   1. `[s]` Update authority
-    ///
-    /// Data: `UpdateField` data, specifying the new field and value. If the
-    /// field does not exist on the account, it will be created. If the
-    /// field does exist, it will be overwritten.
-    UpdateField(UpdateField),
-
-    /// Removes a key-value pair in a token-metadata account.
-    ///
-    /// This only applies to additional fields, and not the base name / symbol /
-    /// URI fields.
-    ///
-    /// By the end of the instruction, the metadata account must be properly
-    /// resized at the end based on the new size of the TLV entry.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Metadata account
-    ///   1. `[s]` Update authority
-    ///
-    /// Data: the string key to remove. If the idempotent flag is set to false,
-    /// returns an error if the key is not present
-    RemoveKey(RemoveKey),
-
-    /// Updates the token-metadata authority
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Metadata account
-    ///   1. `[s]` Current update authority
-    ///
-    /// Data: the new authority. Can be unset using a `None` value
-    UpdateAuthority(UpdateAuthority),
-
-    /// Emits the token-metadata as return data
-    ///
-    /// The format of the data emitted follows exactly the `TokenMetadata`
-    /// struct, but it's possible that the account data is stored in another
-    /// format by the program.
-    ///
-    /// With this instruction, a program that implements the token-metadata
-    /// interface can return `TokenMetadata` without adhering to the specific
-    /// byte layout of the `TokenMetadata` struct in any accounts.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` Metadata account
-    Emit(Emit),
-}
-impl TokenMetadataInstruction {
-    /// Unpacks a byte buffer into a
-    /// [TokenMetadataInstruction](enum.TokenMetadataInstruction.html).
-    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
-        if input.len() < ArrayDiscriminator::LENGTH {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-        let (discriminator, rest) = input.split_at(ArrayDiscriminator::LENGTH);
-        Ok(match discriminator {
-            Initialize::SPL_DISCRIMINATOR_SLICE => {
-                let data = Initialize::try_from_slice(rest)?;
-                Self::Initialize(data)
-            }
-            UpdateField::SPL_DISCRIMINATOR_SLICE => {
-                let data = UpdateField::try_from_slice(rest)?;
-                Self::UpdateField(data)
-            }
-            RemoveKey::SPL_DISCRIMINATOR_SLICE => {
-                let data = RemoveKey::try_from_slice(rest)?;
-                Self::RemoveKey(data)
-            }
-            UpdateAuthority::SPL_DISCRIMINATOR_SLICE => {
-                let data = UpdateAuthority::try_from_slice(rest)?;
-                Self::UpdateAuthority(data)
-            }
-            Emit::SPL_DISCRIMINATOR_SLICE => {
-                let data = Emit::try_from_slice(rest)?;
-                Self::Emit(data)
-            }
-            _ => return Err(ProgramError::InvalidInstructionData),
-        })
-    }
-
-    /// Packs a [TokenInstruction](enum.TokenInstruction.html) into a byte
-    /// buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = vec![];
-        match self {
-            Self::Initialize(data) => {
-                buf.extend_from_slice(Initialize::SPL_DISCRIMINATOR_SLICE);
-                buf.append(&mut borsh::to_vec(data).unwrap());
-            }
-            Self::UpdateField(data) => {
-                buf.extend_from_slice(UpdateField::SPL_DISCRIMINATOR_SLICE);
-                buf.append(&mut borsh::to_vec(data).unwrap());
-            }
-            Self::RemoveKey(data) => {
-                buf.extend_from_slice(RemoveKey::SPL_DISCRIMINATOR_SLICE);
-                buf.append(&mut borsh::to_vec(data).unwrap());
-            }
-            Self::UpdateAuthority(data) => {
-                buf.extend_from_slice(UpdateAuthority::SPL_DISCRIMINATOR_SLICE);
-                buf.append(&mut borsh::to_vec(data).unwrap());
-            }
-            Self::Emit(data) => {
-                buf.extend_from_slice(Emit::SPL_DISCRIMINATOR_SLICE);
-                buf.append(&mut borsh::to_vec(data).unwrap());
-            }
-        };
-        buf
-    }
-}
-
-/// Creates an `Initialize` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn initialize(
-    program_id: &Pubkey,
-    metadata: &Pubkey,
-    update_authority: &Pubkey,
-    mint: &Pubkey,
-    mint_authority: &Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-) -> Instruction {
-    let data = TokenMetadataInstruction::Initialize(Initialize { name, symbol, uri });
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*metadata, false),
-            AccountMeta::new_readonly(*update_authority, false),
-            AccountMeta::new_readonly(*mint, false),
-            AccountMeta::new_readonly(*mint_authority, true),
-        ],
-        data: data.pack(),
-    }
-}
-
-/// Creates an `UpdateField` instruction
-pub fn update_field(
-    program_id: &Pubkey,
-    metadata: &Pubkey,
-    update_authority: &Pubkey,
-    field: Field,
-    value: String,
-) -> Instruction {
-    let data = TokenMetadataInstruction::UpdateField(UpdateField { field, value });
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*metadata, false),
-            AccountMeta::new_readonly(*update_authority, true),
-        ],
-        data: data.pack(),
-    }
-}
-
-/// Creates a `RemoveKey` instruction
-pub fn remove_key(
-    program_id: &Pubkey,
-    metadata: &Pubkey,
-    update_authority: &Pubkey,
-    key: String,
-    idempotent: bool,
-) -> Instruction {
-    let data = TokenMetadataInstruction::RemoveKey(RemoveKey { key, idempotent });
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*metadata, false),
-            AccountMeta::new_readonly(*update_authority, true),
-        ],
-        data: data.pack(),
-    }
-}
-
-/// Creates an `UpdateAuthority` instruction
-pub fn update_authority(
-    program_id: &Pubkey,
-    metadata: &Pubkey,
-    current_authority: &Pubkey,
-    new_authority: OptionalNonZeroPubkey,
-) -> Instruction {
-    let data = TokenMetadataInstruction::UpdateAuthority(UpdateAuthority { new_authority });
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![
-            AccountMeta::new(*metadata, false),
-            AccountMeta::new_readonly(*current_authority, true),
-        ],
-        data: data.pack(),
-    }
-}
-
-/// Creates an `Emit` instruction
-pub fn emit(
-    program_id: &Pubkey,
-    metadata: &Pubkey,
-    start: Option<u64>,
-    end: Option<u64>,
-) -> Instruction {
-    let data = TokenMetadataInstruction::Emit(Emit { start, end });
-    Instruction {
-        program_id: *program_id,
-        accounts: vec![AccountMeta::new_readonly(*metadata, false)],
-        data: data.pack(),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[cfg(feature = "serde-traits")]
-    use std::str::FromStr;
-    use {super::*, crate::NAMESPACE, solana_program::hash};
-
-    fn check_pack_unpack<T: BorshSerialize>(
-        instruction: TokenMetadataInstruction,
-        discriminator: &[u8],
-        data: T,
-    ) {
-        let mut expect = vec![];
-        expect.extend_from_slice(discriminator.as_ref());
-        expect.append(&mut borsh::to_vec(&data).unwrap());
-        let packed = instruction.pack();
-        assert_eq!(packed, expect);
-        let unpacked = TokenMetadataInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, instruction);
-    }
-
-    #[test]
-    fn initialize_pack() {
-        let name = "My test token";
-        let symbol = "TEST";
-        let uri = "http://test.test";
-        let data = Initialize {
-            name: name.to_string(),
-            symbol: symbol.to_string(),
-            uri: uri.to_string(),
-        };
-        let check = TokenMetadataInstruction::Initialize(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:initialize_account").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        check_pack_unpack(check, discriminator, data);
-    }
-
-    #[test]
-    fn update_field_pack() {
-        let field = "MyTestField";
-        let value = "http://test.uri";
-        let data = UpdateField {
-            field: Field::Key(field.to_string()),
-            value: value.to_string(),
-        };
-        let check = TokenMetadataInstruction::UpdateField(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:updating_field").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        check_pack_unpack(check, discriminator, data);
-    }
-
-    #[test]
-    fn remove_key_pack() {
-        let data = RemoveKey {
-            key: "MyTestField".to_string(),
-            idempotent: true,
-        };
-        let check = TokenMetadataInstruction::RemoveKey(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:remove_key_ix").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        check_pack_unpack(check, discriminator, data);
-    }
-
-    #[test]
-    fn update_authority_pack() {
-        let data = UpdateAuthority {
-            new_authority: OptionalNonZeroPubkey::default(),
-        };
-        let check = TokenMetadataInstruction::UpdateAuthority(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:update_the_authority").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        check_pack_unpack(check, discriminator, data);
-    }
-
-    #[test]
-    fn emit_pack() {
-        let data = Emit {
-            start: None,
-            end: Some(10),
-        };
-        let check = TokenMetadataInstruction::Emit(data.clone());
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:emitter").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        check_pack_unpack(check, discriminator, data);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn initialize_serde() {
-        let data = Initialize {
-            name: "Token Name".to_string(),
-            symbol: "TST".to_string(),
-            uri: "uri.test".to_string(),
-        };
-        let ix = TokenMetadataInstruction::Initialize(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected =
-            "{\"initialize\":{\"name\":\"Token Name\",\"symbol\":\"TST\",\"uri\":\"uri.test\"}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn update_field_serde() {
-        let data = UpdateField {
-            field: Field::Key("MyField".to_string()),
-            value: "my field value".to_string(),
-        };
-        let ix = TokenMetadataInstruction::UpdateField(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected =
-            "{\"updateField\":{\"field\":{\"key\":\"MyField\"},\"value\":\"my field value\"}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn remove_key_serde() {
-        let data = RemoveKey {
-            key: "MyTestField".to_string(),
-            idempotent: true,
-        };
-        let ix = TokenMetadataInstruction::RemoveKey(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected = "{\"removeKey\":{\"idempotent\":true,\"key\":\"MyTestField\"}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn update_authority_serde() {
-        let update_authority_option: Option<Pubkey> =
-            Some(Pubkey::from_str("4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM").unwrap());
-        let update_authority: OptionalNonZeroPubkey = update_authority_option.try_into().unwrap();
-        let data = UpdateAuthority {
-            new_authority: update_authority,
-        };
-        let ix = TokenMetadataInstruction::UpdateAuthority(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected = "{\"updateAuthority\":{\"newAuthority\":\"4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM\"}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn update_authority_serde_with_none() {
-        let data = UpdateAuthority {
-            new_authority: OptionalNonZeroPubkey::default(),
-        };
-        let ix = TokenMetadataInstruction::UpdateAuthority(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected = "{\"updateAuthority\":{\"newAuthority\":null}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-
-    #[cfg(feature = "serde-traits")]
-    #[test]
-    fn emit_serde() {
-        let data = Emit {
-            start: None,
-            end: Some(10),
-        };
-        let ix = TokenMetadataInstruction::Emit(data);
-        let serialized = serde_json::to_string(&ix).unwrap();
-        let serialized_expected = "{\"emit\":{\"start\":null,\"end\":10}}";
-        assert_eq!(&serialized, serialized_expected);
-
-        let deserialized = serde_json::from_str::<TokenMetadataInstruction>(&serialized).unwrap();
-        assert_eq!(ix, deserialized);
-    }
-}
diff --git a/token-metadata/interface/src/lib.rs b/token-metadata/interface/src/lib.rs
deleted file mode 100644
index a4329d6ff2b..00000000000
--- a/token-metadata/interface/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Crate defining an interface for token-metadata
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod error;
-pub mod instruction;
-pub mod state;
-
-// Export current sdk types for downstream users building with a different sdk
-// version Export borsh for downstream users
-pub use {borsh, solana_program};
-
-/// Namespace for all programs implementing token-metadata
-pub const NAMESPACE: &str = "spl_token_metadata_interface";
diff --git a/token-metadata/interface/src/state.rs b/token-metadata/interface/src/state.rs
deleted file mode 100644
index 1b94dee7feb..00000000000
--- a/token-metadata/interface/src/state.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-//! Token-metadata interface state types
-
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    solana_program::{
-        borsh1::{get_instance_packed_len, try_from_slice_unchecked},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_type_length_value::{
-        state::{TlvState, TlvStateBorrowed},
-        variable_len_pack::VariableLenPack,
-    },
-};
-
-/// Data struct for all token-metadata, stored in a TLV entry
-///
-/// The type and length parts must be handled by the TLV library, and not stored
-/// as part of this struct.
-#[derive(Clone, Debug, Default, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
-pub struct TokenMetadata {
-    /// The authority that can sign to update the metadata
-    pub update_authority: OptionalNonZeroPubkey,
-    /// The associated mint, used to counter spoofing to be sure that metadata
-    /// belongs to a particular mint
-    pub mint: Pubkey,
-    /// The longer name of the token
-    pub name: String,
-    /// The shortened symbol for the token
-    pub symbol: String,
-    /// The URI pointing to richer metadata
-    pub uri: String,
-    /// Any additional metadata about the token as key-value pairs. The program
-    /// must avoid storing the same key twice.
-    pub additional_metadata: Vec<(String, String)>,
-}
-impl SplDiscriminate for TokenMetadata {
-    /// Please use this discriminator in your program when matching
-    const SPL_DISCRIMINATOR: ArrayDiscriminator =
-        ArrayDiscriminator::new([112, 132, 90, 90, 11, 88, 157, 87]);
-}
-impl TokenMetadata {
-    /// Gives the total size of this struct as a TLV entry in an account
-    pub fn tlv_size_of(&self) -> Result<usize, ProgramError> {
-        TlvStateBorrowed::get_base_len()
-            .checked_add(get_instance_packed_len(self)?)
-            .ok_or(ProgramError::InvalidAccountData)
-    }
-
-    /// Updates a field in the metadata struct
-    pub fn update(&mut self, field: Field, value: String) {
-        match field {
-            Field::Name => self.name = value,
-            Field::Symbol => self.symbol = value,
-            Field::Uri => self.uri = value,
-            Field::Key(key) => self.set_key_value(key, value),
-        }
-    }
-
-    /// Sets a key-value pair in the additional metadata
-    ///
-    /// If the key is already present, overwrites the existing entry. Otherwise,
-    /// adds it to the end.
-    pub fn set_key_value(&mut self, new_key: String, new_value: String) {
-        for (key, value) in self.additional_metadata.iter_mut() {
-            if *key == new_key {
-                value.replace_range(.., &new_value);
-                return;
-            }
-        }
-        self.additional_metadata.push((new_key, new_value));
-    }
-
-    /// Removes the key-value pair given by the provided key. Returns true if
-    /// the key was found.
-    pub fn remove_key(&mut self, key: &str) -> bool {
-        let mut found_key = false;
-        self.additional_metadata.retain(|x| {
-            let should_retain = x.0 != key;
-            if !should_retain {
-                found_key = true;
-            }
-            should_retain
-        });
-        found_key
-    }
-
-    /// Get the slice corresponding to the given start and end range
-    pub fn get_slice(data: &[u8], start: Option<u64>, end: Option<u64>) -> Option<&[u8]> {
-        let start = start.unwrap_or(0) as usize;
-        let end = end.map(|x| x as usize).unwrap_or(data.len());
-        data.get(start..end)
-    }
-}
-impl VariableLenPack for TokenMetadata {
-    fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-        borsh::to_writer(&mut dst[..], self).map_err(Into::into)
-    }
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        try_from_slice_unchecked(src).map_err(Into::into)
-    }
-    fn get_packed_len(&self) -> Result<usize, ProgramError> {
-        get_instance_packed_len(self).map_err(Into::into)
-    }
-}
-
-/// Fields in the metadata account, used for updating
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub enum Field {
-    /// The name field, corresponding to `TokenMetadata.name`
-    Name,
-    /// The symbol field, corresponding to `TokenMetadata.symbol`
-    Symbol,
-    /// The uri field, corresponding to `TokenMetadata.uri`
-    Uri,
-    /// A user field, whose key is given by the associated string
-    Key(String),
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::NAMESPACE, solana_program::hash};
-
-    #[test]
-    fn discriminator() {
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:token_metadata").as_bytes()]);
-        let discriminator =
-            ArrayDiscriminator::try_from(&preimage.as_ref()[..ArrayDiscriminator::LENGTH]).unwrap();
-        assert_eq!(TokenMetadata::SPL_DISCRIMINATOR, discriminator);
-    }
-
-    #[test]
-    fn update() {
-        let name = "name".to_string();
-        let symbol = "symbol".to_string();
-        let uri = "uri".to_string();
-        let mut token_metadata = TokenMetadata {
-            name,
-            symbol,
-            uri,
-            ..Default::default()
-        };
-
-        // updating base fields
-        let new_name = "new_name".to_string();
-        token_metadata.update(Field::Name, new_name.clone());
-        assert_eq!(token_metadata.name, new_name);
-
-        let new_symbol = "new_symbol".to_string();
-        token_metadata.update(Field::Symbol, new_symbol.clone());
-        assert_eq!(token_metadata.symbol, new_symbol);
-
-        let new_uri = "new_uri".to_string();
-        token_metadata.update(Field::Uri, new_uri.clone());
-        assert_eq!(token_metadata.uri, new_uri);
-
-        // add new key-value pairs
-        let key1 = "key1".to_string();
-        let value1 = "value1".to_string();
-        token_metadata.update(Field::Key(key1.clone()), value1.clone());
-        assert_eq!(token_metadata.additional_metadata.len(), 1);
-        assert_eq!(
-            token_metadata.additional_metadata[0],
-            (key1.clone(), value1.clone())
-        );
-
-        let key2 = "key2".to_string();
-        let value2 = "value2".to_string();
-        token_metadata.update(Field::Key(key2.clone()), value2.clone());
-        assert_eq!(token_metadata.additional_metadata.len(), 2);
-        assert_eq!(
-            token_metadata.additional_metadata[0],
-            (key1.clone(), value1)
-        );
-        assert_eq!(
-            token_metadata.additional_metadata[1],
-            (key2.clone(), value2.clone())
-        );
-
-        // update first key, see that order is preserved
-        let new_value1 = "new_value1".to_string();
-        token_metadata.update(Field::Key(key1.clone()), new_value1.clone());
-        assert_eq!(token_metadata.additional_metadata.len(), 2);
-        assert_eq!(token_metadata.additional_metadata[0], (key1, new_value1));
-        assert_eq!(token_metadata.additional_metadata[1], (key2, value2));
-    }
-
-    #[test]
-    fn remove_key() {
-        let name = "name".to_string();
-        let symbol = "symbol".to_string();
-        let uri = "uri".to_string();
-        let mut token_metadata = TokenMetadata {
-            name,
-            symbol,
-            uri,
-            ..Default::default()
-        };
-
-        // add new key-value pair
-        let key = "key".to_string();
-        let value = "value".to_string();
-        token_metadata.update(Field::Key(key.clone()), value.clone());
-        assert_eq!(token_metadata.additional_metadata.len(), 1);
-        assert_eq!(token_metadata.additional_metadata[0], (key.clone(), value));
-
-        // remove it
-        assert!(token_metadata.remove_key(&key));
-        assert_eq!(token_metadata.additional_metadata.len(), 0);
-
-        // remove it again, returns false
-        assert!(!token_metadata.remove_key(&key));
-        assert_eq!(token_metadata.additional_metadata.len(), 0);
-    }
-}
diff --git a/token-metadata/js/.eslintignore b/token-metadata/js/.eslintignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token-metadata/js/.eslintignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token-metadata/js/.eslintrc b/token-metadata/js/.eslintrc
deleted file mode 100644
index 5aef10a4729..00000000000
--- a/token-metadata/js/.eslintrc
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "root": true,
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended",
-        "plugin:require-extensions/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier",
-        "require-extensions"
-    ],
-    "rules": {
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/consistent-type-imports": "error"
-    },
-    "overrides": [
-        {
-            "files": [
-                "examples/**/*",
-                "test/**/*"
-            ],
-            "rules": {
-                "require-extensions/require-extensions": "off",
-                "require-extensions/require-index": "off"
-            }
-        }
-    ]
-}
diff --git a/token-metadata/js/.gitignore b/token-metadata/js/.gitignore
deleted file mode 100644
index 21f33db819c..00000000000
--- a/token-metadata/js/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.idea
-.vscode
-.DS_Store
-
-node_modules
-
-pnpm-lock.yaml
-yarn.lock
-
-docs
-lib
-test-ledger
-*.tsbuildinfo
diff --git a/token-metadata/js/.mocharc.json b/token-metadata/js/.mocharc.json
deleted file mode 100644
index 451c14c3016..00000000000
--- a/token-metadata/js/.mocharc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "extension": ["ts"],
-    "node-option": ["experimental-specifier-resolution=node", "loader=ts-node/esm"],
-    "timeout": 5000
-}
diff --git a/token-metadata/js/.nojekyll b/token-metadata/js/.nojekyll
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/token-metadata/js/.prettierignore b/token-metadata/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token-metadata/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token-metadata/js/.prettierrc b/token-metadata/js/.prettierrc
deleted file mode 100644
index b9ce4c1923a..00000000000
--- a/token-metadata/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "printWidth": 120,
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}
\ No newline at end of file
diff --git a/token-metadata/js/LICENSE b/token-metadata/js/LICENSE
deleted file mode 100644
index d6456956733..00000000000
--- a/token-metadata/js/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/token-metadata/js/README.md b/token-metadata/js/README.md
deleted file mode 100644
index 851a95d9035..00000000000
--- a/token-metadata/js/README.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# `@solana/spl-token-metadata`
-
-A TypeScript interface describing the instructions required for a program to implement to be considered a "token-metadata" program for SPL token mints. The interface can be implemented by any program.
-
-## Links
-
-- [TypeScript Docs](https://solana-labs.github.io/solana-program-library/token-metadata/js/)
-- [FAQs (Frequently Asked Questions)](#faqs)
-- [Install](#install)
-- [Build from Source](#build-from-source)
-
-## FAQs
-
-### How can I get support?
-
-Please ask questions in the Solana Stack Exchange: https://solana.stackexchange.com/
-
-If you've found a bug or you'd like to request a feature, please
-[open an issue](https://github.com/solana-labs/solana-program-library/issues/new).
-
-## Install
-
-```shell
-npm install --save @solana/spl-token-metadata @solana/web3.js
-```
-_OR_
-```shell
-yarn add @solana/spl-token-metadata @solana/web3.js
-```
-
-## Build from Source
-
-0. Prerequisites
-
-* Node 16+
-* NPM 8+
-
-1. Clone the project:
-```shell
-git clone https://github.com/solana-labs/solana-program-library.git
-```
-
-2. Navigate to the library:
-```shell
-cd solana-program-library/token-metadata/js
-```
-
-3. Install the dependencies:
-```shell
-npm install
-```
-
-4. Build the library:
-```shell
-npm run build
-```
-
-5. Build the on-chain programs:
-```shell
-npm run test:build-programs
-```
diff --git a/token-metadata/js/package.json b/token-metadata/js/package.json
deleted file mode 100644
index c93f3f0fe75..00000000000
--- a/token-metadata/js/package.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-    "name": "@solana/spl-token-metadata",
-    "description": "SPL Token Metadata Interface JS API",
-    "version": "0.1.3",
-    "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "repository": "https://github.com/solana-labs/solana-program-library",
-    "license": "Apache-2.0",
-    "type": "module",
-    "sideEffects": false,
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "lib",
-        "src",
-        "LICENSE",
-        "README.md"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "./lib/cjs/index.js",
-    "module": "./lib/esm/index.js",
-    "types": "./lib/types/index.d.ts",
-    "exports": {
-        "types": "./lib/types/index.d.ts",
-        "require": "./lib/cjs/index.js",
-        "import": "./lib/esm/index.js"
-    },
-    "scripts": {
-        "build": "tsc --build --verbose tsconfig.all.json",
-        "clean": "shx rm -rf lib **/*.tsbuildinfo || true",
-        "deploy": "npm run deploy:docs",
-        "deploy:docs": "npm run docs && gh-pages --dest token-metadata/js --dist docs --dotfiles",
-        "docs": "shx rm -rf docs && typedoc && shx cp .nojekyll docs/",
-        "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-        "lint": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}' && eslint --max-warnings 0 .",
-        "lint:fix": "npm run fmt && eslint --fix .",
-        "nuke": "shx rm -rf node_modules package-lock.json || true",
-        "postbuild": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json",
-        "reinstall": "npm run nuke && npm install",
-        "release": "npm run clean && npm run build",
-        "test": "mocha test",
-        "watch": "tsc --build --verbose --watch tsconfig.all.json"
-    },
-    "peerDependencies": {
-        "@solana/web3.js": "^1.93.0"
-    },
-    "dependencies": {
-        "@solana/codecs": "2.0.0-preview.3",
-        "@solana/spl-type-length-value": "0.1.0"
-    },
-    "devDependencies": {
-        "@solana/web3.js": "^1.93.0",
-        "@types/chai": "^4.3.16",
-        "@types/mocha": "^10.0.6",
-        "@types/node": "^20.14.5",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
-        "chai": "^5.1.1",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "eslint-plugin-require-extensions": "^0.1.1",
-        "gh-pages": "^6.1.1",
-        "mocha": "^10.4.0",
-        "prettier": "^3.3.2",
-        "shx": "^0.3.4",
-        "ts-node": "^10.9.2",
-        "tslib": "^2.6.3",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
-    }
-}
diff --git a/token-metadata/js/src/errors.ts b/token-metadata/js/src/errors.ts
deleted file mode 100644
index b86785b0bb6..00000000000
--- a/token-metadata/js/src/errors.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-// Errors match those in rust https://github.com/solana-labs/solana-program-library/blob/master/token-metadata/interface/src/error.rs
-// Code follows: https://github.com/solana-labs/solana-program-library/blob/master/token/js/src/errors.tshttps://github.com/solana-labs/solana-program-library/blob/master/token/js/src/errors.ts
-
-/** Base class for errors */
-export class TokenMetadataError extends Error {
-    constructor(message?: string) {
-        super(message);
-    }
-}
-
-/** Thrown if incorrect account provided */
-export class IncorrectAccountError extends TokenMetadataError {
-    name = 'IncorrectAccountError';
-}
-
-/** Thrown if Mint has no mint authority */
-export class MintHasNoMintAuthorityError extends TokenMetadataError {
-    name = 'MintHasNoMintAuthorityError';
-}
-
-/** Thrown if Incorrect mint authority has signed the instruction */
-export class IncorrectMintAuthorityError extends TokenMetadataError {
-    name = 'IncorrectMintAuthorityError';
-}
-
-/** Thrown if Incorrect mint authority has signed the instruction */
-export class IncorrectUpdateAuthorityError extends TokenMetadataError {
-    name = 'IncorrectUpdateAuthorityError';
-}
-
-/** Thrown if Token metadata has no update authority */
-export class ImmutableMetadataError extends TokenMetadataError {
-    name = 'ImmutableMetadataError';
-}
-
-/** Thrown if Key not found in metadata account */
-export class KeyNotFoundError extends TokenMetadataError {
-    name = 'KeyNotFoundError';
-}
diff --git a/token-metadata/js/src/field.ts b/token-metadata/js/src/field.ts
deleted file mode 100644
index 58db19433ef..00000000000
--- a/token-metadata/js/src/field.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import type { Codec } from '@solana/codecs';
-import {
-    addCodecSizePrefix,
-    getU32Codec,
-    getUtf8Codec,
-    getStructCodec,
-    getTupleCodec,
-    getUnitCodec,
-} from '@solana/codecs';
-
-export enum Field {
-    Name,
-    Symbol,
-    Uri,
-}
-
-type FieldLayout = { __kind: 'Name' } | { __kind: 'Symbol' } | { __kind: 'Uri' } | { __kind: 'Key'; value: [string] };
-
-export const getFieldCodec = () =>
-    [
-        ['Name', getUnitCodec()],
-        ['Symbol', getUnitCodec()],
-        ['Uri', getUnitCodec()],
-        ['Key', getStructCodec([['value', getTupleCodec([addCodecSizePrefix(getUtf8Codec(), getU32Codec())])]])],
-    ] as const;
-
-export function getFieldConfig(field: Field | string): FieldLayout {
-    if (field === Field.Name || field === 'Name' || field === 'name') {
-        return { __kind: 'Name' };
-    } else if (field === Field.Symbol || field === 'Symbol' || field === 'symbol') {
-        return { __kind: 'Symbol' };
-    } else if (field === Field.Uri || field === 'Uri' || field === 'uri') {
-        return { __kind: 'Uri' };
-    } else {
-        return { __kind: 'Key', value: [field] };
-    }
-}
diff --git a/token-metadata/js/src/index.ts b/token-metadata/js/src/index.ts
deleted file mode 100644
index faffcde7683..00000000000
--- a/token-metadata/js/src/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './errors.js';
-export * from './field.js';
-export * from './instruction.js';
-export * from './state.js';
diff --git a/token-metadata/js/src/instruction.ts b/token-metadata/js/src/instruction.ts
deleted file mode 100644
index b428d4fef8e..00000000000
--- a/token-metadata/js/src/instruction.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import type { Encoder } from '@solana/codecs';
-import {
-    addEncoderSizePrefix,
-    fixEncoderSize,
-    getBooleanEncoder,
-    getBytesEncoder,
-    getDataEnumCodec,
-    getOptionEncoder,
-    getUtf8Encoder,
-    getStructEncoder,
-    getTupleEncoder,
-    getU32Encoder,
-    getU64Encoder,
-    transformEncoder,
-} from '@solana/codecs';
-import type { VariableSizeEncoder } from '@solana/codecs';
-import { splDiscriminate } from '@solana/spl-type-length-value';
-import type { PublicKey } from '@solana/web3.js';
-import { SystemProgram, TransactionInstruction } from '@solana/web3.js';
-
-import type { Field } from './field.js';
-import { getFieldCodec, getFieldConfig } from './field.js';
-
-function getInstructionEncoder<T extends object>(discriminator: Uint8Array, dataEncoder: Encoder<T>): Encoder<T> {
-    return transformEncoder(getTupleEncoder([getBytesEncoder(), dataEncoder]), (data: T): [Uint8Array, T] => [
-        discriminator,
-        data,
-    ]);
-}
-
-function getPublicKeyEncoder(): Encoder<PublicKey> {
-    return transformEncoder(fixEncoderSize(getBytesEncoder(), 32), (publicKey: PublicKey) => publicKey.toBytes());
-}
-
-function getStringEncoder(): VariableSizeEncoder<string> {
-    return addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder());
-}
-
-/**
- * Initializes a TLV entry with the basic token-metadata fields.
- *
- * Assumes that the provided mint is an SPL token mint, that the metadata
- * account is allocated and assigned to the program, and that the metadata
- * account has enough lamports to cover the rent-exempt reserve.
- */
-export interface InitializeInstructionArgs {
-    programId: PublicKey;
-    metadata: PublicKey;
-    updateAuthority: PublicKey;
-    mint: PublicKey;
-    mintAuthority: PublicKey;
-    name: string;
-    symbol: string;
-    uri: string;
-}
-
-export function createInitializeInstruction(args: InitializeInstructionArgs): TransactionInstruction {
-    const { programId, metadata, updateAuthority, mint, mintAuthority, name, symbol, uri } = args;
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: metadata },
-            { isSigner: false, isWritable: false, pubkey: updateAuthority },
-            { isSigner: false, isWritable: false, pubkey: mint },
-            { isSigner: true, isWritable: false, pubkey: mintAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_metadata_interface:initialize_account'),
-                getStructEncoder([
-                    ['name', getStringEncoder()],
-                    ['symbol', getStringEncoder()],
-                    ['uri', getStringEncoder()],
-                ])
-            ).encode({ name, symbol, uri })
-        ),
-    });
-}
-
-/**
- * If the field does not exist on the account, it will be created.
- * If the field does exist, it will be overwritten.
- */
-export interface UpdateFieldInstruction {
-    programId: PublicKey;
-    metadata: PublicKey;
-    updateAuthority: PublicKey;
-    field: Field | string;
-    value: string;
-}
-
-export function createUpdateFieldInstruction(args: UpdateFieldInstruction): TransactionInstruction {
-    const { programId, metadata, updateAuthority, field, value } = args;
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: metadata },
-            { isSigner: true, isWritable: false, pubkey: updateAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_metadata_interface:updating_field'),
-                getStructEncoder([
-                    ['field', getDataEnumCodec(getFieldCodec())],
-                    ['value', getStringEncoder()],
-                ])
-            ).encode({ field: getFieldConfig(field), value })
-        ),
-    });
-}
-
-export interface RemoveKeyInstructionArgs {
-    programId: PublicKey;
-    metadata: PublicKey;
-    updateAuthority: PublicKey;
-    key: string;
-    idempotent: boolean;
-}
-
-export function createRemoveKeyInstruction(args: RemoveKeyInstructionArgs) {
-    const { programId, metadata, updateAuthority, key, idempotent } = args;
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: metadata },
-            { isSigner: true, isWritable: false, pubkey: updateAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_metadata_interface:remove_key_ix'),
-                getStructEncoder([
-                    ['idempotent', getBooleanEncoder()],
-                    ['key', getStringEncoder()],
-                ])
-            ).encode({ idempotent, key })
-        ),
-    });
-}
-
-export interface UpdateAuthorityInstructionArgs {
-    programId: PublicKey;
-    metadata: PublicKey;
-    oldAuthority: PublicKey;
-    newAuthority: PublicKey | null;
-}
-
-export function createUpdateAuthorityInstruction(args: UpdateAuthorityInstructionArgs): TransactionInstruction {
-    const { programId, metadata, oldAuthority, newAuthority } = args;
-
-    return new TransactionInstruction({
-        programId,
-        keys: [
-            { isSigner: false, isWritable: true, pubkey: metadata },
-            { isSigner: true, isWritable: false, pubkey: oldAuthority },
-        ],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_metadata_interface:update_the_authority'),
-                getStructEncoder([['newAuthority', getPublicKeyEncoder()]])
-            ).encode({ newAuthority: newAuthority ?? SystemProgram.programId })
-        ),
-    });
-}
-
-export interface EmitInstructionArgs {
-    programId: PublicKey;
-    metadata: PublicKey;
-    start?: bigint;
-    end?: bigint;
-}
-
-export function createEmitInstruction(args: EmitInstructionArgs): TransactionInstruction {
-    const { programId, metadata, start, end } = args;
-    return new TransactionInstruction({
-        programId,
-        keys: [{ isSigner: false, isWritable: false, pubkey: metadata }],
-        data: Buffer.from(
-            getInstructionEncoder(
-                splDiscriminate('spl_token_metadata_interface:emitter'),
-                getStructEncoder([
-                    ['start', getOptionEncoder(getU64Encoder())],
-                    ['end', getOptionEncoder(getU64Encoder())],
-                ])
-            ).encode({ start: start ?? null, end: end ?? null })
-        ),
-    });
-}
diff --git a/token-metadata/js/src/state.ts b/token-metadata/js/src/state.ts
deleted file mode 100644
index 6f689ebd893..00000000000
--- a/token-metadata/js/src/state.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import {
-    addCodecSizePrefix,
-    fixCodecSize,
-    getArrayCodec,
-    getBytesCodec,
-    getUtf8Codec,
-    getU32Codec,
-    getStructCodec,
-    getTupleCodec,
-} from '@solana/codecs';
-import type { ReadonlyUint8Array, VariableSizeCodec } from '@solana/codecs';
-
-export const TOKEN_METADATA_DISCRIMINATOR = Buffer.from([112, 132, 90, 90, 11, 88, 157, 87]);
-
-function getStringCodec(): VariableSizeCodec<string> {
-    return addCodecSizePrefix(getUtf8Codec(), getU32Codec());
-}
-
-const tokenMetadataCodec = getStructCodec([
-    ['updateAuthority', fixCodecSize(getBytesCodec(), 32)],
-    ['mint', fixCodecSize(getBytesCodec(), 32)],
-    ['name', getStringCodec()],
-    ['symbol', getStringCodec()],
-    ['uri', getStringCodec()],
-    ['additionalMetadata', getArrayCodec(getTupleCodec([getStringCodec(), getStringCodec()]))],
-]);
-
-export interface TokenMetadata {
-    // The authority that can sign to update the metadata
-    updateAuthority?: PublicKey;
-    // The associated mint, used to counter spoofing to be sure that metadata belongs to a particular mint
-    mint: PublicKey;
-    // The longer name of the token
-    name: string;
-    // The shortened symbol for the token
-    symbol: string;
-    // The URI pointing to richer metadata
-    uri: string;
-    // Any additional metadata about the token as key-value pairs
-    additionalMetadata: (readonly [string, string])[];
-}
-
-// Checks if all elements in the array are 0
-function isNonePubkey(buffer: ReadonlyUint8Array): boolean {
-    for (let i = 0; i < buffer.length; i++) {
-        if (buffer[i] !== 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-// Pack TokenMetadata into byte slab
-export function pack(meta: TokenMetadata): ReadonlyUint8Array {
-    // If no updateAuthority given, set it to the None/Zero PublicKey for encoding
-    const updateAuthority = meta.updateAuthority ?? PublicKey.default;
-    return tokenMetadataCodec.encode({
-        ...meta,
-        updateAuthority: updateAuthority.toBuffer(),
-        mint: meta.mint.toBuffer(),
-    });
-}
-
-// unpack byte slab into TokenMetadata
-export function unpack(buffer: Buffer | Uint8Array | ReadonlyUint8Array): TokenMetadata {
-    const data = tokenMetadataCodec.decode(buffer);
-
-    return isNonePubkey(data.updateAuthority)
-        ? {
-              mint: new PublicKey(data.mint),
-              name: data.name,
-              symbol: data.symbol,
-              uri: data.uri,
-              additionalMetadata: data.additionalMetadata,
-          }
-        : {
-              updateAuthority: new PublicKey(data.updateAuthority),
-              mint: new PublicKey(data.mint),
-              name: data.name,
-              symbol: data.symbol,
-              uri: data.uri,
-              additionalMetadata: data.additionalMetadata,
-          };
-}
diff --git a/token-metadata/js/test/instruction.test.ts b/token-metadata/js/test/instruction.test.ts
deleted file mode 100644
index e206393c7e1..00000000000
--- a/token-metadata/js/test/instruction.test.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-import { expect } from 'chai';
-
-import {
-    createEmitInstruction,
-    createInitializeInstruction,
-    createRemoveKeyInstruction,
-    createUpdateAuthorityInstruction,
-    createUpdateFieldInstruction,
-    getFieldCodec,
-    getFieldConfig,
-} from '../src';
-import {
-    addDecoderSizePrefix,
-    fixDecoderSize,
-    getBooleanDecoder,
-    getBytesDecoder,
-    getDataEnumCodec,
-    getOptionDecoder,
-    getUtf8Decoder,
-    getU32Decoder,
-    getU64Decoder,
-    getStructDecoder,
-    some,
-} from '@solana/codecs';
-import { splDiscriminate } from '@solana/spl-type-length-value';
-import type { Decoder, Option, VariableSizeDecoder } from '@solana/codecs';
-import { PublicKey, type TransactionInstruction } from '@solana/web3.js';
-
-function checkPackUnpack<T extends object>(
-    instruction: TransactionInstruction,
-    discriminator: Uint8Array,
-    decoder: Decoder<T>,
-    values: T
-) {
-    expect(instruction.data.subarray(0, 8)).to.deep.equal(discriminator);
-    const unpacked = decoder.decode(instruction.data.subarray(8));
-    expect(unpacked).to.deep.equal(values);
-}
-
-function getStringDecoder(): VariableSizeDecoder<string> {
-    return addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder());
-}
-
-describe('Token Metadata Instructions', () => {
-    const programId = new PublicKey('22222222222222222222222222222222222222222222');
-    const metadata = new PublicKey('33333333333333333333333333333333333333333333');
-    const updateAuthority = new PublicKey('44444444444444444444444444444444444444444444');
-    const mint = new PublicKey('55555555555555555555555555555555555555555555');
-    const mintAuthority = new PublicKey('66666666666666666666666666666666666666666666');
-
-    it('Can create Initialize Instruction', () => {
-        const name = 'My test token';
-        const symbol = 'TEST';
-        const uri = 'http://test.test';
-        checkPackUnpack(
-            createInitializeInstruction({
-                programId,
-                metadata,
-                updateAuthority,
-                mint,
-                mintAuthority,
-                name,
-                symbol,
-                uri,
-            }),
-            splDiscriminate('spl_token_metadata_interface:initialize_account'),
-            getStructDecoder([
-                ['name', getStringDecoder()],
-                ['symbol', getStringDecoder()],
-                ['uri', getStringDecoder()],
-            ]),
-            { name, symbol, uri }
-        );
-    });
-
-    it('Can create Update Field Instruction', () => {
-        const field = 'MyTestField';
-        const value = 'http://test.uri';
-        checkPackUnpack(
-            createUpdateFieldInstruction({
-                programId,
-                metadata,
-                updateAuthority,
-                field,
-                value,
-            }),
-            splDiscriminate('spl_token_metadata_interface:updating_field'),
-            getStructDecoder([
-                ['key', getDataEnumCodec(getFieldCodec())],
-                ['value', getStringDecoder()],
-            ]),
-            { key: getFieldConfig(field), value }
-        );
-    });
-
-    it('Can create Update Field Instruction with Field Enum', () => {
-        const field = 'Name';
-        const value = 'http://test.uri';
-        checkPackUnpack(
-            createUpdateFieldInstruction({
-                programId,
-                metadata,
-                updateAuthority,
-                field,
-                value,
-            }),
-            splDiscriminate('spl_token_metadata_interface:updating_field'),
-            getStructDecoder([
-                ['key', getDataEnumCodec(getFieldCodec())],
-                ['value', getStringDecoder()],
-            ]),
-            { key: getFieldConfig(field), value }
-        );
-    });
-
-    it('Can create Remove Key Instruction', () => {
-        checkPackUnpack(
-            createRemoveKeyInstruction({
-                programId,
-                metadata,
-                updateAuthority: updateAuthority,
-                key: 'MyTestField',
-                idempotent: true,
-            }),
-            splDiscriminate('spl_token_metadata_interface:remove_key_ix'),
-            getStructDecoder([
-                ['idempotent', getBooleanDecoder()],
-                ['key', getStringDecoder()],
-            ]),
-            { idempotent: true, key: 'MyTestField' }
-        );
-    });
-
-    it('Can create Update Authority Instruction', () => {
-        const newAuthority = PublicKey.default;
-        checkPackUnpack(
-            createUpdateAuthorityInstruction({
-                programId,
-                metadata,
-                oldAuthority: updateAuthority,
-                newAuthority,
-            }),
-            splDiscriminate('spl_token_metadata_interface:update_the_authority'),
-            getStructDecoder([['newAuthority', fixDecoderSize(getBytesDecoder(), 32)]]),
-            { newAuthority: Uint8Array.from(newAuthority.toBuffer()) }
-        );
-    });
-
-    it('Can create Emit Instruction', () => {
-        const start: Option<bigint> = some(0n);
-        const end: Option<bigint> = some(10n);
-        checkPackUnpack(
-            createEmitInstruction({
-                programId,
-                metadata,
-                start: 0n,
-                end: 10n,
-            }),
-            splDiscriminate('spl_token_metadata_interface:emitter'),
-            getStructDecoder([
-                ['start', getOptionDecoder(getU64Decoder())],
-                ['end', getOptionDecoder(getU64Decoder())],
-            ]),
-            { start, end }
-        );
-    });
-});
diff --git a/token-metadata/js/test/state.test.ts b/token-metadata/js/test/state.test.ts
deleted file mode 100644
index f55dd04a175..00000000000
--- a/token-metadata/js/test/state.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { expect } from 'chai';
-
-import type { TokenMetadata } from '../src/state';
-import { unpack, pack } from '../src';
-
-function checkPackUnpack(tokenMetadata: TokenMetadata) {
-    const packed = pack(tokenMetadata);
-    const unpacked = unpack(packed);
-    expect(unpacked).to.deep.equal(tokenMetadata);
-}
-
-describe('Token Metadata State', () => {
-    it('Can pack and unpack base token metadata', () => {
-        checkPackUnpack({
-            mint: PublicKey.default,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('Can pack and unpack with updateAuthority', () => {
-        checkPackUnpack({
-            updateAuthority: new PublicKey('44444444444444444444444444444444444444444444'),
-            mint: new PublicKey('55555555555555555555555555555555555555555555'),
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('Can pack and unpack with additional metadata', () => {
-        checkPackUnpack({
-            mint: PublicKey.default,
-            name: 'new_name',
-            symbol: 'new_symbol',
-            uri: 'new_uri',
-            additionalMetadata: [
-                ['key1', 'value1'],
-                ['key2', 'value2'],
-            ],
-        });
-    });
-
-    it('Can pack and unpack with updateAuthority and additional metadata', () => {
-        checkPackUnpack({
-            updateAuthority: new PublicKey('44444444444444444444444444444444444444444444'),
-            mint: new PublicKey('55555555555555555555555555555555555555555555'),
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [
-                ['key1', 'value1'],
-                ['key2', 'value2'],
-            ],
-        });
-    });
-});
diff --git a/token-metadata/js/tsconfig.all.json b/token-metadata/js/tsconfig.all.json
deleted file mode 100644
index 985513259e2..00000000000
--- a/token-metadata/js/tsconfig.all.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.root.json",
-    "references": [
-        {
-            "path": "./tsconfig.cjs.json"
-        },
-        {
-            "path": "./tsconfig.esm.json"
-        }
-    ]
-}
diff --git a/token-metadata/js/tsconfig.base.json b/token-metadata/js/tsconfig.base.json
deleted file mode 100644
index 90620c4e485..00000000000
--- a/token-metadata/js/tsconfig.base.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "include": [],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "stripInternal": true
-    }
-}
diff --git a/token-metadata/js/tsconfig.cjs.json b/token-metadata/js/tsconfig.cjs.json
deleted file mode 100644
index 2db9b71569e..00000000000
--- a/token-metadata/js/tsconfig.cjs.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/cjs",
-        "target": "ES2016",
-        "module": "CommonJS",
-        "sourceMap": true
-    }
-}
diff --git a/token-metadata/js/tsconfig.esm.json b/token-metadata/js/tsconfig.esm.json
deleted file mode 100644
index 25e7e25e751..00000000000
--- a/token-metadata/js/tsconfig.esm.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/esm",
-        "declarationDir": "lib/types",
-        "target": "ES2020",
-        "module": "ES2020",
-        "sourceMap": true,
-        "declaration": true,
-        "declarationMap": true
-    }
-}
diff --git a/token-metadata/js/tsconfig.json b/token-metadata/js/tsconfig.json
deleted file mode 100644
index 2f9b239bfca..00000000000
--- a/token-metadata/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig.all.json",
-    "include": ["src", "test"],
-    "compilerOptions": {
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
diff --git a/token-metadata/js/tsconfig.root.json b/token-metadata/js/tsconfig.root.json
deleted file mode 100644
index fadf294ab43..00000000000
--- a/token-metadata/js/tsconfig.root.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "compilerOptions": {
-        "composite": true
-    }
-}
diff --git a/token-metadata/js/typedoc.json b/token-metadata/js/typedoc.json
deleted file mode 100644
index c39fc53aee1..00000000000
--- a/token-metadata/js/typedoc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md"
-}
diff --git a/token-swap/js/package.json b/token-swap/js/package.json
index e814fbf1ee9..9c80d5dfc68 100644
--- a/token-swap/js/package.json
+++ b/token-swap/js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@solana/spl-token-swap",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "SPL Token Swap JavaScript API",
   "license": "MIT",
   "type": "module",
@@ -37,10 +37,8 @@
     "build:program": "cargo build-sbf --manifest-path=../program/Cargo.toml",
     "test:js": "mocha test",
     "test": "start-server-and-test 'solana-test-validator --bpf-program SwapsVeCiPHMUAtzQWZw7RjsKjgCjhwU55QGu4U1Szw ../../target/deploy/spl_token_swap.so --reset --quiet' http://127.0.0.1:8899/health test:js",
-    "lint": "npm run pretty && eslint --max-warnings 0 .",
-    "lint:fix": "npm run pretty:fix && eslint . --fix",
-    "pretty": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}'",
-    "pretty:fix": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'"
+    "lint": "eslint --max-warnings 0 .",
+    "lint:fix": "eslint . --fix"
   },
   "keywords": [],
   "dependencies": {
@@ -48,26 +46,23 @@
     "@solana/buffer-layout-utils": "^0.2.0"
   },
   "peerDependencies": {
-    "@solana/web3.js": "^1.93.0"
+    "@solana/web3.js": "^1.95.5"
   },
   "devDependencies": {
-    "@solana/spl-token": "0.4.6",
-    "@solana/web3.js": "^1.93.0",
-    "@types/bn.js": "^5.1.0",
-    "@types/chai-as-promised": "^7.1.4",
-    "@types/chai": "^4.3.16",
-    "@types/mocha": "^10.0.6",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
+    "@solana/spl-token": "0.4.9",
+    "@solana/web3.js": "^1.95.5",
+    "@types/bn.js": "^5.1.6",
+    "@types/chai-as-promised": "^8.0.1",
+    "@types/chai": "^5.0.1",
+    "@types/mocha": "^10.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.4.0",
+    "@typescript-eslint/parser": "^8.4.0",
     "eslint": "^8.57.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-require-extensions": "^0.1.1",
-    "mocha": "^10.4.0",
-    "prettier": "^3.3.2",
-    "start-server-and-test": "^2.0.4",
+    "mocha": "^11.0.1",
+    "start-server-and-test": "^2.0.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
+    "typescript": "^5.7.2"
   }
 }
diff --git a/token-swap/js/test/main.test.ts b/token-swap/js/test/main.test.ts
index 3f6aac99cdb..e0967a1bb40 100644
--- a/token-swap/js/test/main.test.ts
+++ b/token-swap/js/test/main.test.ts
@@ -121,7 +121,7 @@ async function getConnection(): Promise<Connection> {
   if (connection) return connection;
 
   const url = 'http://127.0.0.1:8899';
-  connection = new Connection(url, 'recent');
+  connection = new Connection(url, 'processed');
   const version = await connection.getVersion();
 
   console.log('Connection to cluster established:', url, version);
diff --git a/token-swap/program/Cargo.toml b/token-swap/program/Cargo.toml
index 379517556b8..022e9390403 100644
--- a/token-swap/program/Cargo.toml
+++ b/token-swap/program/Cargo.toml
@@ -13,22 +13,22 @@ production = []
 fuzz = ["arbitrary", "roots"]
 
 [dependencies]
-arrayref = "0.3.7"
+arrayref = "0.3.9"
 enum_dispatch = "0.3.13"
 num-derive = "0.4"
 num-traits = "0.2"
-solana-program = ">=1.18.11,<=2"
-spl-math = { version = "0.2", path = "../../libraries/math", features = [ "no-entrypoint" ] }
-spl-token = { version = "4.0", path = "../../token/program", features = [ "no-entrypoint" ] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = [ "no-entrypoint" ] }
-thiserror = "1.0"
-arbitrary = { version = "1.3", features = ["derive"], optional = true }
+solana-program = "2.1.0"
+spl-math = { version = "0.3", path = "../../libraries/math" }
+spl-token = { version = "7.0", features = [ "no-entrypoint" ] }
+spl-token-2022 = { version = "6.0.0", features = [ "no-entrypoint" ] }
+thiserror = "2.0"
+arbitrary = { version = "1.4", features = ["derive"], optional = true }
 roots = { version = "0.0.8", optional = true }
 
 [dev-dependencies]
-proptest = "1.4"
+proptest = "1.6"
 roots = "0.0.8"
-solana-sdk = ">=1.18.11,<=2"
+solana-sdk = "2.1.0"
 test-case = "3.3"
 
 [lib]
diff --git a/token-swap/program/fuzz/Cargo.toml b/token-swap/program/fuzz/Cargo.toml
index 71f2c53b710..77d85c045b5 100644
--- a/token-swap/program/fuzz/Cargo.toml
+++ b/token-swap/program/fuzz/Cargo.toml
@@ -10,10 +10,10 @@ publish = false
 
 [dependencies]
 honggfuzz = { version = "0.5.56" }
-arbitrary = { version = "1.3", features = ["derive"] }
-solana-program = ">=1.18.11,<=2"
-spl-math = { version = "0.2", path = "../../../libraries/math", features = [ "no-entrypoint" ] }
-spl-token = { version = "4.0", path = "../../../token/program", features = [ "no-entrypoint" ] }
+arbitrary = { version = "1.4", features = ["derive"] }
+solana-program = "2.1.0"
+spl-math = { version = "0.3", path = "../../../libraries/math" }
+spl-token = { version = "7.0", features = [ "no-entrypoint" ] }
 spl-token-swap = { path = "..", features = ["fuzz", "no-entrypoint"] }
 
 [[bin]]
diff --git a/token-swap/program/proptest-regressions/curve/constant_price.txt b/token-swap/program/proptest-regressions/curve/constant_price.txt
new file mode 100644
index 00000000000..a146ac8a4e5
--- /dev/null
+++ b/token-swap/program/proptest-regressions/curve/constant_price.txt
@@ -0,0 +1 @@
+cc 2594e0e0a7f4471f4929439462cb19c5b187294cc0ede01a155051179eb99bdd
diff --git a/token-swap/program/src/constraints.rs b/token-swap/program/src/constraints.rs
index 99e3d1b4564..66e9c3ec9b1 100644
--- a/token-swap/program/src/constraints.rs
+++ b/token-swap/program/src/constraints.rs
@@ -1,7 +1,7 @@
 //! Various constraints as required for production environments
 
 #[cfg(feature = "production")]
-use std::env;
+use std::option_env;
 use {
     crate::{
         curve::{
@@ -21,7 +21,7 @@ use {
 /// cannot be used, so we have to split the curves based on their types.
 pub struct SwapConstraints<'a> {
     /// Owner of the program
-    pub owner_key: &'a str,
+    pub owner_key: Option<&'a str>,
     /// Valid curve types
     pub valid_curve_types: &'a [CurveType],
     /// Valid fees
@@ -61,7 +61,7 @@ impl<'a> SwapConstraints<'a> {
 }
 
 #[cfg(feature = "production")]
-const OWNER_KEY: &str = env!("SWAP_PROGRAM_OWNER_FEE_ADDRESS");
+const OWNER_KEY: Option<&str> = option_env!("SWAP_PROGRAM_OWNER_FEE_ADDRESS");
 #[cfg(feature = "production")]
 const FEES: &Fees = &Fees {
     trade_fee_numerator: 0,
@@ -115,7 +115,7 @@ mod tests {
         let owner_withdraw_fee_denominator = 10;
         let host_fee_numerator = 10;
         let host_fee_denominator = 100;
-        let owner_key = "";
+        let owner_key = Some("");
         let curve_type = CurveType::ConstantProduct;
         let valid_fees = Fees {
             trade_fee_numerator,
diff --git a/token-swap/program/src/curve/constant_price.rs b/token-swap/program/src/curve/constant_price.rs
index 4f3f026320d..b9e5272b50a 100644
--- a/token-swap/program/src/curve/constant_price.rs
+++ b/token-swap/program/src/curve/constant_price.rs
@@ -217,8 +217,8 @@ impl CurveCalculator for ConstantPriceCurve {
     ) -> Option<PreciseNumber> {
         let swap_token_b_value = swap_token_b_amount.checked_mul(self.token_b_price as u128)?;
         // special logic in case we're close to the limits, avoid overflowing u128
-        let value = if swap_token_b_value.saturating_sub(std::u64::MAX.into())
-            > (std::u128::MAX.saturating_sub(std::u64::MAX.into()))
+        let value = if swap_token_b_value.saturating_sub(u64::MAX.into())
+            > (u128::MAX.saturating_sub(u64::MAX.into()))
         {
             swap_token_b_value
                 .checked_div(2)?
@@ -495,7 +495,8 @@ mod tests {
                 swap_token_a_amount,
                 swap_token_b_amount,
                 TradeDirection::AtoB,
-                CONVERSION_BASIS_POINTS_GUARANTEE
+                // TODO see why this needs to be so high
+                CONVERSION_BASIS_POINTS_GUARANTEE * 20
             );
             check_withdraw_token_conversion(
                 &curve,
@@ -504,7 +505,8 @@ mod tests {
                 swap_token_a_amount,
                 swap_token_b_amount,
                 TradeDirection::BtoA,
-                CONVERSION_BASIS_POINTS_GUARANTEE
+                // TODO see why this needs to be so high
+                CONVERSION_BASIS_POINTS_GUARANTEE * 20
             );
         }
     }
diff --git a/token-swap/program/src/curve/fees.rs b/token-swap/program/src/curve/fees.rs
index b62cecf5cde..844a6342315 100644
--- a/token-swap/program/src/curve/fees.rs
+++ b/token-swap/program/src/curve/fees.rs
@@ -7,7 +7,6 @@ use {
         program_error::ProgramError,
         program_pack::{IsInitialized, Pack, Sealed},
     },
-    std::convert::TryFrom,
 };
 
 /// Encapsulates all fee information and calculations for swap operations
@@ -101,8 +100,8 @@ impl Fees {
     pub fn owner_withdraw_fee(&self, pool_tokens: u128) -> Option<u128> {
         calculate_fee(
             pool_tokens,
-            u128::try_from(self.owner_withdraw_fee_numerator).ok()?,
-            u128::try_from(self.owner_withdraw_fee_denominator).ok()?,
+            u128::from(self.owner_withdraw_fee_numerator),
+            u128::from(self.owner_withdraw_fee_denominator),
         )
     }
 
@@ -110,8 +109,8 @@ impl Fees {
     pub fn trading_fee(&self, trading_tokens: u128) -> Option<u128> {
         calculate_fee(
             trading_tokens,
-            u128::try_from(self.trade_fee_numerator).ok()?,
-            u128::try_from(self.trade_fee_denominator).ok()?,
+            u128::from(self.trade_fee_numerator),
+            u128::from(self.trade_fee_denominator),
         )
     }
 
@@ -119,8 +118,8 @@ impl Fees {
     pub fn owner_trading_fee(&self, trading_tokens: u128) -> Option<u128> {
         calculate_fee(
             trading_tokens,
-            u128::try_from(self.owner_trade_fee_numerator).ok()?,
-            u128::try_from(self.owner_trade_fee_denominator).ok()?,
+            u128::from(self.owner_trade_fee_numerator),
+            u128::from(self.owner_trade_fee_denominator),
         )
     }
 
@@ -159,8 +158,8 @@ impl Fees {
     pub fn host_fee(&self, owner_fee: u128) -> Option<u128> {
         calculate_fee(
             owner_fee,
-            u128::try_from(self.host_fee_numerator).ok()?,
-            u128::try_from(self.host_fee_denominator).ok()?,
+            u128::from(self.host_fee_numerator),
+            u128::from(self.host_fee_denominator),
         )
     }
 
diff --git a/token-swap/program/src/curve/offset.rs b/token-swap/program/src/curve/offset.rs
index c1d3f499877..8d5937536d0 100644
--- a/token-swap/program/src/curve/offset.rs
+++ b/token-swap/program/src/curve/offset.rs
@@ -33,9 +33,11 @@ pub struct OffsetCurve {
 impl CurveCalculator for OffsetCurve {
     /// Constant product swap ensures token a * (token b + offset) = constant
     /// This is guaranteed to work for all values such that:
+    ///
     ///  - 1 <= source_amount <= u64::MAX
     ///  - 1 <= (swap_source_amount * (swap_destination_amount +
     ///    token_b_offset)) <= u128::MAX
+    ///
     /// If the offset and token B are both close to u64::MAX, there can be
     /// overflow errors with the invariant.
     fn swap_without_fees(
diff --git a/token-swap/program/src/instruction.rs b/token-swap/program/src/instruction.rs
index b81b57ec8be..874727d3d35 100644
--- a/token-swap/program/src/instruction.rs
+++ b/token-swap/program/src/instruction.rs
@@ -107,10 +107,10 @@ pub enum SwapInstruction {
     ///   3. `[]` token_b Account. Must be non zero, owned by swap authority.
     ///   4. `[writable]` Pool Token Mint. Must be empty, owned by swap
     ///      authority.
-    ///   5. `[]` Pool Token Account to deposit trading and withdraw fees.
-    ///   Must be empty, not owned by swap authority
+    ///   5. `[]` Pool Token Account to deposit trading and withdraw fees. Must
+    ///      be empty, not owned by swap authority
     ///   6. `[writable]` Pool Token Account to deposit the initial pool token
-    ///   supply.  Must be empty, not owned by swap authority.
+    ///      supply. Must be empty, not owned by swap authority.
     ///   7. `[]` Pool Token program id
     Initialize(Initialize),
 
diff --git a/token-swap/program/src/processor.rs b/token-swap/program/src/processor.rs
index b46462ebf86..09b22b25964 100644
--- a/token-swap/program/src/processor.rs
+++ b/token-swap/program/src/processor.rs
@@ -338,6 +338,7 @@ impl Processor {
         if let Some(swap_constraints) = swap_constraints {
             let owner_key = swap_constraints
                 .owner_key
+                .unwrap()
                 .parse::<Pubkey>()
                 .map_err(|_| SwapError::InvalidOwner)?;
             if fee_account.owner != owner_key {
@@ -475,9 +476,9 @@ impl Processor {
         let result = token_swap
             .swap_curve()
             .swap(
-                to_u128(actual_amount_in)?,
-                to_u128(source_account.amount)?,
-                to_u128(dest_account.amount)?,
+                u128::from(actual_amount_in),
+                u128::from(source_account.amount),
+                u128::from(dest_account.amount),
                 trade_direction,
                 token_swap.fees(),
             )
@@ -562,7 +563,7 @@ impl Processor {
                     result.owner_fee,
                     swap_token_a_amount,
                     swap_token_b_amount,
-                    to_u128(pool_mint.supply)?,
+                    u128::from(pool_mint.supply),
                     trade_direction,
                     RoundDirection::Floor,
                 )
@@ -672,9 +673,9 @@ impl Processor {
         let token_a = Self::unpack_token_account(token_a_info, token_swap.token_program_id())?;
         let token_b = Self::unpack_token_account(token_b_info, token_swap.token_program_id())?;
         let pool_mint = Self::unpack_mint(pool_mint_info, token_swap.token_program_id())?;
-        let current_pool_mint_supply = to_u128(pool_mint.supply)?;
+        let current_pool_mint_supply = u128::from(pool_mint.supply);
         let (pool_token_amount, pool_mint_supply) = if current_pool_mint_supply > 0 {
-            (to_u128(pool_token_amount)?, current_pool_mint_supply)
+            (u128::from(pool_token_amount), current_pool_mint_supply)
         } else {
             (calculator.new_pool_supply(), calculator.new_pool_supply())
         };
@@ -683,8 +684,8 @@ impl Processor {
             .pool_tokens_to_trading_tokens(
                 pool_token_amount,
                 pool_mint_supply,
-                to_u128(token_a.amount)?,
-                to_u128(token_b.amount)?,
+                u128::from(token_a.amount),
+                u128::from(token_b.amount),
                 RoundDirection::Ceiling,
             )
             .ok_or(SwapError::ZeroTradingTokens)?;
@@ -794,22 +795,22 @@ impl Processor {
                 } else {
                     token_swap
                         .fees()
-                        .owner_withdraw_fee(to_u128(pool_token_amount)?)
+                        .owner_withdraw_fee(u128::from(pool_token_amount))
                         .ok_or(SwapError::FeeCalculationFailure)?
                 }
             }
             Err(_) => 0,
         };
-        let pool_token_amount = to_u128(pool_token_amount)?
+        let pool_token_amount = u128::from(pool_token_amount)
             .checked_sub(withdraw_fee)
             .ok_or(SwapError::CalculationFailure)?;
 
         let results = calculator
             .pool_tokens_to_trading_tokens(
                 pool_token_amount,
-                to_u128(pool_mint.supply)?,
-                to_u128(token_a.amount)?,
-                to_u128(token_b.amount)?,
+                u128::from(pool_mint.supply),
+                u128::from(token_a.amount),
+                u128::from(token_b.amount),
                 RoundDirection::Floor,
             )
             .ok_or(SwapError::ZeroTradingTokens)?;
@@ -942,14 +943,14 @@ impl Processor {
         )?;
 
         let pool_mint = Self::unpack_mint(pool_mint_info, token_swap.token_program_id())?;
-        let pool_mint_supply = to_u128(pool_mint.supply)?;
+        let pool_mint_supply = u128::from(pool_mint.supply);
         let pool_token_amount = if pool_mint_supply > 0 {
             token_swap
                 .swap_curve()
                 .deposit_single_token_type(
-                    to_u128(source_token_amount)?,
-                    to_u128(swap_token_a.amount)?,
-                    to_u128(swap_token_b.amount)?,
+                    u128::from(source_token_amount),
+                    u128::from(swap_token_a.amount),
+                    u128::from(swap_token_b.amount),
                     pool_mint_supply,
                     trade_direction,
                     token_swap.fees(),
@@ -1067,14 +1068,14 @@ impl Processor {
         )?;
 
         let pool_mint = Self::unpack_mint(pool_mint_info, token_swap.token_program_id())?;
-        let pool_mint_supply = to_u128(pool_mint.supply)?;
-        let swap_token_a_amount = to_u128(swap_token_a.amount)?;
-        let swap_token_b_amount = to_u128(swap_token_b.amount)?;
+        let pool_mint_supply = u128::from(pool_mint.supply);
+        let swap_token_a_amount = u128::from(swap_token_a.amount);
+        let swap_token_b_amount = u128::from(swap_token_b.amount);
 
         let burn_pool_token_amount = token_swap
             .swap_curve()
             .withdraw_single_token_type_exact_out(
-                to_u128(destination_token_amount)?,
+                u128::from(destination_token_amount),
                 swap_token_a_amount,
                 swap_token_b_amount,
                 pool_mint_supply,
@@ -1250,10 +1251,6 @@ impl Processor {
     }
 }
 
-fn to_u128(val: u64) -> Result<u128, SwapError> {
-    val.try_into().map_err(|_| SwapError::ConversionFailure)
-}
-
 fn to_u64(val: u128) -> Result<u64, SwapError> {
     val.try_into().map_err(|_| SwapError::ConversionFailure)
 }
@@ -1266,9 +1263,8 @@ fn invoke_signed_wrapper<T>(
 where
     T: 'static + PrintProgramError + DecodeError<T> + FromPrimitive + Error,
 {
-    invoke_signed(instruction, account_infos, signers_seeds).map_err(|err| {
+    invoke_signed(instruction, account_infos, signers_seeds).inspect_err(|err| {
         err.print::<T>();
-        err
     })
 }
 
@@ -3113,10 +3109,10 @@ mod tests {
                 curve_type: CurveType::ConstantProduct,
                 calculator: Arc::new(curve),
             };
-            let owner_key = &new_key.to_string();
+            let owner_key = new_key.to_string();
             let valid_curve_types = &[CurveType::ConstantProduct];
             let constraints = Some(SwapConstraints {
-                owner_key,
+                owner_key: Some(owner_key.as_ref()),
                 valid_curve_types,
                 fees: &fees,
             });
@@ -3186,10 +3182,10 @@ mod tests {
                 curve_type: CurveType::ConstantProduct,
                 calculator: Arc::new(curve),
             };
-            let owner_key = &user_key.to_string();
+            let owner_key = user_key.to_string();
             let valid_curve_types = &[CurveType::ConstantProduct];
             let constraints = Some(SwapConstraints {
-                owner_key,
+                owner_key: Some(owner_key.as_ref()),
                 valid_curve_types,
                 fees: &fees,
             });
@@ -3261,10 +3257,10 @@ mod tests {
                 curve_type: CurveType::ConstantProduct,
                 calculator: Arc::new(curve),
             };
-            let owner_key = &user_key.to_string();
+            let owner_key = user_key.to_string();
             let valid_curve_types = &[CurveType::ConstantProduct];
             let constraints = Some(SwapConstraints {
-                owner_key,
+                owner_key: Some(owner_key.as_ref()),
                 valid_curve_types,
                 fees: &fees,
             });
@@ -4758,9 +4754,9 @@ mod tests {
                 .calculator
                 .pool_tokens_to_trading_tokens(
                     withdraw_amount - withdraw_fee,
-                    pool_mint.base.supply.try_into().unwrap(),
-                    swap_token_a.base.amount.try_into().unwrap(),
-                    swap_token_b.base.amount.try_into().unwrap(),
+                    pool_mint.base.supply.into(),
+                    swap_token_a.base.amount.into(),
+                    swap_token_b.base.amount.into(),
                     RoundDirection::Floor,
                 )
                 .unwrap();
@@ -4837,10 +4833,10 @@ mod tests {
                 .swap_curve
                 .calculator
                 .pool_tokens_to_trading_tokens(
-                    pool_fee_amount.try_into().unwrap(),
-                    pool_mint.base.supply.try_into().unwrap(),
-                    swap_token_a.base.amount.try_into().unwrap(),
-                    swap_token_b.base.amount.try_into().unwrap(),
+                    pool_fee_amount.into(),
+                    pool_mint.base.supply.into(),
+                    swap_token_a.base.amount.into(),
+                    swap_token_b.base.amount.into(),
                     RoundDirection::Floor,
                 )
                 .unwrap();
@@ -6005,10 +6001,10 @@ mod tests {
             let pool_token_amount = accounts
                 .swap_curve
                 .withdraw_single_token_type_exact_out(
-                    destination_a_amount.try_into().unwrap(),
-                    swap_token_a.base.amount.try_into().unwrap(),
-                    swap_token_b.base.amount.try_into().unwrap(),
-                    pool_mint.base.supply.try_into().unwrap(),
+                    destination_a_amount.into(),
+                    swap_token_a.base.amount.into(),
+                    swap_token_b.base.amount.into(),
+                    pool_mint.base.supply.into(),
                     TradeDirection::AtoB,
                     &accounts.fees,
                 )
@@ -6165,9 +6161,9 @@ mod tests {
         let actual_a_to_b_amount = a_to_b_amount - token_a_fee;
         let results = swap_curve
             .swap(
-                actual_a_to_b_amount.try_into().unwrap(),
-                token_a_amount.try_into().unwrap(),
-                token_b_amount.try_into().unwrap(),
+                actual_a_to_b_amount.into(),
+                token_a_amount.into(),
+                token_b_amount.into(),
                 TradeDirection::AtoB,
                 &fees,
             )
@@ -6201,9 +6197,9 @@ mod tests {
                 .calculator
                 .withdraw_single_token_type_exact_out(
                     results.owner_fee,
-                    token_a_amount.try_into().unwrap(),
-                    token_b_amount.try_into().unwrap(),
-                    initial_supply.try_into().unwrap(),
+                    token_a_amount.into(),
+                    token_b_amount.into(),
+                    initial_supply.into(),
                     TradeDirection::AtoB,
                     RoundDirection::Floor,
                 )
@@ -6243,9 +6239,9 @@ mod tests {
 
         let mut results = swap_curve
             .swap(
-                b_to_a_amount.try_into().unwrap(),
-                token_b_amount.try_into().unwrap(),
-                token_a_amount.try_into().unwrap(),
+                b_to_a_amount.into(),
+                token_b_amount.into(),
+                token_a_amount.into(),
                 TradeDirection::BtoA,
                 &fees,
             )
@@ -6290,9 +6286,9 @@ mod tests {
                 .calculator
                 .withdraw_single_token_type_exact_out(
                     results.owner_fee,
-                    token_a_amount.try_into().unwrap(),
-                    token_b_amount.try_into().unwrap(),
-                    initial_supply.try_into().unwrap(),
+                    token_a_amount.into(),
+                    token_b_amount.into(),
+                    initial_supply.into(),
                     TradeDirection::BtoA,
                     RoundDirection::Floor,
                 )
@@ -6485,10 +6481,10 @@ mod tests {
             calculator: Arc::new(curve),
         };
 
-        let owner_key_str = &owner_key.to_string();
+        let owner_key_str = owner_key.to_string();
         let valid_curve_types = &[CurveType::ConstantProduct];
         let constraints = Some(SwapConstraints {
-            owner_key: owner_key_str,
+            owner_key: Some(owner_key_str.as_ref()),
             valid_curve_types,
             fees: &fees,
         });
@@ -7188,7 +7184,7 @@ mod tests {
                 _pool_key,
                 _pool_account,
             ) = accounts.setup_token_accounts(&user_key, &authority_key, initial_a, initial_b, 0);
-            let owner_key = &swapper_key.to_string();
+            let owner_key = swapper_key.to_string();
             let fees = Fees {
                 trade_fee_numerator,
                 trade_fee_denominator,
@@ -7200,7 +7196,7 @@ mod tests {
                 host_fee_denominator,
             };
             let constraints = Some(SwapConstraints {
-                owner_key,
+                owner_key: Some(owner_key.as_ref()),
                 valid_curve_types: &[],
                 fees: &fees,
             });
@@ -7268,7 +7264,7 @@ mod tests {
                 _pool_key,
                 _pool_account,
             ) = accounts.setup_token_accounts(&user_key, &authority_key, initial_a, initial_b, 0);
-            let owner_key = &swapper_key.to_string();
+            let owner_key = swapper_key.to_string();
             let fees = Fees {
                 trade_fee_numerator,
                 trade_fee_denominator,
@@ -7280,7 +7276,7 @@ mod tests {
                 host_fee_denominator,
             };
             let constraints = Some(SwapConstraints {
-                owner_key,
+                owner_key: Some(owner_key.as_ref()),
                 valid_curve_types: &[],
                 fees: &fees,
             });
@@ -8192,9 +8188,9 @@ mod tests {
             calculator: Arc::new(ConstantProductCurve {}),
         };
 
-        let owner_key_str = &owner_key.to_string();
+        let owner_key_str = owner_key.to_string();
         let constraints = Some(SwapConstraints {
-            owner_key: owner_key_str,
+            owner_key: Some(owner_key_str.as_ref()),
             valid_curve_types: &[CurveType::ConstantProduct],
             fees: &fees,
         });
diff --git a/token-upgrade/cli/Cargo.toml b/token-upgrade/cli/Cargo.toml
index 5887dceb950..f542f67007b 100644
--- a/token-upgrade/cli/Cargo.toml
+++ b/token-upgrade/cli/Cargo.toml
@@ -12,22 +12,22 @@ walkdir = "2"
 
 [dependencies]
 clap = { version = "3", features = ["cargo"] }
-futures-util = "0.3.30"
-solana-clap-v3-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-remote-wallet = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = ["no-entrypoint"] }
-spl-token = { version = "4.0", path = "../../token/program", features = ["no-entrypoint"] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
+futures-util = "0.3.31"
+solana-clap-v3-utils = "2.1.0"
+solana-cli-config = "2.1.0"
+solana-client = "2.1.0"
+solana-logger = "2.1.0"
+solana-remote-wallet = "2.1.0"
+solana-sdk = "2.1.0"
+spl-associated-token-account-client = { version = "2.0.0" }
+spl-token = { version = "7.0", features = ["no-entrypoint"] }
+spl-token-2022 = { version = "6.0.0", features = ["no-entrypoint"] }
+spl-token-client = { version = "0.13.0" }
 spl-token-upgrade = { version = "0.1", path = "../program", features = ["no-entrypoint"] }
 tokio = { version = "1", features = ["full"] }
 
 [dev-dependencies]
-solana-test-validator = ">=1.18.11,<=2"
+solana-test-validator = "2.1.0"
 
 [[bin]]
 name = "spl-token-upgrade"
diff --git a/token-upgrade/cli/src/main.rs b/token-upgrade/cli/src/main.rs
index 5565effa52a..852418d7d4c 100644
--- a/token-upgrade/cli/src/main.rs
+++ b/token-upgrade/cli/src/main.rs
@@ -1,11 +1,12 @@
 use {
-    clap::{crate_description, crate_name, crate_version, Arg, Command},
+    clap::{crate_description, crate_name, crate_version, Arg, ArgAction, Command},
     solana_clap_v3_utils::{
-        input_parsers::{parse_url_or_moniker, pubkey_of, signer::SignerSourceParserBuilder},
-        input_validators::normalize_to_url_if_moniker,
-        keypair::{
-            signer_from_path, signer_from_path_with_config, DefaultSigner, SignerFromPathConfig,
+        input_parsers::{
+            parse_url_or_moniker,
+            signer::{SignerSource, SignerSourceParserBuilder},
         },
+        input_validators::normalize_to_url_if_moniker,
+        keypair::{signer_from_path, signer_from_source, SignerFromPathConfig},
     },
     solana_client::nonblocking::rpc_client::RpcClient,
     solana_remote_wallet::remote_wallet::RemoteWalletManager,
@@ -17,7 +18,7 @@ use {
         signature::{Signature, Signer},
         transaction::Transaction,
     },
-    spl_associated_token_account::get_associated_token_address_with_program_id,
+    spl_associated_token_account_client::address::get_associated_token_address_with_program_id,
     spl_token_2022::{
         extension::StateWithExtensions,
         state::{Account, Mint},
@@ -333,7 +334,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                     .value_parser(SignerSourceParserBuilder::default().allow_all().build())
                     .value_name("MULTISIG_SIGNER")
                     .takes_value(true)
-                    .multiple(true)
+                    .action(ArgAction::Append)
                     .min_values(0)
                     .max_values(spl_token_2022::instruction::MAX_SIGNERS)
                     .help("Member signer of a multisig account")
@@ -345,19 +346,24 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let mut wallet_manager: Option<Rc<RemoteWalletManager>> = None;
 
     let config = {
-        let cli_config = if let Some(config_file) = matches.value_of("config_file") {
+        let cli_config = if let Some(config_file) = matches.try_get_one::<String>("config_file")? {
             solana_cli_config::Config::load(config_file).unwrap_or_default()
         } else {
             solana_cli_config::Config::default()
         };
 
-        let payer = DefaultSigner::new(
-            "payer",
-            matches
-                .value_of("payer")
-                .map(|s| s.to_string())
-                .unwrap_or_else(|| cli_config.keypair_path.clone()),
-        );
+        let payer = if let Ok(Some((signer, _))) =
+            SignerSource::try_get_signer(matches, "payer", &mut wallet_manager)
+        {
+            Box::new(signer)
+        } else {
+            signer_from_path(
+                matches,
+                &cli_config.keypair_path,
+                "payer",
+                &mut wallet_manager,
+            )?
+        };
 
         let json_rpc_url = normalize_to_url_if_moniker(
             matches
@@ -367,16 +373,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
         Config {
             commitment_config: CommitmentConfig::confirmed(),
-            payer: Arc::from(
-                payer
-                    .signer_from_path(matches, &mut wallet_manager)
-                    .unwrap_or_else(|err| {
-                        eprintln!("error: {}", err);
-                        exit(1);
-                    }),
-            ),
+            payer: Arc::from(payer),
             json_rpc_url,
-            verbose: matches.is_present("verbose"),
+            verbose: matches.try_contains_id("verbose")?,
         }
     };
     solana_logger::setup_with_default("solana=info");
@@ -391,15 +390,17 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     match (command, matches) {
         ("create-escrow", arg_matches) => {
-            let original_mint = pubkey_of(arg_matches, "original_mint").unwrap();
-            let new_mint = pubkey_of(arg_matches, "new_mint").unwrap();
-            let account_keypair = matches.value_of("account_keypair").map(|path| {
-                signer_from_path(arg_matches, path, "account_keypair", &mut wallet_manager)
-                    .unwrap_or_else(|err| {
-                        eprintln!("error: account keypair: {}", err);
-                        exit(1);
-                    })
-            });
+            let original_mint =
+                SignerSource::try_get_pubkey(arg_matches, "original_mint", &mut wallet_manager)
+                    .unwrap()
+                    .unwrap();
+            let new_mint =
+                SignerSource::try_get_pubkey(arg_matches, "new_mint", &mut wallet_manager)
+                    .unwrap()
+                    .unwrap();
+            let account_keypair =
+                SignerSource::try_get_signer(matches, "account_keypair", &mut wallet_manager)?
+                    .map(|(signer, _)| signer);
             let response = process_create_escrow_account(
                 &rpc_client,
                 &config.payer,
@@ -417,14 +418,16 @@ async fn main() -> Result<(), Box<dyn Error>> {
         ("exchange", arg_matches) => {
             let mut bulk_signers = vec![config.payer.clone()];
             let mut multisig_pubkeys = vec![];
-            if let Some(values) = arg_matches.values_of("multisig_signer") {
-                for (i, value) in values.enumerate() {
+
+            if let Some(sources) = arg_matches.try_get_many::<SignerSource>("multisig_signer")? {
+                for (i, source) in sources.enumerate() {
                     let name = format!("{}-{}", "multisig_signer", i.saturating_add(1));
-                    let signer = signer_from_path(arg_matches, value, &name, &mut wallet_manager)
-                        .unwrap_or_else(|e| {
-                            eprintln!("error parsing multisig signer: {}", e);
-                            exit(1);
-                        });
+                    let signer =
+                        signer_from_source(arg_matches, source, &name, &mut wallet_manager)
+                            .unwrap_or_else(|e| {
+                                eprint!("error parsing multisig signer: {}", e);
+                                exit(1);
+                            });
                     let signer_pubkey = signer.pubkey();
                     let signer = Arc::from(signer);
                     if !bulk_signers.contains(&signer) {
@@ -436,33 +439,35 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 }
             }
 
-            let original_mint = pubkey_of(arg_matches, "original_mint").unwrap();
-            let new_mint = pubkey_of(arg_matches, "new_mint").unwrap();
+            let original_mint =
+                SignerSource::try_get_pubkey(arg_matches, "original_mint", &mut wallet_manager)
+                    .unwrap()
+                    .unwrap();
+            let new_mint =
+                SignerSource::try_get_pubkey(arg_matches, "new_mint", &mut wallet_manager)
+                    .unwrap()
+                    .unwrap();
             let signer_config = SignerFromPathConfig {
                 allow_null_signer: !multisig_pubkeys.is_empty(),
             };
-            let owner = matches
-                .value_of("owner")
-                .map_or(Ok(config.payer.clone()), |path| {
-                    signer_from_path_with_config(
-                        arg_matches,
-                        path,
-                        "owner",
-                        &mut wallet_manager,
-                        &signer_config,
-                    )
-                    .map(Arc::from)
-                })
-                .unwrap_or_else(|err| {
-                    eprintln!("error: owner signer: {}", err);
-                    exit(1);
-                });
+            let owner = if let Ok(Some((signer, _))) =
+                SignerSource::try_get_signer(matches, "owner", &mut wallet_manager)
+            {
+                Arc::from(signer)
+            } else {
+                config.payer.clone()
+            };
             if !signer_config.allow_null_signer && !bulk_signers.contains(&owner) {
                 bulk_signers.push(owner.clone());
             }
-            let burn_from = pubkey_of(arg_matches, "burn_from");
-            let escrow = pubkey_of(arg_matches, "escrow");
-            let destination = pubkey_of(arg_matches, "destination");
+            let burn_from =
+                SignerSource::try_get_pubkey(arg_matches, "burn_from", &mut wallet_manager)
+                    .unwrap();
+            let escrow =
+                SignerSource::try_get_pubkey(arg_matches, "escrow", &mut wallet_manager).unwrap();
+            let destination =
+                SignerSource::try_get_pubkey(arg_matches, "destination", &mut wallet_manager)
+                    .unwrap();
 
             let signature = process_exchange(
                 &rpc_client,
diff --git a/token-upgrade/program/Cargo.toml b/token-upgrade/program/Cargo.toml
index b24acb97361..296cdb2bd18 100644
--- a/token-upgrade/program/Cargo.toml
+++ b/token-upgrade/program/Cargo.toml
@@ -14,16 +14,16 @@ test-sbf = []
 [dependencies]
 num-derive = "0.4"
 num-traits = "0.2"
-num_enum = "0.7.2"
-solana-program = ">=1.18.11,<=2"
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-thiserror = "1.0"
+num_enum = "0.7.3"
+solana-program = "2.1.0"
+spl-token-2022 = { version = "6.0.0", features = ["no-entrypoint"] }
+thiserror = "2.0"
 
 [dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../../token/program", features = ["no-entrypoint"] }
-spl-token-client = { version = "0.10.0", path = "../../token/client" }
+solana-program-test = "2.1.0"
+solana-sdk = "2.1.0"
+spl-token = { version = "7.0", features = ["no-entrypoint"] }
+spl-token-client = { version = "0.13.0" }
 test-case = "3.3"
 
 [lib]
diff --git a/token-upgrade/program/tests/functional.rs b/token-upgrade/program/tests/functional.rs
index 06f3d0eef3f..3938f9f65ec 100644
--- a/token-upgrade/program/tests/functional.rs
+++ b/token-upgrade/program/tests/functional.rs
@@ -164,7 +164,7 @@ async fn success(original_program_id: Pubkey, new_program_id: Pubkey) {
         .unwrap();
 
     {
-        let mut context = context.lock().await;
+        let context = context.lock().await;
         let transaction = Transaction::new_signed_with_payer(
             &[exchange(
                 &spl_token_upgrade::id(),
@@ -285,7 +285,7 @@ async fn fail_incorrect_escrow_derivation(original_program_id: Pubkey, new_progr
         &[],
     );
     instruction.accounts[5] = AccountMeta::new_readonly(program_escrow, false);
-    let mut context = context.lock().await;
+    let context = context.lock().await;
     let transaction = Transaction::new_signed_with_payer(
         &[instruction],
         Some(&context.payer.pubkey()),
@@ -379,7 +379,7 @@ async fn fail_decimals_mismatch(original_program_id: Pubkey, new_program_id: Pub
         .await
         .unwrap();
 
-    let mut context = context.lock().await;
+    let context = context.lock().await;
     let transaction = Transaction::new_signed_with_payer(
         &[exchange(
             &spl_token_upgrade::id(),
diff --git a/token-wrap/program/Cargo.toml b/token-wrap/program/Cargo.toml
index 6cb411609a4..9fd8596ca3f 100644
--- a/token-wrap/program/Cargo.toml
+++ b/token-wrap/program/Cargo.toml
@@ -12,16 +12,19 @@ no-entrypoint = []
 test-sbf = []
 
 [dependencies]
-bytemuck = { version = "1.16.0", features = ["derive"] }
+bytemuck = { version = "1.21.0", features = ["derive"] }
 num_enum = "0.7"
-solana-program = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = ["no-entrypoint"] }
-spl-token = { version = "4.0", path = "../../token/program", features = ["no-entrypoint"] }
-spl-token-2022 = { version = "3.0.2", path = "../../token/program-2022", features = ["no-entrypoint"] }
-thiserror = "1.0"
+solana-program = "2.1.0"
+spl-associated-token-account = { version = "6.0.0", features = ["no-entrypoint"] }
+spl-token = { version = "7.0", features = ["no-entrypoint"] }
+spl-token-2022 = { version = "6.0.0", features = ["no-entrypoint"] }
+thiserror = "2.0"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[lints]
+workspace = true
diff --git a/token-wrap/program/src/instruction.rs b/token-wrap/program/src/instruction.rs
index fc5975c9dd5..bca604a95e6 100644
--- a/token-wrap/program/src/instruction.rs
+++ b/token-wrap/program/src/instruction.rs
@@ -45,8 +45,8 @@ pub enum TokenWrapInstruction {
     /// 6. `[]` SPL Token program for unwrapped mint
     /// 7. `[]` SPL Token program for wrapped mint
     /// 8. `[signer]` Transfer authority on unwrapped token account
-    /// 8..8+M. `[signer]` (Optional) M multisig signers on unwrapped token
-    /// account
+    /// 9. ..8+M. `[signer]` (Optional) M multisig signers on unwrapped token
+    ///    account
     ///
     /// Data expected by this instruction:
     ///   * little-endian u64 representing the amount to wrap
@@ -72,8 +72,8 @@ pub enum TokenWrapInstruction {
     /// 6. `[]` SPL Token program for wrapped mint
     /// 7. `[]` SPL Token program for unwrapped mint
     /// 8. `[signer]` Transfer authority on wrapped token account
-    /// 8..8+M. `[signer]` (Optional) M multisig signers on wrapped token
-    /// account
+    /// 9. ..8+M. `[signer]` (Optional) M multisig signers on wrapped token
+    ///    account
     ///
     /// Data expected by this instruction:
     ///   * little-endian u64 representing the amount to unwrap
diff --git a/token/.gitignore b/token/.gitignore
deleted file mode 100644
index 2a77c909079..00000000000
--- a/token/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/twoxtx-solana/
diff --git a/token/README.md b/token/README.md
new file mode 100644
index 00000000000..e2e43253970
--- /dev/null
+++ b/token/README.md
@@ -0,0 +1,9 @@
+NOTE: The token program is now maintained at
+[solana-program/token](https://github.com/solana-program/token).
+
+The token-2022 program, confidential-transfers, clients, CLI, and JS library are
+maintained at
+[solana-program/token-2022](https://github.com/solana-program/token-2022).
+
+The transfer-hook interface, example program, and clients are maintained at
+[solana-program/transfer-hook](https://github.com/solana-program/transfer-hook).
diff --git a/token/cli/Cargo.toml b/token/cli/Cargo.toml
deleted file mode 100644
index 44819e19e55..00000000000
--- a/token/cli/Cargo.toml
+++ /dev/null
@@ -1,64 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL-Token Command-line Utility"
-edition = "2021"
-homepage = "https://spl.solana.com/token"
-license = "Apache-2.0"
-name = "spl-token-cli"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "3.4.1"
-
-[build-dependencies]
-walkdir = "2"
-
-[dependencies]
-base64 = "0.22.1"
-clap = "2.33.3"
-console = "0.15.8"
-futures = "0.3"
-serde = "1.0.203"
-serde_derive = "1.0.103"
-serde_json = "1.0.117"
-solana-account-decoder = ">=1.18.11,<=2"
-solana-clap-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-cli-output = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-remote-wallet = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-solana-transaction-status = ">=1.18.11,<=2"
-spl-token = { version = "4.0", path = "../program", features = [
-  "no-entrypoint",
-] }
-spl-token-2022 = { version = "3.0.2", path = "../program-2022", features = [
-  "no-entrypoint",
-] }
-spl-token-client = { version = "0.10.0", path = "../client" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-spl-token-group-interface = { version = "0.2.3", path = "../../token-group/interface" }
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-spl-memo = { version = "4.0", path = "../../memo/program", features = [
-  "no-entrypoint",
-] }
-strum = "0.26"
-strum_macros = "0.26"
-tokio = "1.38"
-
-[dev-dependencies]
-solana-test-validator = ">=1.18.11,<=2"
-assert_cmd = "2.0.14"
-libtest-mimic = "0.7"
-serial_test = "3.1.1"
-tempfile = "3.10.1"
-
-[[bin]]
-name = "spl-token"
-path = "src/main.rs"
-
-[[test]]
-name = "command"
-path = "tests/command.rs"
-harness = false
diff --git a/token/cli/README.md b/token/cli/README.md
deleted file mode 100644
index 1d706b5609a..00000000000
--- a/token/cli/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# SPL Token program command-line utility
-
-A basic command-line for creating and using SPL Tokens.  See https://spl.solana.com/token for more details
-
-## Build
-
-To build the CLI locally, simply run:
-
-```sh
-cargo build
-```
-
-## Testing
-
-The tests require locally built programs for Token, Token-2022, and Associated
-Token Account. To build these, you can run:
-
-```sh
-BUILD_DEPENDENT_PROGRAMS=1 cargo build
-```
-
-This method uses the local `build.rs` file, which can be error-prone, so alternatively,
-you can build the programs by running the following commands from this directory:
-
-```sh
-cargo build-sbf --manifest-path ../program/Cargo.toml
-cargo build-sbf --manifest-path ../program-2022/Cargo.toml
-cargo build-sbf --manifest-path ../../associated-token-account/program/Cargo.toml
-```
-
-After that, you can run the tests as any other Rust project:
-
-```sh
-cargo test
-```
diff --git a/token/cli/build.rs b/token/cli/build.rs
deleted file mode 100644
index c07683ecff8..00000000000
--- a/token/cli/build.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-extern crate walkdir;
-
-use {
-    std::{env, path::Path, process::Command},
-    walkdir::WalkDir,
-};
-
-fn rerun_if_changed(directory: &Path) {
-    let src = directory.join("src");
-    let files_in_src: Vec<_> = WalkDir::new(src)
-        .into_iter()
-        .map(|entry| entry.unwrap())
-        .filter(|entry| {
-            if !entry.file_type().is_file() {
-                return false;
-            }
-            true
-        })
-        .map(|f| f.path().to_str().unwrap().to_owned())
-        .collect();
-
-    for file in files_in_src {
-        if !Path::new(&file).is_file() {
-            panic!("{} is not a file", file);
-        }
-        println!("cargo:rerun-if-changed={}", file);
-    }
-    let toml = directory.join("Cargo.toml").to_str().unwrap().to_owned();
-    println!("cargo:rerun-if-changed={}", toml);
-}
-
-fn build_bpf(program_directory: &Path) {
-    let toml_file = program_directory.join("Cargo.toml");
-    let toml_file = format!("{}", toml_file.display());
-    let args = vec!["build-sbf", "--manifest-path", &toml_file];
-    let output = Command::new("cargo")
-        .args(&args)
-        .output()
-        .expect("Error running cargo build-sbf");
-    if let Ok(output_str) = std::str::from_utf8(&output.stdout) {
-        let subs = output_str.split('\n');
-        for sub in subs {
-            println!("cargo:warning=(not a warning) {}", sub);
-        }
-    }
-}
-
-fn main() {
-    let is_debug = env::var("DEBUG").map(|v| v == "true").unwrap_or(false);
-    let build_dependent_programs = env::var("BUILD_DEPENDENT_PROGRAMS")
-        .map(|v| v != "false" && v != "0")
-        .unwrap_or(false);
-    if is_debug && build_dependent_programs {
-        let cwd = env::current_dir().expect("Unable to get current working directory");
-        let spl_token_2022_dir = cwd
-            .parent()
-            .expect("Unable to get parent directory of current working dir")
-            .join("program-2022");
-        rerun_if_changed(&spl_token_2022_dir);
-        let spl_token_dir = cwd
-            .parent()
-            .expect("Unable to get parent directory of current working dir")
-            .join("program");
-        rerun_if_changed(&spl_token_dir);
-        let spl_associated_token_account_dir = cwd
-            .parent()
-            .expect("Unable to get parent directory of current working dir")
-            .parent()
-            .expect("Unable to get parent directory of current working dir")
-            .join("associated-token-account")
-            .join("program");
-        rerun_if_changed(&spl_associated_token_account_dir);
-
-        build_bpf(&spl_token_dir);
-        build_bpf(&spl_token_2022_dir);
-        build_bpf(&spl_associated_token_account_dir);
-    }
-    println!("cargo:rerun-if-changed=build.rs");
-}
diff --git a/token/cli/examples/confidential-transfer.sh b/token/cli/examples/confidential-transfer.sh
deleted file mode 100755
index 00536e4a470..00000000000
--- a/token/cli/examples/confidential-transfer.sh
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env bash
-
-# Set whichever network you would like to test with
-# solana config set -ul
-
-program_id="TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
-
-echo "Setup keypairs"
-solana-keygen new -o confidential-mint.json --no-bip39-passphrase
-solana-keygen new -o confidential-source.json --no-bip39-passphrase
-solana-keygen new -o confidential-destination.json --no-bip39-passphrase
-mint_pubkey=$(solana-keygen pubkey "confidential-mint.json")
-source_pubkey=$(solana-keygen pubkey "confidential-source.json")
-destination_pubkey=$(solana-keygen pubkey "confidential-destination.json")
-
-set -ex
-echo "Initializing mint"
-spl-token --program-id "$program_id" create-token confidential-mint.json --enable-confidential-transfers auto
-echo "Displaying"
-spl-token display "$mint_pubkey"
-read  -n 1 -p "..."
-
-echo "Setting up transfer accounts"
-spl-token create-account "$mint_pubkey" confidential-source.json
-spl-token configure-confidential-transfer-account --address "$source_pubkey"
-spl-token create-account "$mint_pubkey" confidential-destination.json
-spl-token configure-confidential-transfer-account --address "$destination_pubkey"
-spl-token mint "$mint_pubkey" 100 confidential-source.json
-
-echo "Displaying"
-spl-token display "$source_pubkey"
-read  -n 1 -p "..."
-
-echo "Depositing into confidential"
-spl-token deposit-confidential-tokens "$mint_pubkey" 100 --address "$source_pubkey"
-echo "Displaying"
-spl-token display "$source_pubkey"
-read  -n 1 -p "..."
-
-echo "Applying pending balances"
-spl-token apply-pending-balance --address "$source_pubkey"
-echo "Displaying"
-spl-token display "$source_pubkey"
-read  -n 1 -p "..."
-
-echo "Transferring 10"
-spl-token transfer "$mint_pubkey" 10 "$destination_pubkey" --from "$source_pubkey" --confidential
-echo "Displaying source"
-spl-token display "$source_pubkey"
-echo "Displaying destination"
-spl-token display "$destination_pubkey"
-read  -n 1 -p "..."
-
-echo "Applying balance on destination"
-spl-token apply-pending-balance --address "$destination_pubkey"
-echo "Displaying destination"
-spl-token display "$destination_pubkey"
-read  -n 1 -p "..."
-
-echo "Transferring 0"
-spl-token transfer "$mint_pubkey" 0 "$destination_pubkey" --from "$source_pubkey" --confidential
-echo "Displaying destination"
-spl-token display "$destination_pubkey"
-read  -n 1 -p "..."
-
-echo "Transferring 0 again"
-spl-token transfer "$mint_pubkey" 0 "$destination_pubkey" --from "$source_pubkey" --confidential
-echo "Displaying destination"
-spl-token display "$destination_pubkey"
-read  -n 1 -p "..."
-
-echo "Withdrawing 10 from destination"
-spl-token apply-pending-balance --address "$destination_pubkey"
-spl-token withdraw-confidential-tokens "$mint_pubkey" 10 --address "$destination_pubkey"
-echo "Displaying destination"
-spl-token display "$destination_pubkey"
-read  -n 1 -p "..."
diff --git a/token/cli/src/bench.rs b/token/cli/src/bench.rs
deleted file mode 100644
index 644cdc55333..00000000000
--- a/token/cli/src/bench.rs
+++ /dev/null
@@ -1,371 +0,0 @@
-/// The `bench` subcommand
-use {
-    crate::{clap_app::Error, command::CommandResult, config::Config},
-    clap::{value_t_or_exit, ArgMatches},
-    solana_clap_utils::input_parsers::pubkey_of_signer,
-    solana_client::{
-        nonblocking::rpc_client::RpcClient, rpc_client::RpcClient as BlockingRpcClient,
-        tpu_client::TpuClient, tpu_client::TpuClientConfig,
-    },
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        message::Message, native_token::lamports_to_sol, native_token::Sol, program_pack::Pack,
-        pubkey::Pubkey, signature::Signer, system_instruction,
-    },
-    spl_associated_token_account::*,
-    spl_token_2022::{
-        extension::StateWithExtensions,
-        instruction,
-        state::{Account, Mint},
-    },
-    std::{rc::Rc, sync::Arc, time::Instant},
-};
-
-pub(crate) async fn bench_process_command(
-    matches: &ArgMatches<'_>,
-    config: &Config<'_>,
-    mut signers: Vec<Arc<dyn Signer>>,
-    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-) -> CommandResult {
-    assert!(!config.sign_only);
-
-    match matches.subcommand() {
-        ("create-accounts", Some(arg_matches)) => {
-            let token = pubkey_of_signer(arg_matches, "token", wallet_manager)
-                .unwrap()
-                .unwrap();
-            let n = value_t_or_exit!(arg_matches, "n", usize);
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", wallet_manager);
-            signers.push(owner_signer);
-
-            command_create_accounts(config, signers, &token, n, &owner).await?;
-        }
-        ("close-accounts", Some(arg_matches)) => {
-            let token = pubkey_of_signer(arg_matches, "token", wallet_manager)
-                .unwrap()
-                .unwrap();
-            let n = value_t_or_exit!(arg_matches, "n", usize);
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", wallet_manager);
-            signers.push(owner_signer);
-
-            command_close_accounts(config, signers, &token, n, &owner).await?;
-        }
-        ("deposit-into", Some(arg_matches)) => {
-            let token = pubkey_of_signer(arg_matches, "token", wallet_manager)
-                .unwrap()
-                .unwrap();
-            let n = value_t_or_exit!(arg_matches, "n", usize);
-            let ui_amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", wallet_manager);
-            signers.push(owner_signer);
-            let from = pubkey_of_signer(arg_matches, "from", wallet_manager).unwrap();
-            command_deposit_into_or_withdraw_from(
-                config, signers, &token, n, &owner, ui_amount, from, true,
-            )
-            .await?;
-        }
-        ("withdraw-from", Some(arg_matches)) => {
-            let token = pubkey_of_signer(arg_matches, "token", wallet_manager)
-                .unwrap()
-                .unwrap();
-            let n = value_t_or_exit!(arg_matches, "n", usize);
-            let ui_amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", wallet_manager);
-            signers.push(owner_signer);
-            let to = pubkey_of_signer(arg_matches, "to", wallet_manager).unwrap();
-            command_deposit_into_or_withdraw_from(
-                config, signers, &token, n, &owner, ui_amount, to, false,
-            )
-            .await?;
-        }
-        _ => unreachable!(),
-    }
-
-    Ok("".to_string())
-}
-
-fn get_token_address_with_seed(
-    program_id: &Pubkey,
-    token: &Pubkey,
-    owner: &Pubkey,
-    i: usize,
-) -> (Pubkey, String) {
-    let seed = format!("{}{}", i, token)[..31].to_string();
-    (
-        Pubkey::create_with_seed(owner, &seed, program_id).unwrap(),
-        seed,
-    )
-}
-
-fn get_token_addresses_with_seed(
-    program_id: &Pubkey,
-    token: &Pubkey,
-    owner: &Pubkey,
-    n: usize,
-) -> Vec<(Pubkey, String)> {
-    (0..n)
-        .map(|i| get_token_address_with_seed(program_id, token, owner, i))
-        .collect()
-}
-
-async fn get_valid_mint_program_id(
-    rpc_client: &RpcClient,
-    token: &Pubkey,
-) -> Result<Pubkey, Error> {
-    let mint_account = rpc_client
-        .get_account(token)
-        .await
-        .map_err(|err| format!("Token mint {} does not exist: {}", token, err))?;
-
-    StateWithExtensions::<Mint>::unpack(&mint_account.data)
-        .map_err(|err| format!("Invalid token mint {}: {}", token, err))?;
-    Ok(mint_account.owner)
-}
-
-async fn command_create_accounts(
-    config: &Config<'_>,
-    signers: Vec<Arc<dyn Signer>>,
-    token: &Pubkey,
-    n: usize,
-    owner: &Pubkey,
-) -> Result<(), Error> {
-    let rpc_client = &config.rpc_client;
-
-    println!("Scanning accounts...");
-    let program_id = get_valid_mint_program_id(rpc_client, token).await?;
-
-    let minimum_balance_for_rent_exemption = rpc_client
-        .get_minimum_balance_for_rent_exemption(Account::get_packed_len())
-        .await?;
-
-    let mut lamports_required: u64 = 0;
-
-    let token_addresses_with_seed = get_token_addresses_with_seed(&program_id, token, owner, n);
-    let mut messages = vec![];
-    for address_chunk in token_addresses_with_seed.chunks(100) {
-        let accounts_chunk = rpc_client
-            .get_multiple_accounts(&address_chunk.iter().map(|x| x.0).collect::<Vec<_>>())
-            .await?;
-
-        for (account, (address, seed)) in accounts_chunk.iter().zip(address_chunk) {
-            if account.is_none() {
-                lamports_required =
-                    lamports_required.saturating_add(minimum_balance_for_rent_exemption);
-                messages.push(Message::new(
-                    &[
-                        system_instruction::create_account_with_seed(
-                            &config.fee_payer()?.pubkey(),
-                            address,
-                            owner,
-                            seed,
-                            minimum_balance_for_rent_exemption,
-                            Account::get_packed_len() as u64,
-                            &program_id,
-                        ),
-                        instruction::initialize_account(&program_id, address, token, owner)?,
-                    ],
-                    Some(&config.fee_payer()?.pubkey()),
-                ));
-            }
-        }
-    }
-
-    send_messages(config, &messages, lamports_required, signers).await
-}
-
-async fn command_close_accounts(
-    config: &Config<'_>,
-    signers: Vec<Arc<dyn Signer>>,
-    token: &Pubkey,
-    n: usize,
-    owner: &Pubkey,
-) -> Result<(), Error> {
-    let rpc_client = &config.rpc_client;
-
-    println!("Scanning accounts...");
-    let program_id = get_valid_mint_program_id(rpc_client, token).await?;
-
-    let token_addresses_with_seed = get_token_addresses_with_seed(&program_id, token, owner, n);
-    let mut messages = vec![];
-    for address_chunk in token_addresses_with_seed.chunks(100) {
-        let accounts_chunk = rpc_client
-            .get_multiple_accounts(&address_chunk.iter().map(|x| x.0).collect::<Vec<_>>())
-            .await?;
-
-        for (account, (address, _seed)) in accounts_chunk.iter().zip(address_chunk) {
-            if let Some(account) = account {
-                match StateWithExtensions::<Account>::unpack(&account.data) {
-                    Ok(token_account) => {
-                        if token_account.base.amount != 0 {
-                            eprintln!(
-                                "Token account {} holds a balance; unable to close it",
-                                address,
-                            );
-                        } else {
-                            messages.push(Message::new(
-                                &[instruction::close_account(
-                                    &program_id,
-                                    address,
-                                    owner,
-                                    owner,
-                                    &[],
-                                )?],
-                                Some(&config.fee_payer()?.pubkey()),
-                            ));
-                        }
-                    }
-                    Err(err) => {
-                        eprintln!("Invalid token account {}: {}", address, err)
-                    }
-                }
-            }
-        }
-    }
-
-    send_messages(config, &messages, 0, signers).await
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_deposit_into_or_withdraw_from(
-    config: &Config<'_>,
-    signers: Vec<Arc<dyn Signer>>,
-    token: &Pubkey,
-    n: usize,
-    owner: &Pubkey,
-    ui_amount: f64,
-    from_or_to: Option<Pubkey>,
-    deposit_into: bool,
-) -> Result<(), Error> {
-    let rpc_client = &config.rpc_client;
-
-    println!("Scanning accounts...");
-    let program_id = get_valid_mint_program_id(rpc_client, token).await?;
-
-    let mint_info = config.get_mint_info(token, None).await?;
-    let from_or_to = from_or_to
-        .unwrap_or_else(|| get_associated_token_address_with_program_id(owner, token, &program_id));
-    config.check_account(&from_or_to, Some(*token)).await?;
-    let amount = spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals);
-
-    let token_addresses_with_seed = get_token_addresses_with_seed(&program_id, token, owner, n);
-    let mut messages = vec![];
-    for address_chunk in token_addresses_with_seed.chunks(100) {
-        let accounts_chunk = rpc_client
-            .get_multiple_accounts(&address_chunk.iter().map(|x| x.0).collect::<Vec<_>>())
-            .await?;
-
-        for (account, (address, _seed)) in accounts_chunk.iter().zip(address_chunk) {
-            if account.is_some() {
-                messages.push(Message::new(
-                    &[instruction::transfer_checked(
-                        &program_id,
-                        if deposit_into { &from_or_to } else { address },
-                        token,
-                        if deposit_into { address } else { &from_or_to },
-                        owner,
-                        &[],
-                        amount,
-                        mint_info.decimals,
-                    )?],
-                    Some(&config.fee_payer()?.pubkey()),
-                ));
-            } else {
-                eprintln!("Token account does not exist: {}", address)
-            }
-        }
-    }
-
-    send_messages(config, &messages, 0, signers).await
-}
-
-async fn send_messages(
-    config: &Config<'_>,
-    messages: &[Message],
-    mut lamports_required: u64,
-    signers: Vec<Arc<dyn Signer>>,
-) -> Result<(), Error> {
-    if messages.is_empty() {
-        println!("Nothing to do");
-        return Ok(());
-    }
-
-    let blockhash = config.rpc_client.get_latest_blockhash().await?;
-    let mut message = messages[0].clone();
-    message.recent_blockhash = blockhash;
-    lamports_required = lamports_required.saturating_add(
-        config
-            .rpc_client
-            .get_fee_for_message(&message)
-            .await?
-            .saturating_mul(messages.len() as u64),
-    );
-
-    println!(
-        "Sending {:?} messages for ~{}",
-        messages.len(),
-        Sol(lamports_required)
-    );
-
-    check_fee_payer_balance(config, lamports_required).await?;
-
-    // TODO use async tpu client once it's available in 1.11
-    let start = Instant::now();
-    let rpc_client = BlockingRpcClient::new(config.rpc_client.url());
-    let tpu_client = TpuClient::new(
-        Arc::new(rpc_client),
-        &config.websocket_url,
-        TpuClientConfig::default(),
-    )?;
-    let transaction_errors =
-        tpu_client.send_and_confirm_messages_with_spinner(messages, &signers)?;
-    for (i, transaction_error) in transaction_errors.into_iter().enumerate() {
-        if let Some(transaction_error) = transaction_error {
-            println!("Message {} failed with {:?}", i, transaction_error);
-        }
-    }
-    let elapsed = Instant::now().duration_since(start);
-    let tps = messages.len() as f64 / elapsed.as_secs_f64();
-    println!(
-        "Average TPS: {:.2}\nElapsed time: {} seconds",
-        tps,
-        elapsed.as_secs_f64(),
-    );
-
-    let stats = config.rpc_client.get_transport_stats();
-    println!("Total RPC requests: {}", stats.request_count);
-    println!(
-        "Total RPC time: {:.2} seconds",
-        stats.elapsed_time.as_secs_f64()
-    );
-    if stats.rate_limited_time != std::time::Duration::default() {
-        println!(
-            "Total idle time due to RPC rate limiting: {:.2} seconds",
-            stats.rate_limited_time.as_secs_f64()
-        );
-    }
-
-    Ok(())
-}
-
-async fn check_fee_payer_balance(config: &Config<'_>, required_balance: u64) -> Result<(), Error> {
-    let balance = config
-        .rpc_client
-        .get_balance(&config.fee_payer()?.pubkey())
-        .await?;
-    if balance < required_balance {
-        Err(format!(
-            "Fee payer, {}, has insufficient balance: {} required, {} available",
-            config.fee_payer()?.pubkey(),
-            lamports_to_sol(required_balance),
-            lamports_to_sol(balance)
-        )
-        .into())
-    } else {
-        Ok(())
-    }
-}
diff --git a/token/cli/src/clap_app.rs b/token/cli/src/clap_app.rs
deleted file mode 100644
index 94d67ef87c7..00000000000
--- a/token/cli/src/clap_app.rs
+++ /dev/null
@@ -1,2619 +0,0 @@
-use {
-    clap::{
-        crate_description, crate_name, crate_version, App, AppSettings, Arg, ArgGroup, SubCommand,
-    },
-    solana_clap_utils::{
-        fee_payer::fee_payer_arg,
-        input_validators::{
-            is_amount, is_amount_or_all, is_parsable, is_pubkey, is_url_or_moniker,
-            is_valid_pubkey, is_valid_signer,
-        },
-        memo::memo_arg,
-        nonce::*,
-        offline::{self, *},
-        ArgConstant,
-    },
-    solana_sdk::{instruction::AccountMeta, pubkey::Pubkey},
-    spl_token_2022::instruction::{AuthorityType, MAX_SIGNERS, MIN_SIGNERS},
-    std::{fmt, str::FromStr},
-    strum::IntoEnumIterator,
-    strum_macros::{AsRefStr, EnumIter, EnumString, IntoStaticStr},
-};
-
-pub type Error = Box<dyn std::error::Error + Send + Sync>;
-
-pub const OWNER_ADDRESS_ARG: ArgConstant<'static> = ArgConstant {
-    name: "owner",
-    long: "owner",
-    help: "Address of the primary authority controlling a mint or account. Defaults to the client keypair address.",
-};
-
-pub const OWNER_KEYPAIR_ARG: ArgConstant<'static> = ArgConstant {
-    name: "owner",
-    long: "owner",
-    help: "Keypair of the primary authority controlling a mint or account. Defaults to the client keypair.",
-};
-
-pub const MINT_ADDRESS_ARG: ArgConstant<'static> = ArgConstant {
-    name: "mint_address",
-    long: "mint-address",
-    help: "Address of mint that token account is associated with. Required by --sign-only",
-};
-
-pub const MINT_DECIMALS_ARG: ArgConstant<'static> = ArgConstant {
-    name: "mint_decimals",
-    long: "mint-decimals",
-    help: "Decimals of mint that token account is associated with. Required by --sign-only",
-};
-
-pub const DELEGATE_ADDRESS_ARG: ArgConstant<'static> = ArgConstant {
-    name: "delegate_address",
-    long: "delegate-address",
-    help: "Address of delegate currently assigned to token account. Required by --sign-only",
-};
-
-pub const TRANSFER_LAMPORTS_ARG: ArgConstant<'static> = ArgConstant {
-    name: "transfer_lamports",
-    long: "transfer-lamports",
-    help: "Additional lamports to transfer to make account rent-exempt after reallocation. Required by --sign-only",
-};
-
-pub const MULTISIG_SIGNER_ARG: ArgConstant<'static> = ArgConstant {
-    name: "multisig_signer",
-    long: "multisig-signer",
-    help: "Member signer of a multisig account",
-};
-
-pub const COMPUTE_UNIT_PRICE_ARG: ArgConstant<'static> = ArgConstant {
-    name: "compute_unit_price",
-    long: "--with-compute-unit-price",
-    help: "Set compute unit price for transaction, in increments of 0.000001 lamports per compute unit.",
-};
-
-pub const COMPUTE_UNIT_LIMIT_ARG: ArgConstant<'static> = ArgConstant {
-    name: "compute_unit_limit",
-    long: "--with-compute-unit-limit",
-    help: "Set compute unit limit for transaction, in compute units.",
-};
-
-pub static VALID_TOKEN_PROGRAM_IDS: [Pubkey; 2] = [spl_token_2022::ID, spl_token::ID];
-
-#[derive(AsRefStr, Debug, Clone, Copy, PartialEq, EnumString, IntoStaticStr)]
-#[strum(serialize_all = "kebab-case")]
-pub enum CommandName {
-    CreateToken,
-    Close,
-    CloseMint,
-    Bench,
-    CreateAccount,
-    CreateMultisig,
-    Authorize,
-    SetInterestRate,
-    Transfer,
-    Burn,
-    Mint,
-    Freeze,
-    Thaw,
-    Wrap,
-    Unwrap,
-    Approve,
-    Revoke,
-    Balance,
-    Supply,
-    Accounts,
-    Address,
-    AccountInfo,
-    MultisigInfo,
-    Display,
-    Gc,
-    SyncNative,
-    EnableRequiredTransferMemos,
-    DisableRequiredTransferMemos,
-    EnableCpiGuard,
-    DisableCpiGuard,
-    UpdateDefaultAccountState,
-    UpdateMetadataAddress,
-    WithdrawWithheldTokens,
-    SetTransferFee,
-    WithdrawExcessLamports,
-    SetTransferHook,
-    InitializeMetadata,
-    UpdateMetadata,
-    InitializeGroup,
-    UpdateGroupMaxSize,
-    InitializeMember,
-    UpdateConfidentialTransferSettings,
-    ConfigureConfidentialTransferAccount,
-    EnableConfidentialCredits,
-    DisableConfidentialCredits,
-    EnableNonConfidentialCredits,
-    DisableNonConfidentialCredits,
-    DepositConfidentialTokens,
-    WithdrawConfidentialTokens,
-    ApplyPendingBalance,
-    UpdateGroupAddress,
-    UpdateMemberAddress,
-}
-impl fmt::Display for CommandName {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, EnumString, IntoStaticStr)]
-#[strum(serialize_all = "kebab-case")]
-pub enum AccountMetaRole {
-    Readonly,
-    Writable,
-    ReadonlySigner,
-    WritableSigner,
-}
-impl fmt::Display for AccountMetaRole {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-pub fn parse_transfer_hook_account<T>(string: T) -> Result<AccountMeta, String>
-where
-    T: AsRef<str> + fmt::Display,
-{
-    match string.as_ref().split(':').collect::<Vec<_>>().as_slice() {
-        [address, role] => {
-            let address = Pubkey::from_str(address).map_err(|e| format!("{e}"))?;
-            let meta = match AccountMetaRole::from_str(role).map_err(|e| format!("{e}"))? {
-                AccountMetaRole::Readonly => AccountMeta::new_readonly(address, false),
-                AccountMetaRole::Writable => AccountMeta::new(address, false),
-                AccountMetaRole::ReadonlySigner => AccountMeta::new_readonly(address, true),
-                AccountMetaRole::WritableSigner => AccountMeta::new(address, true),
-            };
-            Ok(meta)
-        }
-        _ => Err("Transfer hook account must be present as <ADDRESS>:<ROLE>".to_string()),
-    }
-}
-fn validate_transfer_hook_account<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + fmt::Display,
-{
-    match string.as_ref().split(':').collect::<Vec<_>>().as_slice() {
-        [address, role] => {
-            is_valid_pubkey(address)?;
-            AccountMetaRole::from_str(role)
-                .map(|_| ())
-                .map_err(|e| format!("{e}"))
-        }
-        _ => Err("Transfer hook account must be present as <ADDRESS>:<ROLE>".to_string()),
-    }
-}
-#[derive(Debug, Clone, PartialEq, EnumIter, EnumString, IntoStaticStr)]
-#[strum(serialize_all = "kebab-case")]
-pub enum CliAuthorityType {
-    Mint,
-    Freeze,
-    Owner,
-    Close,
-    CloseMint,
-    TransferFeeConfig,
-    WithheldWithdraw,
-    InterestRate,
-    PermanentDelegate,
-    ConfidentialTransferMint,
-    TransferHookProgramId,
-    ConfidentialTransferFee,
-    MetadataPointer,
-    Metadata,
-    GroupPointer,
-    GroupMemberPointer,
-    Group,
-}
-impl TryFrom<CliAuthorityType> for AuthorityType {
-    type Error = Error;
-    fn try_from(authority_type: CliAuthorityType) -> Result<Self, Error> {
-        match authority_type {
-            CliAuthorityType::Mint => Ok(AuthorityType::MintTokens),
-            CliAuthorityType::Freeze => Ok(AuthorityType::FreezeAccount),
-            CliAuthorityType::Owner => Ok(AuthorityType::AccountOwner),
-            CliAuthorityType::Close => Ok(AuthorityType::CloseAccount),
-            CliAuthorityType::CloseMint => Ok(AuthorityType::CloseMint),
-            CliAuthorityType::TransferFeeConfig => Ok(AuthorityType::TransferFeeConfig),
-            CliAuthorityType::WithheldWithdraw => Ok(AuthorityType::WithheldWithdraw),
-            CliAuthorityType::InterestRate => Ok(AuthorityType::InterestRate),
-            CliAuthorityType::PermanentDelegate => Ok(AuthorityType::PermanentDelegate),
-            CliAuthorityType::ConfidentialTransferMint => {
-                Ok(AuthorityType::ConfidentialTransferMint)
-            }
-            CliAuthorityType::TransferHookProgramId => Ok(AuthorityType::TransferHookProgramId),
-            CliAuthorityType::ConfidentialTransferFee => {
-                Ok(AuthorityType::ConfidentialTransferFeeConfig)
-            }
-            CliAuthorityType::MetadataPointer => Ok(AuthorityType::MetadataPointer),
-            CliAuthorityType::Metadata => {
-                Err("Metadata authority does not map to a token authority type".into())
-            }
-            CliAuthorityType::GroupPointer => Ok(AuthorityType::GroupPointer),
-            CliAuthorityType::GroupMemberPointer => Ok(AuthorityType::GroupMemberPointer),
-            CliAuthorityType::Group => {
-                Err("Group update authority does not map to a token authority type".into())
-            }
-        }
-    }
-}
-
-pub fn owner_address_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(OWNER_ADDRESS_ARG.name)
-        .long(OWNER_ADDRESS_ARG.long)
-        .takes_value(true)
-        .value_name("OWNER_ADDRESS")
-        .validator(is_valid_pubkey)
-        .help(OWNER_ADDRESS_ARG.help)
-}
-
-pub fn owner_keypair_arg_with_value_name<'a, 'b>(value_name: &'static str) -> Arg<'a, 'b> {
-    Arg::with_name(OWNER_KEYPAIR_ARG.name)
-        .long(OWNER_KEYPAIR_ARG.long)
-        .takes_value(true)
-        .value_name(value_name)
-        .validator(is_valid_signer)
-        .help(OWNER_KEYPAIR_ARG.help)
-}
-
-pub fn owner_keypair_arg<'a, 'b>() -> Arg<'a, 'b> {
-    owner_keypair_arg_with_value_name("OWNER_KEYPAIR")
-}
-
-pub fn mint_address_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(MINT_ADDRESS_ARG.name)
-        .long(MINT_ADDRESS_ARG.long)
-        .takes_value(true)
-        .value_name("MINT_ADDRESS")
-        .validator(is_valid_pubkey)
-        .help(MINT_ADDRESS_ARG.help)
-}
-
-fn is_mint_decimals(string: String) -> Result<(), String> {
-    is_parsable::<u8>(string)
-}
-
-pub fn mint_decimals_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(MINT_DECIMALS_ARG.name)
-        .long(MINT_DECIMALS_ARG.long)
-        .takes_value(true)
-        .value_name("MINT_DECIMALS")
-        .validator(is_mint_decimals)
-        .help(MINT_DECIMALS_ARG.help)
-}
-
-pub trait MintArgs {
-    fn mint_args(self) -> Self;
-}
-
-impl MintArgs for App<'_, '_> {
-    fn mint_args(self) -> Self {
-        self.arg(mint_address_arg().requires(MINT_DECIMALS_ARG.name))
-            .arg(mint_decimals_arg().requires(MINT_ADDRESS_ARG.name))
-    }
-}
-
-pub fn delegate_address_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(DELEGATE_ADDRESS_ARG.name)
-        .long(DELEGATE_ADDRESS_ARG.long)
-        .takes_value(true)
-        .value_name("DELEGATE_ADDRESS")
-        .validator(is_valid_pubkey)
-        .help(DELEGATE_ADDRESS_ARG.help)
-}
-
-pub fn transfer_lamports_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(TRANSFER_LAMPORTS_ARG.name)
-        .long(TRANSFER_LAMPORTS_ARG.long)
-        .takes_value(true)
-        .value_name("LAMPORTS")
-        .validator(is_amount)
-        .help(TRANSFER_LAMPORTS_ARG.help)
-}
-
-pub fn multisig_signer_arg<'a, 'b>() -> Arg<'a, 'b> {
-    Arg::with_name(MULTISIG_SIGNER_ARG.name)
-        .long(MULTISIG_SIGNER_ARG.long)
-        .validator(is_valid_signer)
-        .value_name("MULTISIG_SIGNER")
-        .takes_value(true)
-        .multiple(true)
-        .min_values(0u64)
-        .max_values(MAX_SIGNERS as u64)
-        .help(MULTISIG_SIGNER_ARG.help)
-}
-
-fn is_multisig_minimum_signers(string: String) -> Result<(), String> {
-    let v = u8::from_str(&string).map_err(|e| e.to_string())? as usize;
-    if v < MIN_SIGNERS {
-        Err(format!("must be at least {}", MIN_SIGNERS))
-    } else if v > MAX_SIGNERS {
-        Err(format!("must be at most {}", MAX_SIGNERS))
-    } else {
-        Ok(())
-    }
-}
-
-fn is_valid_token_program_id<T>(string: T) -> Result<(), String>
-where
-    T: AsRef<str> + fmt::Display,
-{
-    match is_pubkey(string.as_ref()) {
-        Ok(()) => {
-            let program_id = string.as_ref().parse::<Pubkey>().unwrap();
-            if VALID_TOKEN_PROGRAM_IDS.contains(&program_id) {
-                Ok(())
-            } else {
-                Err(format!("Unrecognized token program id: {}", program_id))
-            }
-        }
-        Err(e) => Err(e),
-    }
-}
-
-struct SignOnlyNeedsFullMintSpec {}
-impl offline::ArgsConfig for SignOnlyNeedsFullMintSpec {
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_ADDRESS_ARG.name, MINT_DECIMALS_ARG.name])
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_ADDRESS_ARG.name, MINT_DECIMALS_ARG.name])
-    }
-}
-
-struct SignOnlyNeedsMintDecimals {}
-impl offline::ArgsConfig for SignOnlyNeedsMintDecimals {
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_DECIMALS_ARG.name])
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_DECIMALS_ARG.name])
-    }
-}
-
-struct SignOnlyNeedsMintAddress {}
-impl offline::ArgsConfig for SignOnlyNeedsMintAddress {
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_ADDRESS_ARG.name])
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[MINT_ADDRESS_ARG.name])
-    }
-}
-
-struct SignOnlyNeedsDelegateAddress {}
-impl offline::ArgsConfig for SignOnlyNeedsDelegateAddress {
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[DELEGATE_ADDRESS_ARG.name])
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[DELEGATE_ADDRESS_ARG.name])
-    }
-}
-
-struct SignOnlyNeedsTransferLamports {}
-impl offline::ArgsConfig for SignOnlyNeedsTransferLamports {
-    fn sign_only_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[TRANSFER_LAMPORTS_ARG.name])
-    }
-    fn signer_arg<'a, 'b>(&self, arg: Arg<'a, 'b>) -> Arg<'a, 'b> {
-        arg.requires_all(&[TRANSFER_LAMPORTS_ARG.name])
-    }
-}
-
-pub fn minimum_signers_help_string() -> String {
-    format!(
-        "The minimum number of signers required to allow the operation. [{} <= M <= N]",
-        MIN_SIGNERS
-    )
-}
-
-pub fn multisig_member_help_string() -> String {
-    format!(
-        "The public keys for each of the N signing members of this account. [{} <= N <= {}]",
-        MIN_SIGNERS, MAX_SIGNERS
-    )
-}
-
-pub(crate) trait BenchSubCommand {
-    fn bench_subcommand(self) -> Self;
-}
-
-impl BenchSubCommand for App<'_, '_> {
-    fn bench_subcommand(self) -> Self {
-        self.subcommand(
-            SubCommand::with_name("bench")
-                .about("Token benchmarking facilities")
-                .setting(AppSettings::InferSubcommands)
-                .setting(AppSettings::SubcommandRequiredElseHelp)
-                .subcommand(
-                    SubCommand::with_name("create-accounts")
-                        .about("Create multiple token accounts for benchmarking")
-                        .arg(
-                            Arg::with_name("token")
-                                .validator(is_valid_pubkey)
-                                .value_name("TOKEN_ADDRESS")
-                                .takes_value(true)
-                                .index(1)
-                                .required(true)
-                                .help("The token that the accounts will hold"),
-                        )
-                        .arg(
-                            Arg::with_name("n")
-                                .validator(is_parsable::<usize>)
-                                .value_name("N")
-                                .takes_value(true)
-                                .index(2)
-                                .required(true)
-                                .help("The number of accounts to create"),
-                        )
-                        .arg(owner_address_arg()),
-                )
-                .subcommand(
-                    SubCommand::with_name("close-accounts")
-                        .about("Close multiple token accounts used for benchmarking")
-                        .arg(
-                            Arg::with_name("token")
-                                .validator(is_valid_pubkey)
-                                .value_name("TOKEN_ADDRESS")
-                                .takes_value(true)
-                                .index(1)
-                                .required(true)
-                                .help("The token that the accounts held"),
-                        )
-                        .arg(
-                            Arg::with_name("n")
-                                .validator(is_parsable::<usize>)
-                                .value_name("N")
-                                .takes_value(true)
-                                .index(2)
-                                .required(true)
-                                .help("The number of accounts to close"),
-                        )
-                        .arg(owner_address_arg()),
-                )
-                .subcommand(
-                    SubCommand::with_name("deposit-into")
-                        .about("Deposit tokens into multiple accounts")
-                        .arg(
-                            Arg::with_name("token")
-                                .validator(is_valid_pubkey)
-                                .value_name("TOKEN_ADDRESS")
-                                .takes_value(true)
-                                .index(1)
-                                .required(true)
-                                .help("The token that the accounts will hold"),
-                        )
-                        .arg(
-                            Arg::with_name("n")
-                                .validator(is_parsable::<usize>)
-                                .value_name("N")
-                                .takes_value(true)
-                                .index(2)
-                                .required(true)
-                                .help("The number of accounts to deposit into"),
-                        )
-                        .arg(
-                            Arg::with_name("amount")
-                                .validator(is_amount)
-                                .value_name("TOKEN_AMOUNT")
-                                .takes_value(true)
-                                .index(3)
-                                .required(true)
-                                .help("Amount to deposit into each account, in tokens"),
-                        )
-                        .arg(
-                            Arg::with_name("from")
-                                .long("from")
-                                .validator(is_valid_pubkey)
-                                .value_name("SOURCE_TOKEN_ACCOUNT_ADDRESS")
-                                .takes_value(true)
-                                .help("The source token account address [default: associated token account for --owner]")
-                        )
-                        .arg(owner_address_arg()),
-                )
-                .subcommand(
-                    SubCommand::with_name("withdraw-from")
-                        .about("Withdraw tokens from multiple accounts")
-                        .arg(
-                            Arg::with_name("token")
-                                .validator(is_valid_pubkey)
-                                .value_name("TOKEN_ADDRESS")
-                                .takes_value(true)
-                                .index(1)
-                                .required(true)
-                                .help("The token that the accounts hold"),
-                        )
-                        .arg(
-                            Arg::with_name("n")
-                                .validator(is_parsable::<usize>)
-                                .value_name("N")
-                                .takes_value(true)
-                                .index(2)
-                                .required(true)
-                                .help("The number of accounts to withdraw from"),
-                        )
-                        .arg(
-                            Arg::with_name("amount")
-                                .validator(is_amount)
-                                .value_name("TOKEN_AMOUNT")
-                                .takes_value(true)
-                                .index(3)
-                                .required(true)
-                                .help("Amount to withdraw from each account, in tokens"),
-                        )
-                        .arg(
-                            Arg::with_name("to")
-                                .long("to")
-                                .validator(is_valid_pubkey)
-                                .value_name("RECIPIENT_TOKEN_ACCOUNT_ADDRESS")
-                                .takes_value(true)
-                                .help("The recipient token account address [default: associated token account for --owner]")
-                        )
-                        .arg(owner_address_arg()),
-                ),
-        )
-    }
-}
-
-pub fn app<'a, 'b>(
-    default_decimals: &'a str,
-    minimum_signers_help: &'b str,
-    multisig_member_help: &'b str,
-) -> App<'a, 'b> {
-    App::new(crate_name!())
-        .about(crate_description!())
-        .version(crate_version!())
-        .setting(AppSettings::SubcommandRequiredElseHelp)
-        .arg(
-            Arg::with_name("config_file")
-                .short("C")
-                .long("config")
-                .value_name("PATH")
-                .takes_value(true)
-                .global(true)
-                .help("Configuration file to use"),
-        )
-        .arg(
-            Arg::with_name("verbose")
-                .short("v")
-                .long("verbose")
-                .takes_value(false)
-                .global(true)
-                .help("Show additional information"),
-        )
-        .arg(
-            Arg::with_name("output_format")
-                .long("output")
-                .value_name("FORMAT")
-                .global(true)
-                .takes_value(true)
-                .possible_values(&["json", "json-compact"])
-                .help("Return information in specified output format"),
-        )
-        .arg(
-            Arg::with_name("program_id")
-                .short("p")
-                .long("program-id")
-                .value_name("ADDRESS")
-                .takes_value(true)
-                .global(true)
-                .validator(is_valid_token_program_id)
-                .help("SPL Token program id"),
-        )
-        .arg(
-            Arg::with_name("json_rpc_url")
-                .short("u")
-                .long("url")
-                .value_name("URL_OR_MONIKER")
-                .takes_value(true)
-                .global(true)
-                .validator(is_url_or_moniker)
-                .help(
-                    "URL for Solana's JSON RPC or moniker (or their first letter): \
-                       [mainnet-beta, testnet, devnet, localhost] \
-                    Default from the configuration file."
-                ),
-        )
-        .arg(fee_payer_arg().global(true))
-        .arg(
-            Arg::with_name("use_unchecked_instruction")
-                .long("use-unchecked-instruction")
-                .takes_value(false)
-                .global(true)
-                .hidden(true)
-                .help("Use unchecked instruction if appropriate. Supports transfer, burn, mint, and approve."),
-        )
-        .arg(
-            Arg::with_name(COMPUTE_UNIT_LIMIT_ARG.name)
-                .long(COMPUTE_UNIT_LIMIT_ARG.long)
-                .takes_value(true)
-                .global(true)
-                .value_name("COMPUTE-UNIT-LIMIT")
-                .validator(is_parsable::<u32>)
-                .help(COMPUTE_UNIT_LIMIT_ARG.help)
-        )
-        .arg(
-            Arg::with_name(COMPUTE_UNIT_PRICE_ARG.name)
-                .long(COMPUTE_UNIT_PRICE_ARG.long)
-                .takes_value(true)
-                .global(true)
-                .value_name("COMPUTE-UNIT-PRICE")
-                .validator(is_parsable::<u64>)
-                .help(COMPUTE_UNIT_PRICE_ARG.help)
-        )
-        .bench_subcommand()
-        .subcommand(SubCommand::with_name(CommandName::CreateToken.into()).about("Create a new token")
-                .arg(
-                    Arg::with_name("token_keypair")
-                        .value_name("TOKEN_KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .index(1)
-                        .help(
-                            "Specify the token keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             [default: randomly generated keypair]"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("mint_authority")
-                        .long("mint-authority")
-                        .alias("owner")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .help(
-                            "Specify the mint authority address. \
-                             Defaults to the client keypair address."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("decimals")
-                        .long("decimals")
-                        .validator(is_mint_decimals)
-                        .value_name("DECIMALS")
-                        .takes_value(true)
-                        .default_value(default_decimals)
-                        .help("Number of base 10 digits to the right of the decimal place"),
-                )
-                .arg(
-                    Arg::with_name("enable_freeze")
-                        .long("enable-freeze")
-                        .takes_value(false)
-                        .help(
-                            "Enable the mint authority to freeze token accounts for this mint"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("enable_close")
-                        .long("enable-close")
-                        .takes_value(false)
-                        .help(
-                            "Enable the mint authority to close this mint"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("interest_rate")
-                        .long("interest-rate")
-                        .value_name("RATE_BPS")
-                        .takes_value(true)
-                        .help(
-                            "Specify the interest rate in basis points. \
-                            Rate authority defaults to the mint authority."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("metadata_address")
-                        .long("metadata-address")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .conflicts_with("enable_metadata")
-                        .help(
-                            "Specify address that stores token metadata."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("group_address")
-                        .long("group-address")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .conflicts_with("enable_group")
-                        .help(
-                            "Specify address that stores token group configurations."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("member_address")
-                        .long("member-address")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .conflicts_with("enable_member")
-                        .help(
-                            "Specify address that stores token member configurations."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("enable_non_transferable")
-                        .long("enable-non-transferable")
-                        .alias("enable-nontransferable")
-                        .takes_value(false)
-                        .help(
-                            "Permanently force tokens to be non-transferable. They may still be burned."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("default_account_state")
-                        .long("default-account-state")
-                        .requires("enable_freeze")
-                        .takes_value(true)
-                        .possible_values(&["initialized", "frozen"])
-                        .help("Specify that accounts have a default state. \
-                            Note: specifying \"initialized\" adds an extension, which gives \
-                            the option of specifying default frozen accounts in the future. \
-                            This behavior is not the same as the default, which makes it \
-                            impossible to specify a default account state in the future."),
-                )
-                .arg(
-                    Arg::with_name("transfer_fee")
-                        .long("transfer-fee")
-                        .value_names(&["FEE_IN_BASIS_POINTS", "MAXIMUM_FEE"])
-                        .takes_value(true)
-                        .number_of_values(2)
-                        .help(
-                            "Add a transfer fee to the mint. \
-                            The mint authority can set the fee and withdraw collected fees.",
-                        ),
-                )
-                .arg(
-                    Arg::with_name("enable_permanent_delegate")
-                        .long("enable-permanent-delegate")
-                        .takes_value(false)
-                        .help(
-                            "Enable the mint authority to be permanent delegate for this mint"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("enable_confidential_transfers")
-                        .long("enable-confidential-transfers")
-                        .value_names(&["APPROVE-POLICY"])
-                        .takes_value(true)
-                        .possible_values(&["auto", "manual"])
-                        .help(
-                            "Enable accounts to make confidential transfers. If \"auto\" \
-                            is selected, then accounts are automatically approved to make \
-                            confidential transfers. If \"manual\" is selected, then the \
-                            confidential transfer mint authority must approve each account \
-                            before it can make confidential transfers."
-                        )
-                )
-                .arg(
-                    Arg::with_name("transfer_hook")
-                        .long("transfer-hook")
-                        .value_name("TRANSFER_HOOK_PROGRAM_ID")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .help("Enable the mint authority to set the transfer hook program for this mint"),
-                )
-                .arg(
-                    Arg::with_name("enable_metadata")
-                        .long("enable-metadata")
-                        .conflicts_with("metadata_address")
-                        .takes_value(false)
-                        .help("Enables metadata in the mint. The mint authority must initialize the metadata."),
-                )
-                .arg(
-                    Arg::with_name("enable_group")
-                        .long("enable-group")
-                        .conflicts_with("group_address")
-                        .takes_value(false)
-                        .help("Enables group configurations in the mint. The mint authority must initialize the group."),
-                )
-                .arg(
-                    Arg::with_name("enable_member")
-                        .long("enable-member")
-                        .conflicts_with("member_address")
-                        .takes_value(false)
-                        .help("Enables group member configurations in the mint. The mint authority must initialize the member."),
-                )
-                .nonce_args(true)
-                .arg(memo_arg())
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::SetInterestRate.into())
-                .about("Set the interest rate for an interest-bearing token")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .help("The interest-bearing token address"),
-                )
-                .arg(
-                    Arg::with_name("rate")
-                        .value_name("RATE")
-                        .takes_value(true)
-                        .required(true)
-                        .help("The new interest rate in basis points"),
-                )
-                .arg(
-                    Arg::with_name("rate_authority")
-                    .long("rate-authority")
-                    .validator(is_valid_signer)
-                    .value_name("SIGNER")
-                    .takes_value(true)
-                    .help(
-                        "Specify the rate authority keypair. \
-                        Defaults to the client keypair address."
-                    )
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::SetTransferHook.into())
-                .about("Set the transfer hook program id for a token")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address with an existing transfer hook"),
-                )
-                .arg(
-                    Arg::with_name("new_program_id")
-                        .validator(is_valid_pubkey)
-                        .value_name("NEW_PROGRAM_ID")
-                        .takes_value(true)
-                        .required_unless("disable")
-                        .index(2)
-                        .help("The new transfer hook program id to set for this mint"),
-                )
-                .arg(
-                    Arg::with_name("disable")
-                        .long("disable")
-                        .takes_value(false)
-                        .conflicts_with("new_program_id")
-                        .help("Disable transfer hook functionality by setting the program id to None.")
-                )
-                .arg(
-                    Arg::with_name("authority")
-                        .long("authority")
-                        .alias("owner")
-                        .validator(is_valid_signer)
-                        .value_name("SIGNER")
-                        .takes_value(true)
-                        .help("Specify the authority keypair. Defaults to the client keypair address.")
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::InitializeMetadata.into())
-                .about("Initialize metadata extension on a token mint")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address with no metadata present"),
-                )
-                .arg(
-                    Arg::with_name("name")
-                        .value_name("TOKEN_NAME")
-                        .takes_value(true)
-                        .required(true)
-                        .index(2)
-                        .help("The name of the token to set in metadata"),
-                )
-                .arg(
-                    Arg::with_name("symbol")
-                        .value_name("TOKEN_SYMBOL")
-                        .takes_value(true)
-                        .required(true)
-                        .index(3)
-                        .help("The symbol of the token to set in metadata"),
-                )
-                .arg(
-                    Arg::with_name("uri")
-                        .value_name("TOKEN_URI")
-                        .takes_value(true)
-                        .required(true)
-                        .index(4)
-                        .help("The URI of the token to set in metadata"),
-                )
-                .arg(
-                    Arg::with_name("mint_authority")
-                        .long("mint-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the mint authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("update_authority")
-                        .long("update-authority")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .help(
-                            "Specify the update authority address. \
-                             Defaults to the client keypair address."
-                        ),
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateMetadata.into())
-                .about("Update metadata on a token mint that has the extension")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address with no metadata present"),
-                )
-                .arg(
-                    Arg::with_name("field")
-                        .value_name("FIELD_NAME")
-                        .takes_value(true)
-                        .required(true)
-                        .index(2)
-                        .help("The name of the field to update. Can be a base field (\"name\", \"symbol\", or \"uri\") or any new field to add."),
-                )
-                .arg(
-                    Arg::with_name("value")
-                        .value_name("VALUE_STRING")
-                        .takes_value(true)
-                        .index(3)
-                        .required_unless("remove")
-                        .help("The value for the field"),
-                )
-                .arg(
-                    Arg::with_name("remove")
-                        .long("remove")
-                        .takes_value(false)
-                        .conflicts_with("value")
-                        .help("Remove the key and value for the given field. Does not work with base fields: \"name\", \"symbol\", or \"uri\".")
-                )
-                .arg(
-                    Arg::with_name("authority")
-                    .long("authority")
-                    .validator(is_valid_signer)
-                    .value_name("SIGNER")
-                    .takes_value(true)
-                    .help("Specify the metadata update authority keypair. Defaults to the client keypair.")
-                )
-                .nonce_args(true)
-                .arg(transfer_lamports_arg())
-                .offline_args_config(&SignOnlyNeedsTransferLamports{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::InitializeGroup.into())
-                .about("Initialize group extension on a token mint")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address of the group account."),
-                )
-                .arg(
-                        Arg::with_name("max_size")
-                        .validator(is_amount)
-                        .value_name("MAX_SIZE")
-                        .takes_value(true)
-                        .required(true)
-                        .index(2)
-                        .help("The number of members in the group."),
-                    )
-                .arg(
-                    Arg::with_name("mint_authority")
-                        .long("mint-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the mint authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("update_authority")
-                        .long("update-authority")
-                        .value_name("ADDRESS")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .help(
-                            "Specify the update authority address. \
-                             Defaults to the client keypair address."
-                        ),
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateGroupMaxSize.into())
-                .about("Updates the maximum number of members for a group.")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address of the group account."),
-                )
-                .arg(
-                        Arg::with_name("new_max_size")
-                        .validator(is_amount)
-                        .value_name("NEW_MAX_SIZE")
-                        .takes_value(true)
-                        .required(true)
-                        .index(2)
-                        .help("The number of members in the group."),
-                    )
-                .arg(
-                    Arg::with_name("update_authority")
-                        .long("update-authority")
-                        .value_name("SIGNER")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the update authority address. \
-                             Defaults to the client keypair address."
-                        ),
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::InitializeMember.into())
-                .about("Initialize group member extension on a token mint")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(1)
-                        .help("The token address of the member account."),
-                )
-                .arg(
-                    Arg::with_name("group_token")
-                        .validator(is_valid_pubkey)
-                        .value_name("GROUP_TOKEN_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .index(2)
-                        .help("The token address of the group account that the token will join."),
-                )
-                .arg(
-                    Arg::with_name("mint_authority")
-                        .long("mint-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the mint authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("group_update_authority")
-                        .long("group-update-authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the update authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair address."
-                        ),
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::CreateAccount.into())
-                .about("Create a new token account")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token that the account will hold"),
-                )
-                .arg(
-                    Arg::with_name("account_keypair")
-                        .value_name("ACCOUNT_KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .index(2)
-                        .help(
-                            "Specify the account keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             [default: associated token account for --owner]"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("immutable")
-                        .long("immutable")
-                        .takes_value(false)
-                        .help(
-                            "Lock the owner of this token account from ever being changed"
-                        ),
-                )
-                .arg(owner_address_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::CreateMultisig.into())
-                .about("Create a new account describing an M:N multisignature")
-                .arg(
-                    Arg::with_name("minimum_signers")
-                        .value_name("MINIMUM_SIGNERS")
-                        .validator(is_multisig_minimum_signers)
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help(minimum_signers_help),
-                )
-                .arg(
-                    Arg::with_name("multisig_member")
-                        .value_name("MULTISIG_MEMBER_PUBKEY")
-                        .validator(is_valid_pubkey)
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .min_values(MIN_SIGNERS as u64)
-                        .max_values(MAX_SIGNERS as u64)
-                        .help(multisig_member_help),
-                )
-                .arg(
-                    Arg::with_name("address_keypair")
-                        .long("address-keypair")
-                        .value_name("ADDRESS_KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the address keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             [default: randomly generated keypair]"
-                        ),
-                )
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Authorize.into())
-                .about("Authorize a new signing keypair to a token or token account")
-                .arg(
-                    Arg::with_name("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint or account"),
-                )
-                .arg(
-                    Arg::with_name("authority_type")
-                        .value_name("AUTHORITY_TYPE")
-                        .takes_value(true)
-                        .possible_values(&CliAuthorityType::iter().map(Into::into).collect::<Vec<_>>())
-                        .index(2)
-                        .required(true)
-                        .help("The new authority type. \
-                            Token mints support `mint`, `freeze`, and mint extension authorities; \
-                            Token accounts support `owner`, `close`, and account extension \
-                            authorities."),
-                )
-                .arg(
-                    Arg::with_name("new_authority")
-                        .validator(is_valid_pubkey)
-                        .value_name("AUTHORITY_ADDRESS")
-                        .takes_value(true)
-                        .index(3)
-                        .required_unless("disable")
-                        .help("The address of the new authority"),
-                )
-                .arg(
-                    Arg::with_name("authority")
-                        .long("authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the current authority keypair. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("disable")
-                        .long("disable")
-                        .takes_value(false)
-                        .conflicts_with("new_authority")
-                        .help("Disable mint, freeze, or close functionality by setting authority to None.")
-                )
-                .arg(
-                    Arg::with_name("force")
-                        .long("force")
-                        .hidden(true)
-                        .help("Force re-authorize the wallet's associate token account. Don't use this flag"),
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Transfer.into())
-                .about("Transfer tokens between accounts")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("Token to transfer"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount_or_all)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to send, in tokens; accepts keyword ALL"),
-                )
-                .arg(
-                    Arg::with_name("recipient")
-                        .validator(is_valid_pubkey)
-                        .value_name("RECIPIENT_WALLET_ADDRESS or RECIPIENT_TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(3)
-                        .required(true)
-                        .help("If a token account address is provided, use it as the recipient. \
-                               Otherwise assume the recipient address is a user wallet and transfer to \
-                               the associated token account")
-                )
-                .arg(
-                    Arg::with_name("from")
-                        .validator(is_valid_pubkey)
-                        .value_name("SENDER_TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .long("from")
-                        .help("Specify the sending token account \
-                            [default: owner's associated token account]")
-                )
-                .arg(owner_keypair_arg_with_value_name("SENDER_TOKEN_OWNER_KEYPAIR")
-                        .help(
-                            "Specify the owner of the sending token account. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(
-                    Arg::with_name("allow_unfunded_recipient")
-                        .long("allow-unfunded-recipient")
-                        .takes_value(false)
-                        .help("Complete the transfer even if the recipient address is not funded")
-                )
-                .arg(
-                    Arg::with_name("allow_empty_recipient")
-                        .long("allow-empty-recipient")
-                        .takes_value(false)
-                        .hidden(true) // Deprecated, use --allow-unfunded-recipient instead
-                )
-                .arg(
-                    Arg::with_name("fund_recipient")
-                        .long("fund-recipient")
-                        .takes_value(false)
-                        .conflicts_with("confidential")
-                        .help("Create the associated token account for the recipient if doesn't already exist")
-                )
-                .arg(
-                    Arg::with_name("no_wait")
-                        .long("no-wait")
-                        .takes_value(false)
-                        .help("Return signature immediately after submitting the transaction, instead of waiting for confirmations"),
-                )
-                .arg(
-                    Arg::with_name("allow_non_system_account_recipient")
-                        .long("allow-non-system-account-recipient")
-                        .takes_value(false)
-                        .help("Send tokens to the recipient even if the recipient is not a wallet owned by System Program."),
-                )
-                .arg(
-                    Arg::with_name("no_recipient_is_ata_owner")
-                        .long("no-recipient-is-ata-owner")
-                        .takes_value(false)
-                        .requires("sign_only")
-                        .help("In sign-only mode, specifies that the recipient is the owner of the associated token account rather than an actual token account"),
-                )
-                .arg(
-                    Arg::with_name("recipient_is_ata_owner")
-                        .long("recipient-is-ata-owner")
-                        .takes_value(false)
-                        .hidden(true)
-                        .conflicts_with("no_recipient_is_ata_owner")
-                        .requires("sign_only")
-                        .help("recipient-is-ata-owner is now the default behavior. The option has been deprecated and will be removed in a future release."),
-                )
-                .arg(
-                    Arg::with_name("expected_fee")
-                        .long("expected-fee")
-                        .validator(is_amount)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .help("Expected fee amount collected during the transfer"),
-                )
-                .arg(
-                    Arg::with_name("transfer_hook_account")
-                        .long("transfer-hook-account")
-                        .validator(validate_transfer_hook_account)
-                        .value_name("PUBKEY:ROLE")
-                        .takes_value(true)
-                        .multiple(true)
-                        .min_values(0u64)
-                        .help("Additional pubkey(s) required for a transfer hook and their \
-                            role, in the format \"<PUBKEY>:<ROLE>\". The role must be \
-                            \"readonly\", \"writable\". \"readonly-signer\", or \"writable-signer\".\
-                            Used for offline transaction creation and signing.")
-                )
-                .arg(
-                    Arg::with_name("confidential")
-                        .long("confidential")
-                        .takes_value(false)
-                        .conflicts_with("fund_recipient")
-                        .help("Send tokens confidentially. Both sender and recipient accounts must \
-                            be pre-configured for confidential transfers.")
-                )
-                .arg(multisig_signer_arg())
-                .arg(mint_decimals_arg())
-                .nonce_args(true)
-                .arg(memo_arg())
-                .offline_args_config(&SignOnlyNeedsMintDecimals{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Burn.into())
-                .about("Burn tokens from an account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token account address to burn from"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount_or_all)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to burn, in tokens; accepts keyword ALL"),
-                )
-                .arg(owner_keypair_arg_with_value_name("TOKEN_OWNER_KEYPAIR")
-                        .help(
-                            "Specify the burnt token owner account. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(multisig_signer_arg())
-                .mint_args()
-                .nonce_args(true)
-                .arg(memo_arg())
-                .offline_args_config(&SignOnlyNeedsFullMintSpec{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Mint.into())
-                .about("Mint new tokens")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token to mint"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to mint, in tokens"),
-                )
-                .arg(
-                    Arg::with_name("recipient")
-                        .validator(is_valid_pubkey)
-                        .value_name("RECIPIENT_TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("recipient_owner")
-                        .index(3)
-                        .help("The token account address of recipient \
-                            [default: associated token account for --mint-authority]"),
-                )
-                .arg(
-                    Arg::with_name("recipient_owner")
-                        .long("recipient-owner")
-                        .validator(is_valid_pubkey)
-                        .value_name("RECIPIENT_WALLET_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("recipient")
-                        .help("The owner of the recipient associated token account"),
-                )
-                .arg(
-                    Arg::with_name("mint_authority")
-                        .long("mint-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the mint authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(mint_decimals_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .arg(memo_arg())
-                .offline_args_config(&SignOnlyNeedsMintDecimals{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Freeze.into())
-                .about("Freeze a token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to freeze"),
-                )
-                .arg(
-                    Arg::with_name("freeze_authority")
-                        .long("freeze-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the freeze authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(mint_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args_config(&SignOnlyNeedsMintAddress{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Thaw.into())
-                .about("Thaw a token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to thaw"),
-                )
-                .arg(
-                    Arg::with_name("freeze_authority")
-                        .long("freeze-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the freeze authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(mint_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args_config(&SignOnlyNeedsMintAddress{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Wrap.into())
-                .about("Wrap native SOL in a SOL token account")
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount)
-                        .value_name("AMOUNT")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("Amount of SOL to wrap"),
-                )
-                .arg(
-                    Arg::with_name("wallet_keypair")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the keypair for the wallet which will have its native SOL wrapped. \
-                             This wallet will be assigned as the owner of the wrapped SOL token account. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(
-                    Arg::with_name("create_aux_account")
-                        .takes_value(false)
-                        .long("create-aux-account")
-                        .help("Wrap SOL in an auxiliary account instead of associated token account"),
-                )
-                .arg(
-                    Arg::with_name("immutable")
-                        .long("immutable")
-                        .takes_value(false)
-                        .help(
-                            "Lock the owner of this token account from ever being changed"
-                        ),
-                )
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Unwrap.into())
-                .about("Unwrap a SOL token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .help("The address of the auxiliary token account to unwrap \
-                            [default: associated token account for --owner]"),
-                )
-                .arg(
-                    Arg::with_name("wallet_keypair")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the keypair for the wallet which owns the wrapped SOL. \
-                             This wallet will receive the unwrapped SOL. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Approve.into())
-                .about("Approve a delegate for a token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to delegate"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to approve, in tokens"),
-                )
-                .arg(
-                    Arg::with_name("delegate")
-                        .validator(is_valid_pubkey)
-                        .value_name("DELEGATE_TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(3)
-                        .required(true)
-                        .help("The token account address of delegate"),
-                )
-                .arg(
-                    owner_keypair_arg()
-                )
-                .arg(multisig_signer_arg())
-                .mint_args()
-                .nonce_args(true)
-                .offline_args_config(&SignOnlyNeedsFullMintSpec{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Revoke.into())
-                .about("Revoke a delegate's authority")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account"),
-                )
-                .arg(owner_keypair_arg()
-                )
-                .arg(delegate_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args_config(&SignOnlyNeedsDelegateAddress{}),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Close.into())
-                .about("Close a token account")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("Token of the associated account to close. \
-                              To close a specific account, use the `--address` parameter instead"),
-                )
-                .arg(
-                    Arg::with_name("recipient")
-                        .long("recipient")
-                        .validator(is_valid_pubkey)
-                        .value_name("REFUND_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .help("The address of the account to receive remaining SOL [default: --owner]"),
-                )
-                .arg(
-                    Arg::with_name("close_authority")
-                        .long("close-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's close authority if it has one, \
-                            otherwise specify the token's owner keypair. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("Specify the token account to close \
-                            [default: owner's associated token account]"),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::CloseMint.into())
-                .about("Close a token mint")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("Token to close"),
-                )
-                .arg(
-                    Arg::with_name("recipient")
-                        .long("recipient")
-                        .validator(is_valid_pubkey)
-                        .value_name("REFUND_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .help("The address of the account to receive remaining SOL [default: --owner]"),
-                )
-                .arg(
-                    Arg::with_name("close_authority")
-                        .long("close-authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's close authority. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Balance.into())
-                .about("Get token account balance")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("Token of associated account. To query a specific account, use the `--address` parameter instead"),
-                )
-                .arg(owner_address_arg().conflicts_with("address"))
-                .arg(
-                    Arg::with_name("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .long("address")
-                        .conflicts_with("token")
-                        .help("Specify the token account to query \
-                            [default: owner's associated token account]"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Supply.into())
-                .about("Get token supply")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token address"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Accounts.into())
-                .about("List all token accounts by owner")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .help("Limit results to the given token. [Default: list accounts for all tokens]"),
-                )
-                .arg(
-                    Arg::with_name("delegated")
-                        .long("delegated")
-                        .takes_value(false)
-                        .conflicts_with("externally_closeable")
-                        .help(
-                            "Limit results to accounts with transfer delegations"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("externally_closeable")
-                        .long("externally-closeable")
-                        .takes_value(false)
-                        .conflicts_with("delegated")
-                        .help(
-                            "Limit results to accounts with external close authorities"
-                        ),
-                )
-                .arg(
-                    Arg::with_name("addresses_only")
-                        .long("addresses-only")
-                        .takes_value(false)
-                        .conflicts_with("verbose")
-                        .conflicts_with("output_format")
-                        .help(
-                            "Print token account addresses only"
-                        ),
-                )
-                .arg(owner_address_arg())
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Address.into())
-                .about("Get wallet address")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .long("token")
-                        .requires("verbose")
-                        .help("Return the associated token address for the given token. \
-                               [Default: return the client keypair address]")
-                )
-                .arg(
-                    owner_address_arg()
-                        .requires("token")
-                        .help("Return the associated token address for the given owner. \
-                               [Default: return the associated token address for the client keypair]"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::AccountInfo.into())
-                .about("Query details of an SPL Token account by address (DEPRECATED: use `spl-token display`)")
-                .setting(AppSettings::Hidden)
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .conflicts_with("address")
-                        .required_unless("address")
-                        .help("Token of associated account. \
-                               To query a specific account, use the `--address` parameter instead"),
-                )
-                .arg(
-                    Arg::with_name(OWNER_ADDRESS_ARG.name)
-                        .takes_value(true)
-                        .value_name("OWNER_ADDRESS")
-                        .validator(is_valid_signer)
-                        .help(OWNER_ADDRESS_ARG.help)
-                        .index(2)
-                        .conflicts_with("address")
-                        .help("Owner of the associated account for the specified token. \
-                               To query a specific account, use the `--address` parameter instead. \
-                               Defaults to the client keypair."),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .long("address")
-                        .conflicts_with("token")
-                        .help("Specify the token account to query"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::MultisigInfo.into())
-                .about("Query details of an SPL Token multisig account by address (DEPRECATED: use `spl-token display`)")
-                .setting(AppSettings::Hidden)
-                .arg(
-                    Arg::with_name("address")
-                    .validator(is_valid_pubkey)
-                    .value_name("MULTISIG_ACCOUNT_ADDRESS")
-                    .takes_value(true)
-                    .index(1)
-                    .required(true)
-                    .help("The address of the SPL Token multisig account to query"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Display.into())
-                .about("Query details of an SPL Token mint, account, or multisig by address")
-                .arg(
-                    Arg::with_name("address")
-                    .validator(is_valid_pubkey)
-                    .value_name("TOKEN_ADDRESS")
-                    .takes_value(true)
-                    .index(1)
-                    .required(true)
-                    .help("The address of the SPL Token mint, account, or multisig to query"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::Gc.into())
-                .about("Cleanup unnecessary token accounts")
-                .arg(owner_keypair_arg())
-                .arg(
-                    Arg::with_name("close_empty_associated_accounts")
-                    .long("close-empty-associated-accounts")
-                    .takes_value(false)
-                    .help("close all empty associated token accounts (to get SOL back)")
-                )
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::SyncNative.into())
-                .about("Sync a native SOL token account to its underlying lamports")
-                .arg(
-                    owner_address_arg()
-                        .index(1)
-                        .conflicts_with("address")
-                        .help("Owner of the associated account for the native token. \
-                               To query a specific account, use the `--address` parameter instead. \
-                               Defaults to the client keypair."),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .long("address")
-                        .conflicts_with("owner")
-                        .help("Specify the specific token account address to sync"),
-                ),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::EnableRequiredTransferMemos.into())
-                .about("Enable required transfer memos for token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to require transfer memos for")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::DisableRequiredTransferMemos.into())
-                .about("Disable required transfer memos for token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to stop requiring transfer memos for"),
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::EnableCpiGuard.into())
-                .about("Enable CPI Guard for token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to enable CPI Guard for")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::DisableCpiGuard.into())
-                .about("Disable CPI Guard for token account")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to disable CPI Guard for"),
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateDefaultAccountState.into())
-                .about("Updates default account state for the mint. Requires the default account state extension.")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint to update default account state"),
-                )
-                .arg(
-                    Arg::with_name("state")
-                        .value_name("STATE")
-                        .takes_value(true)
-                        .possible_values(&["initialized", "frozen"])
-                        .index(2)
-                        .required(true)
-                        .help("The new default account state."),
-                )
-                .arg(
-                    Arg::with_name("freeze_authority")
-                        .long("freeze-authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's freeze authority. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateMetadataAddress.into())
-                .about("Updates metadata pointer address for the mint. Requires the metadata pointer extension.")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint to update the metadata pointer address"),
-                )
-                .arg(
-                    Arg::with_name("metadata_address")
-                        .index(2)
-                        .validator(is_valid_pubkey)
-                        .value_name("METADATA_ADDRESS")
-                        .takes_value(true)
-                        .required_unless("disable")
-                        .help("Specify address that stores token's metadata-pointer"),
-                )
-                .arg(
-                    Arg::with_name("disable")
-                        .long("disable")
-                        .takes_value(false)
-                        .conflicts_with("metadata_address")
-                        .help("Unset metadata pointer address.")
-                )
-                .arg(
-                    Arg::with_name("authority")
-                        .long("authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's metadata-pointer authority. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateGroupAddress.into())
-                .about("Updates group pointer address for the mint. Requires the group pointer extension.")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint to update the group pointer address"),
-                )
-                .arg(
-                    Arg::with_name("group_address")
-                        .index(2)
-                        .validator(is_valid_pubkey)
-                        .value_name("GROUP_ADDRESS")
-                        .takes_value(true)
-                        .required_unless("disable")
-                        .help("Specify address that stores token's group-pointer"),
-                )
-                .arg(
-                    Arg::with_name("disable")
-                        .long("disable")
-                        .takes_value(false)
-                        .conflicts_with("group_address")
-                        .help("Unset group pointer address.")
-                )
-                .arg(
-                    Arg::with_name("authority")
-                        .long("authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's group-pointer authority. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateMemberAddress.into())
-                .about("Updates group member pointer address for the mint. Requires the group member pointer extension.")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint to update the group member pointer address"),
-                )
-                .arg(
-                    Arg::with_name("member_address")
-                        .index(2)
-                        .validator(is_valid_pubkey)
-                        .value_name("MEMBER_ADDRESS")
-                        .takes_value(true)
-                        .required_unless("disable")
-                        .help("Specify address that stores token's group-member-pointer"),
-                )
-                .arg(
-                    Arg::with_name("disable")
-                        .long("disable")
-                        .takes_value(false)
-                        .conflicts_with("member_address")
-                        .help("Unset group member pointer address.")
-                )
-                .arg(
-                    Arg::with_name("authority")
-                        .long("authority")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the token's group-member-pointer authority. \
-                            This may be a keypair file or the ASK keyword. \
-                            Defaults to the client keypair.",
-                        ),
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::WithdrawWithheldTokens.into())
-                .about("Withdraw withheld transfer fee tokens from mint and / or account(s)")
-                .arg(
-                    Arg::with_name("account")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token account to receive withdrawn tokens"),
-                )
-                .arg(
-                    Arg::with_name("source")
-                        .validator(is_valid_pubkey)
-                        .value_name("ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .multiple(true)
-                        .min_values(0u64)
-                        .help("The token accounts to withdraw from")
-                )
-                .arg(
-                    Arg::with_name("include_mint")
-                        .long("include-mint")
-                        .takes_value(false)
-                        .help("Also withdraw withheld tokens from the mint"),
-                )
-                .arg(
-                    Arg::with_name("withdraw_withheld_authority")
-                        .long("withdraw-withheld-authority")
-                        .alias("owner")
-                        .value_name("KEYPAIR")
-                        .validator(is_valid_signer)
-                        .takes_value(true)
-                        .help(
-                            "Specify the withdraw withheld authority keypair. \
-                             This may be a keypair file or the ASK keyword. \
-                             Defaults to the client keypair."
-                        ),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::SetTransferFee.into())
-                .about("Set the transfer fee for a token with a configured transfer fee")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .help("The interest-bearing token address"),
-                )
-                .arg(
-                    Arg::with_name("transfer_fee_basis_points")
-                        .value_name("FEE_IN_BASIS_POINTS")
-                        .takes_value(true)
-                        .required(true)
-                        .help("The new transfer fee in basis points"),
-                )
-                .arg(
-                    Arg::with_name("maximum_fee")
-                        .value_name("TOKEN_AMOUNT")
-                        .validator(is_amount)
-                        .takes_value(true)
-                        .required(true)
-                        .help("The new maximum transfer fee in UI amount"),
-                )
-                .arg(
-                    Arg::with_name("transfer_fee_authority")
-                    .long("transfer-fee-authority")
-                    .validator(is_valid_signer)
-                    .value_name("SIGNER")
-                    .takes_value(true)
-                    .help(
-                        "Specify the rate authority keypair. \
-                        Defaults to the client keypair address."
-                    )
-                )
-                .arg(mint_decimals_arg())
-                .offline_args_config(&SignOnlyNeedsMintDecimals{})
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::WithdrawExcessLamports.into())
-                .about("Withdraw lamports from a Token Program owned account")
-                .arg(
-                    Arg::with_name("from")
-                        .validator(is_valid_pubkey)
-                        .value_name("SOURCE_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .help("Specify the address of the account to recover lamports from"),
-                )
-                .arg(
-                    Arg::with_name("recipient")
-                        .validator(is_valid_pubkey)
-                        .value_name("REFUND_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .required(true)
-                        .help("Specify the address of the account to send lamports to"),
-                )
-                .arg(owner_address_arg())
-                .arg(multisig_signer_arg())
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::UpdateConfidentialTransferSettings.into())
-                .about("Update confidential transfer configuration for a token")
-                .arg(
-                    Arg::with_name("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The address of the token mint to update confidential transfer configuration for")
-                )
-                .arg(
-                    Arg::with_name("approve_policy")
-                        .long("approve-policy")
-                        .value_name("APPROVE_POLICY")
-                        .takes_value(true)
-                        .possible_values(&["auto", "manual"])
-                        .help(
-                            "Policy for enabling accounts to make confidential transfers. If \"auto\" \
-                            is selected, then accounts are automatically approved to make \
-                            confidential transfers. If \"manual\" is selected, then the \
-                            confidential transfer mint authority must approve each account \
-                            before it can make confidential transfers."
-                        )
-                )
-                .arg(
-                    Arg::with_name("auditor_pubkey")
-                        .long("auditor-pubkey")
-                        .value_name("AUDITOR_PUBKEY")
-                        .takes_value(true)
-                        .help(
-                            "The auditor encryption public key. The corresponding private key for \
-                            this auditor public key can be used to decrypt all confidential \
-                            transfers involving tokens from this mint. Currently, the auditor \
-                            public key can only be specified as a direct *base64* encoding of \
-                            an ElGamal public key. More methods of specifying the auditor public \
-                            key will be supported in a future version. To disable auditability \
-                            feature for the token, use \"none\"."
-                        )
-                )
-                .group(
-                    ArgGroup::with_name("update_fields").args(&["approve_policy", "auditor_pubkey"])
-                        .required(true)
-                        .multiple(true)
-                )
-                .arg(
-                    Arg::with_name("confidential_transfer_authority")
-                        .long("confidential-transfer-authority")
-                        .validator(is_valid_signer)
-                        .value_name("SIGNER")
-                        .takes_value(true)
-                        .help(
-                            "Specify the confidential transfer authority keypair. \
-                            Defaults to the client keypair address."
-                        )
-                )
-                .nonce_args(true)
-                .offline_args(),
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::ConfigureConfidentialTransferAccount.into())
-                .about("Configure confidential transfers for token account")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("The address of the token account to configure confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(
-                    Arg::with_name("maximum_pending_balance_credit_counter")
-                        .long("maximum-pending-balance-credit-counter")
-                        .value_name("MAXIMUM-CREDIT-COUNTER")
-                        .takes_value(true)
-                        .help(
-                            "The maximum pending balance credit counter. \
-                            This parameter limits the number of confidential transfers that a token account \
-                            can receive to facilitate decryption of the encrypted balance. \
-                            Defaults to 65536 (2^16)"
-                        )
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::EnableConfidentialCredits.into())
-                .about("Enable confidential transfers for token account. To enable confidential transfers \
-                for the first time, use `configure-confidential-transfer-account` instead.")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("The address of the token account to enable confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::DisableConfidentialCredits.into())
-                .about("Disable confidential transfers for token account")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("The address of the token account to disable confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::EnableNonConfidentialCredits.into())
-                .about("Enable non-confidential transfers for token account.")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("The address of the token account to enable non-confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::DisableNonConfidentialCredits.into())
-                .about("Disable non-confidential transfers for token account")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .conflicts_with("token")
-                        .help("The address of the token account to disable non-confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::DepositConfidentialTokens.into())
-                .about("Deposit amounts for confidential transfers")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount_or_all)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to deposit; accepts keyword ALL"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .help("The address of the token account to configure confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .arg(mint_decimals_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::WithdrawConfidentialTokens.into())
-                .about("Withdraw amounts for confidential transfers")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("amount")
-                        .validator(is_amount_or_all)
-                        .value_name("TOKEN_AMOUNT")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("Amount to deposit; accepts keyword ALL"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .help("The address of the token account to configure confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .arg(mint_decimals_arg())
-                .nonce_args(true)
-        )
-        .subcommand(
-            SubCommand::with_name(CommandName::ApplyPendingBalance.into())
-                .about("Collect confidential tokens from pending to available balance")
-                .arg(
-                    Arg::with_name("token")
-                        .long("token")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(1)
-                        .required_unless("address")
-                        .help("The token address with confidential transfers enabled"),
-                )
-                .arg(
-                    Arg::with_name("address")
-                        .long("address")
-                        .validator(is_valid_pubkey)
-                        .value_name("TOKEN_ACCOUNT_ADDRESS")
-                        .takes_value(true)
-                        .help("The address of the token account to configure confidential transfers for \
-                            [default: owner's associated token account]")
-                )
-                .arg(
-                    owner_address_arg()
-                )
-                .arg(multisig_signer_arg())
-                .nonce_args(true)
-        )
-}
diff --git a/token/cli/src/command.rs b/token/cli/src/command.rs
deleted file mode 100644
index 980408d74c7..00000000000
--- a/token/cli/src/command.rs
+++ /dev/null
@@ -1,4616 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-use {
-    crate::{
-        bench::*,
-        clap_app::*,
-        config::{Config, MintInfo},
-        encryption_keypair::*,
-        output::*,
-        sort::{sort_and_parse_token_accounts, AccountFilter},
-    },
-    clap::{value_t, value_t_or_exit, ArgMatches},
-    futures::try_join,
-    serde::Serialize,
-    solana_account_decoder::{
-        parse_token::{get_token_account_mint, parse_token, TokenAccountType, UiAccountState},
-        UiAccountData,
-    },
-    solana_clap_utils::{
-        input_parsers::{pubkey_of_signer, pubkeys_of_multiple_signers, value_of},
-        keypair::signer_from_path,
-    },
-    solana_cli_output::{
-        return_signers_data, CliSignOnlyData, CliSignature, OutputFormat, QuietDisplay,
-        ReturnSignersConfig, VerboseDisplay,
-    },
-    solana_client::rpc_request::TokenAccountsFilter,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        instruction::AccountMeta,
-        native_token::*,
-        program_option::COption,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_program,
-    },
-    spl_associated_token_account::get_associated_token_address_with_program_id,
-    spl_token_2022::{
-        extension::{
-            confidential_transfer::{
-                account_info::{
-                    ApplyPendingBalanceAccountInfo, TransferAccountInfo, WithdrawAccountInfo,
-                },
-                instruction::TransferSplitContextStateAccounts,
-                ConfidentialTransferAccount, ConfidentialTransferMint,
-            },
-            confidential_transfer_fee::ConfidentialTransferFeeConfig,
-            cpi_guard::CpiGuard,
-            default_account_state::DefaultAccountState,
-            group_member_pointer::GroupMemberPointer,
-            group_pointer::GroupPointer,
-            interest_bearing_mint::InterestBearingConfig,
-            memo_transfer::MemoTransfer,
-            metadata_pointer::MetadataPointer,
-            mint_close_authority::MintCloseAuthority,
-            permanent_delegate::PermanentDelegate,
-            transfer_fee::{TransferFeeAmount, TransferFeeConfig},
-            transfer_hook::TransferHook,
-            BaseStateWithExtensions, ExtensionType, StateWithExtensionsOwned,
-        },
-        solana_zk_token_sdk::{
-            encryption::{
-                auth_encryption::AeKey,
-                elgamal::{self, ElGamalKeypair},
-            },
-            zk_token_elgamal::pod::ElGamalPubkey,
-        },
-        state::{Account, AccountState, Mint},
-    },
-    spl_token_client::{
-        client::{ProgramRpcClientSendTransaction, RpcClientResponse},
-        token::{ComputeUnitLimit, ExtensionInitializationParams, Token},
-    },
-    spl_token_group_interface::state::TokenGroup,
-    spl_token_metadata_interface::state::{Field, TokenMetadata},
-    std::{collections::HashMap, fmt::Display, process::exit, rc::Rc, str::FromStr, sync::Arc},
-};
-
-fn print_error_and_exit<T, E: Display>(e: E) -> T {
-    eprintln!("error: {}", e);
-    exit(1)
-}
-
-type BulkSigners = Vec<Arc<dyn Signer>>;
-pub type CommandResult = Result<String, Error>;
-
-fn push_signer_with_dedup(signer: Arc<dyn Signer>, bulk_signers: &mut BulkSigners) {
-    if !bulk_signers.contains(&signer) {
-        bulk_signers.push(signer);
-    }
-}
-
-fn new_throwaway_signer() -> (Arc<dyn Signer>, Pubkey) {
-    let keypair = Keypair::new();
-    let pubkey = keypair.pubkey();
-    (Arc::new(keypair) as Arc<dyn Signer>, pubkey)
-}
-
-fn get_signer(
-    matches: &ArgMatches<'_>,
-    keypair_name: &str,
-    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-) -> Option<(Arc<dyn Signer>, Pubkey)> {
-    matches.value_of(keypair_name).map(|path| {
-        let signer = signer_from_path(matches, path, keypair_name, wallet_manager)
-            .unwrap_or_else(print_error_and_exit);
-        let signer_pubkey = signer.pubkey();
-        (Arc::from(signer), signer_pubkey)
-    })
-}
-
-fn parse_amount_or_all(matches: &ArgMatches<'_>) -> Option<f64> {
-    match matches.value_of("amount").unwrap() {
-        "ALL" => None,
-        amount => Some(amount.parse::<f64>().unwrap()),
-    }
-}
-
-async fn check_wallet_balance(
-    config: &Config<'_>,
-    wallet: &Pubkey,
-    required_balance: u64,
-) -> Result<(), Error> {
-    let balance = config.rpc_client.get_balance(wallet).await?;
-    if balance < required_balance {
-        Err(format!(
-            "Wallet {}, has insufficient balance: {} required, {} available",
-            wallet,
-            lamports_to_sol(required_balance),
-            lamports_to_sol(balance)
-        )
-        .into())
-    } else {
-        Ok(())
-    }
-}
-
-fn base_token_client(
-    config: &Config<'_>,
-    token_pubkey: &Pubkey,
-    decimals: Option<u8>,
-) -> Result<Token<ProgramRpcClientSendTransaction>, Error> {
-    Ok(Token::new(
-        config.program_client.clone(),
-        &config.program_id,
-        token_pubkey,
-        decimals,
-        config.fee_payer()?.clone(),
-    ))
-}
-
-fn config_token_client(
-    token: Token<ProgramRpcClientSendTransaction>,
-    config: &Config<'_>,
-) -> Result<Token<ProgramRpcClientSendTransaction>, Error> {
-    let token = token.with_compute_unit_limit(config.compute_unit_limit.clone());
-
-    let token = if let Some(compute_unit_price) = config.compute_unit_price {
-        token.with_compute_unit_price(compute_unit_price)
-    } else {
-        token
-    };
-
-    if let (Some(nonce_account), Some(nonce_authority), Some(nonce_blockhash)) = (
-        config.nonce_account,
-        &config.nonce_authority,
-        config.nonce_blockhash,
-    ) {
-        Ok(token.with_nonce(
-            &nonce_account,
-            Arc::clone(nonce_authority),
-            &nonce_blockhash,
-        ))
-    } else {
-        Ok(token)
-    }
-}
-
-fn token_client_from_config(
-    config: &Config<'_>,
-    token_pubkey: &Pubkey,
-    decimals: Option<u8>,
-) -> Result<Token<ProgramRpcClientSendTransaction>, Error> {
-    let token = base_token_client(config, token_pubkey, decimals)?;
-    config_token_client(token, config)
-}
-
-fn native_token_client_from_config(
-    config: &Config<'_>,
-) -> Result<Token<ProgramRpcClientSendTransaction>, Error> {
-    let token = Token::new_native(
-        config.program_client.clone(),
-        &config.program_id,
-        config.fee_payer()?.clone(),
-    );
-
-    if let (Some(nonce_account), Some(nonce_authority), Some(nonce_blockhash)) = (
-        config.nonce_account,
-        &config.nonce_authority,
-        config.nonce_blockhash,
-    ) {
-        Ok(token.with_nonce(
-            &nonce_account,
-            Arc::clone(nonce_authority),
-            &nonce_blockhash,
-        ))
-    } else {
-        Ok(token)
-    }
-}
-
-#[derive(strum_macros::Display, Debug)]
-#[strum(serialize_all = "kebab-case")]
-enum Pointer {
-    Metadata,
-    Group,
-    GroupMember,
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_create_token(
-    config: &Config<'_>,
-    decimals: u8,
-    token_pubkey: Pubkey,
-    authority: Pubkey,
-    enable_freeze: bool,
-    enable_close: bool,
-    enable_non_transferable: bool,
-    enable_permanent_delegate: bool,
-    memo: Option<String>,
-    metadata_address: Option<Pubkey>,
-    group_address: Option<Pubkey>,
-    member_address: Option<Pubkey>,
-    rate_bps: Option<i16>,
-    default_account_state: Option<AccountState>,
-    transfer_fee: Option<(u16, u64)>,
-    confidential_transfer_auto_approve: Option<bool>,
-    transfer_hook_program_id: Option<Pubkey>,
-    enable_metadata: bool,
-    enable_group: bool,
-    enable_member: bool,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    println_display(
-        config,
-        format!(
-            "Creating token {} under program {}",
-            token_pubkey, config.program_id
-        ),
-    );
-
-    let token = token_client_from_config(config, &token_pubkey, Some(decimals))?;
-
-    let freeze_authority = if enable_freeze { Some(authority) } else { None };
-
-    let mut extensions = vec![];
-
-    if enable_close {
-        extensions.push(ExtensionInitializationParams::MintCloseAuthority {
-            close_authority: Some(authority),
-        });
-    }
-
-    if enable_permanent_delegate {
-        extensions.push(ExtensionInitializationParams::PermanentDelegate {
-            delegate: authority,
-        });
-    }
-
-    if let Some(rate_bps) = rate_bps {
-        extensions.push(ExtensionInitializationParams::InterestBearingConfig {
-            rate_authority: Some(authority),
-            rate: rate_bps,
-        })
-    }
-
-    if enable_non_transferable {
-        extensions.push(ExtensionInitializationParams::NonTransferable);
-    }
-
-    if let Some(state) = default_account_state {
-        assert!(
-            enable_freeze,
-            "Token requires a freeze authority to default to frozen accounts"
-        );
-        extensions.push(ExtensionInitializationParams::DefaultAccountState { state })
-    }
-
-    if let Some((transfer_fee_basis_points, maximum_fee)) = transfer_fee {
-        extensions.push(ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(authority),
-            withdraw_withheld_authority: Some(authority),
-            transfer_fee_basis_points,
-            maximum_fee,
-        });
-    }
-
-    if let Some(auto_approve) = confidential_transfer_auto_approve {
-        extensions.push(ExtensionInitializationParams::ConfidentialTransferMint {
-            authority: Some(authority),
-            auto_approve_new_accounts: auto_approve,
-            auditor_elgamal_pubkey: None,
-        });
-        if transfer_fee.is_some() {
-            // Deriving ElGamal key from default signer. Custom ElGamal keys
-            // will be supported in the future once upgrading to clap-v3.
-            //
-            // NOTE: Seed bytes are hardcoded to be empty bytes for now. They
-            // will be updated once custom ElGamal keys are supported.
-            let elgamal_keypair =
-                ElGamalKeypair::new_from_signer(config.default_signer()?.as_ref(), b"").unwrap();
-            extensions.push(
-                ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                    authority: Some(authority),
-                    withdraw_withheld_authority_elgamal_pubkey: (*elgamal_keypair.pubkey()).into(),
-                },
-            );
-        }
-    }
-
-    if let Some(program_id) = transfer_hook_program_id {
-        extensions.push(ExtensionInitializationParams::TransferHook {
-            authority: Some(authority),
-            program_id: Some(program_id),
-        });
-    }
-
-    if let Some(text) = memo {
-        token.with_memo(text, vec![config.default_signer()?.pubkey()]);
-    }
-
-    // CLI checks that only one is set
-    if metadata_address.is_some() || enable_metadata {
-        let metadata_address = if enable_metadata {
-            Some(token_pubkey)
-        } else {
-            metadata_address
-        };
-        extensions.push(ExtensionInitializationParams::MetadataPointer {
-            authority: Some(authority),
-            metadata_address,
-        });
-    }
-
-    if group_address.is_some() || enable_group {
-        let group_address = if enable_group {
-            Some(token_pubkey)
-        } else {
-            group_address
-        };
-        extensions.push(ExtensionInitializationParams::GroupPointer {
-            authority: Some(authority),
-            group_address,
-        });
-    }
-
-    if member_address.is_some() || enable_member {
-        let member_address = if enable_member {
-            Some(token_pubkey)
-        } else {
-            member_address
-        };
-        extensions.push(ExtensionInitializationParams::GroupMemberPointer {
-            authority: Some(authority),
-            member_address,
-        });
-    }
-
-    let res = token
-        .create_mint(
-            &authority,
-            freeze_authority.as_ref(),
-            extensions,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-
-    if enable_metadata {
-        println_display(
-            config,
-            format!(
-                "To initialize metadata inside the mint, please run \
-                `spl-token initialize-metadata {token_pubkey} <YOUR_TOKEN_NAME> <YOUR_TOKEN_SYMBOL> <YOUR_TOKEN_URI>`, \
-                and sign with the mint authority.",
-            ),
-        );
-    }
-
-    if enable_group {
-        println_display(
-            config,
-            format!(
-                "To initialize group configurations inside the mint, please run `spl-token initialize-group {token_pubkey} <MAX_SIZE>`, and sign with the mint authority.",
-            ),
-        );
-    }
-
-    if enable_member {
-        println_display(
-            config,
-            format!(
-                "To initialize group member configurations inside the mint, please run `spl-token initialize-member {token_pubkey}`, and sign with the mint authority and the group's update authority.",
-            ),
-        );
-    }
-
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(cli_signature) => format_output(
-            CliCreateToken {
-                address: token_pubkey.to_string(),
-                decimals,
-                transaction_data: cli_signature,
-            },
-            &CommandName::CreateToken,
-            config,
-        ),
-        TransactionReturnData::CliSignOnlyData(cli_sign_only_data) => {
-            format_output(cli_sign_only_data, &CommandName::CreateToken, config)
-        }
-    })
-}
-
-async fn command_set_interest_rate(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    rate_authority: Pubkey,
-    rate_bps: i16,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let mut token = token_client_from_config(config, &token_pubkey, None)?;
-    // Because set_interest_rate depends on the time, it can cost more between
-    // simulation and execution. To help that, just set a static compute limit
-    // if none has been set
-    if !matches!(config.compute_unit_limit, ComputeUnitLimit::Static(_)) {
-        token = token.with_compute_unit_limit(ComputeUnitLimit::Static(2_500));
-    }
-
-    if !config.sign_only {
-        let mint_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-            .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-
-        if let Ok(interest_rate_config) = mint_state.get_extension::<InterestBearingConfig>() {
-            let mint_rate_authority_pubkey =
-                Option::<Pubkey>::from(interest_rate_config.rate_authority);
-
-            if mint_rate_authority_pubkey != Some(rate_authority) {
-                return Err(format!(
-                    "Mint {} has interest rate authority {}, but {} was provided",
-                    token_pubkey,
-                    mint_rate_authority_pubkey
-                        .map(|pubkey| pubkey.to_string())
-                        .unwrap_or_else(|| "disabled".to_string()),
-                    rate_authority
-                )
-                .into());
-            }
-        } else {
-            return Err(format!("Mint {} is not interest-bearing", token_pubkey).into());
-        }
-    }
-
-    println_display(
-        config,
-        format!(
-            "Setting Interest Rate for {} to {} bps",
-            token_pubkey, rate_bps
-        ),
-    );
-
-    let res = token
-        .update_interest_rate(&rate_authority, rate_bps, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_set_transfer_hook_program(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    authority: Pubkey,
-    new_program_id: Option<Pubkey>,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-
-    if !config.sign_only {
-        let mint_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-            .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-
-        if let Ok(extension) = mint_state.get_extension::<TransferHook>() {
-            let authority_pubkey = Option::<Pubkey>::from(extension.authority);
-
-            if authority_pubkey != Some(authority) {
-                return Err(format!(
-                    "Mint {} has transfer hook authority {}, but {} was provided",
-                    token_pubkey,
-                    authority_pubkey
-                        .map(|pubkey| pubkey.to_string())
-                        .unwrap_or_else(|| "disabled".to_string()),
-                    authority
-                )
-                .into());
-            }
-        } else {
-            return Err(
-                format!("Mint {} does not have permissioned-transfers", token_pubkey).into(),
-            );
-        }
-    }
-
-    println_display(
-        config,
-        format!(
-            "Setting Transfer Hook Program id for {} to {}",
-            token_pubkey,
-            new_program_id
-                .map(|pubkey| pubkey.to_string())
-                .unwrap_or_else(|| "disabled".to_string())
-        ),
-    );
-
-    let res = token
-        .update_transfer_hook_program_id(&authority, new_program_id, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_initialize_metadata(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    update_authority: Pubkey,
-    mint_authority: Pubkey,
-    name: String,
-    symbol: String,
-    uri: String,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-
-    let res = token
-        .token_metadata_initialize_with_rent_transfer(
-            &config.fee_payer()?.pubkey(),
-            &update_authority,
-            &mint_authority,
-            name,
-            symbol,
-            uri,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_update_metadata(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    authority: Pubkey,
-    field: Field,
-    value: Option<String>,
-    transfer_lamports: Option<u64>,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-
-    let res = if let Some(value) = value {
-        token
-            .token_metadata_update_field_with_rent_transfer(
-                &config.fee_payer()?.pubkey(),
-                &authority,
-                field,
-                value,
-                transfer_lamports,
-                &bulk_signers,
-            )
-            .await?
-    } else if let Field::Key(key) = field {
-        token
-            .token_metadata_remove_key(
-                &authority,
-                key,
-                true, // idempotent
-                &bulk_signers,
-            )
-            .await?
-    } else {
-        return Err(format!(
-            "Attempting to remove field {field:?}, which cannot be removed. \
-            Please re-run the command with a value of \"\" rather than the `--remove` flag."
-        )
-        .into());
-    };
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_initialize_group(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    mint_authority: Pubkey,
-    update_authority: Pubkey,
-    max_size: u32,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-
-    let res = token
-        .token_group_initialize_with_rent_transfer(
-            &config.fee_payer()?.pubkey(),
-            &mint_authority,
-            &update_authority,
-            max_size,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_update_group_max_size(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    update_authority: Pubkey,
-    new_max_size: u32,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-
-    let res = token
-        .token_group_update_max_size(&update_authority, new_max_size, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_initialize_member(
-    config: &Config<'_>,
-    member_token_pubkey: Pubkey,
-    mint_authority: Pubkey,
-    group_token_pubkey: Pubkey,
-    group_update_authority: Pubkey,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &member_token_pubkey, None)?;
-
-    let res = token
-        .token_group_initialize_member_with_rent_transfer(
-            &config.fee_payer()?.pubkey(),
-            &mint_authority,
-            &group_token_pubkey,
-            &group_update_authority,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_set_transfer_fee(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    transfer_fee_authority: Pubkey,
-    transfer_fee_basis_points: u16,
-    maximum_fee: f64,
-    mint_decimals: Option<u8>,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let decimals = if !config.sign_only {
-        let mint_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-            .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-
-        if mint_decimals.is_some() && mint_decimals != Some(mint_state.base.decimals) {
-            return Err(format!(
-                "Decimals {} was provided, but actual value is {}",
-                mint_decimals.unwrap(),
-                mint_state.base.decimals
-            )
-            .into());
-        }
-
-        if let Ok(transfer_fee_config) = mint_state.get_extension::<TransferFeeConfig>() {
-            let mint_fee_authority_pubkey =
-                Option::<Pubkey>::from(transfer_fee_config.transfer_fee_config_authority);
-
-            if mint_fee_authority_pubkey != Some(transfer_fee_authority) {
-                return Err(format!(
-                    "Mint {} has transfer fee authority {}, but {} was provided",
-                    token_pubkey,
-                    mint_fee_authority_pubkey
-                        .map(|pubkey| pubkey.to_string())
-                        .unwrap_or_else(|| "disabled".to_string()),
-                    transfer_fee_authority
-                )
-                .into());
-            }
-        } else {
-            return Err(format!("Mint {} does not have a transfer fee", token_pubkey).into());
-        }
-        mint_state.base.decimals
-    } else {
-        mint_decimals.unwrap()
-    };
-
-    println_display(
-        config,
-        format!(
-            "Setting transfer fee for {} to {} bps, {} maximum",
-            token_pubkey, transfer_fee_basis_points, maximum_fee
-        ),
-    );
-
-    let token = token_client_from_config(config, &token_pubkey, Some(decimals))?;
-    let maximum_fee = spl_token::ui_amount_to_amount(maximum_fee, decimals);
-    let res = token
-        .set_transfer_fee(
-            &transfer_fee_authority,
-            transfer_fee_basis_points,
-            maximum_fee,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_create_account(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    owner: Pubkey,
-    maybe_account: Option<Pubkey>,
-    immutable_owner: bool,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let mut extensions = vec![];
-
-    let (account, is_associated) = if let Some(account) = maybe_account {
-        (
-            account,
-            token.get_associated_token_address(&owner) == account,
-        )
-    } else {
-        (token.get_associated_token_address(&owner), true)
-    };
-
-    println_display(config, format!("Creating account {}", account));
-
-    if !config.sign_only {
-        if let Some(account_data) = config.program_client.get_account(account).await? {
-            if account_data.owner != system_program::id() || !is_associated {
-                return Err(format!("Error: Account already exists: {}", account).into());
-            }
-        }
-    }
-
-    if immutable_owner {
-        if config.program_id == spl_token::id() {
-            return Err(format!(
-                "Specified --immutable, but token program {} does not support the extension",
-                config.program_id
-            )
-            .into());
-        } else if is_associated {
-            println_display(
-                config,
-                "Note: --immutable specified, but Token-2022 ATAs are always immutable, ignoring"
-                    .to_string(),
-            );
-        } else {
-            extensions.push(ExtensionType::ImmutableOwner);
-        }
-    }
-
-    let res = if is_associated {
-        token.create_associated_token_account(&owner).await
-    } else {
-        let signer = bulk_signers
-            .iter()
-            .find(|signer| signer.pubkey() == account)
-            .unwrap_or_else(|| panic!("No signer provided for account {}", account));
-
-        token
-            .create_auxiliary_token_account_with_extension_space(&**signer, &owner, extensions)
-            .await
-    }?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_create_multisig(
-    config: &Config<'_>,
-    multisig: Arc<dyn Signer>,
-    minimum_signers: u8,
-    multisig_members: Vec<Pubkey>,
-) -> CommandResult {
-    println_display(
-        config,
-        format!(
-            "Creating {}/{} multisig {} under program {}",
-            minimum_signers,
-            multisig_members.len(),
-            multisig.pubkey(),
-            config.program_id,
-        ),
-    );
-
-    // default is safe here because create_multisig doesn't use it
-    let token = token_client_from_config(config, &Pubkey::default(), None)?;
-
-    let res = token
-        .create_multisig(
-            &*multisig,
-            &multisig_members.iter().collect::<Vec<_>>(),
-            minimum_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_authorize(
-    config: &Config<'_>,
-    account: Pubkey,
-    authority_type: CliAuthorityType,
-    authority: Pubkey,
-    new_authority: Option<Pubkey>,
-    force_authorize: bool,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let auth_str: &'static str = (&authority_type).into();
-
-    let (mint_pubkey, previous_authority) = if !config.sign_only {
-        let target_account = config.get_account_checked(&account).await?;
-
-        let (mint_pubkey, previous_authority) = if let Ok(mint) =
-            StateWithExtensionsOwned::<Mint>::unpack(target_account.data.clone())
-        {
-            let previous_authority = match authority_type {
-                CliAuthorityType::Owner | CliAuthorityType::Close => Err(format!(
-                    "Authority type `{}` not supported for SPL Token mints",
-                    auth_str
-                )),
-                CliAuthorityType::Mint => Ok(Option::<Pubkey>::from(mint.base.mint_authority)),
-                CliAuthorityType::Freeze => Ok(Option::<Pubkey>::from(mint.base.freeze_authority)),
-                CliAuthorityType::CloseMint => {
-                    if let Ok(mint_close_authority) = mint.get_extension::<MintCloseAuthority>() {
-                        Ok(Option::<Pubkey>::from(mint_close_authority.close_authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support close authority",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::TransferFeeConfig => {
-                    if let Ok(transfer_fee_config) = mint.get_extension::<TransferFeeConfig>() {
-                        Ok(Option::<Pubkey>::from(
-                            transfer_fee_config.transfer_fee_config_authority,
-                        ))
-                    } else {
-                        Err(format!("Mint `{}` does not support transfer fees", account))
-                    }
-                }
-                CliAuthorityType::WithheldWithdraw => {
-                    if let Ok(transfer_fee_config) = mint.get_extension::<TransferFeeConfig>() {
-                        Ok(Option::<Pubkey>::from(
-                            transfer_fee_config.withdraw_withheld_authority,
-                        ))
-                    } else {
-                        Err(format!("Mint `{}` does not support transfer fees", account))
-                    }
-                }
-                CliAuthorityType::InterestRate => {
-                    if let Ok(interest_rate_config) = mint.get_extension::<InterestBearingConfig>()
-                    {
-                        Ok(Option::<Pubkey>::from(interest_rate_config.rate_authority))
-                    } else {
-                        Err(format!("Mint `{}` is not interest-bearing", account))
-                    }
-                }
-                CliAuthorityType::PermanentDelegate => {
-                    if let Ok(permanent_delegate) = mint.get_extension::<PermanentDelegate>() {
-                        Ok(Option::<Pubkey>::from(permanent_delegate.delegate))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support permanent delegate",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::ConfidentialTransferMint => {
-                    if let Ok(confidential_transfer_mint) =
-                        mint.get_extension::<ConfidentialTransferMint>()
-                    {
-                        Ok(Option::<Pubkey>::from(confidential_transfer_mint.authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support confidential transfers",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::TransferHookProgramId => {
-                    if let Ok(extension) = mint.get_extension::<TransferHook>() {
-                        Ok(Option::<Pubkey>::from(extension.authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support a transfer hook program",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::ConfidentialTransferFee => {
-                    if let Ok(confidential_transfer_fee_config) =
-                        mint.get_extension::<ConfidentialTransferFeeConfig>()
-                    {
-                        Ok(Option::<Pubkey>::from(
-                            confidential_transfer_fee_config.authority,
-                        ))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support confidential transfer fees",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::MetadataPointer => {
-                    if let Ok(extension) = mint.get_extension::<MetadataPointer>() {
-                        Ok(Option::<Pubkey>::from(extension.authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support a metadata pointer",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::Metadata => {
-                    if let Ok(extension) = mint.get_variable_len_extension::<TokenMetadata>() {
-                        Ok(Option::<Pubkey>::from(extension.update_authority))
-                    } else {
-                        Err(format!("Mint `{account}` does not support metadata"))
-                    }
-                }
-                CliAuthorityType::GroupPointer => {
-                    if let Ok(extension) = mint.get_extension::<GroupPointer>() {
-                        Ok(Option::<Pubkey>::from(extension.authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support a group pointer",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::GroupMemberPointer => {
-                    if let Ok(extension) = mint.get_extension::<GroupMemberPointer>() {
-                        Ok(Option::<Pubkey>::from(extension.authority))
-                    } else {
-                        Err(format!(
-                            "Mint `{}` does not support a group member pointer",
-                            account
-                        ))
-                    }
-                }
-                CliAuthorityType::Group => {
-                    if let Ok(extension) = mint.get_extension::<TokenGroup>() {
-                        Ok(Option::<Pubkey>::from(extension.update_authority))
-                    } else {
-                        Err(format!("Mint `{}` does not support token groups", account))
-                    }
-                }
-            }?;
-
-            Ok((account, previous_authority))
-        } else if let Ok(token_account) =
-            StateWithExtensionsOwned::<Account>::unpack(target_account.data)
-        {
-            let check_associated_token_account = || -> Result<(), Error> {
-                let maybe_associated_token_account = get_associated_token_address_with_program_id(
-                    &token_account.base.owner,
-                    &token_account.base.mint,
-                    &config.program_id,
-                );
-                if account == maybe_associated_token_account
-                    && !force_authorize
-                    && Some(authority) != new_authority
-                {
-                    Err(format!(
-                        "Error: attempting to change the `{}` of an associated token account",
-                        auth_str
-                    )
-                    .into())
-                } else {
-                    Ok(())
-                }
-            };
-
-            let previous_authority = match authority_type {
-                CliAuthorityType::Mint
-                | CliAuthorityType::Freeze
-                | CliAuthorityType::CloseMint
-                | CliAuthorityType::TransferFeeConfig
-                | CliAuthorityType::WithheldWithdraw
-                | CliAuthorityType::InterestRate
-                | CliAuthorityType::PermanentDelegate
-                | CliAuthorityType::ConfidentialTransferMint
-                | CliAuthorityType::TransferHookProgramId
-                | CliAuthorityType::ConfidentialTransferFee
-                | CliAuthorityType::MetadataPointer
-                | CliAuthorityType::Metadata
-                | CliAuthorityType::GroupPointer
-                | CliAuthorityType::Group
-                | CliAuthorityType::GroupMemberPointer => Err(format!(
-                    "Authority type `{auth_str}` not supported for SPL Token accounts",
-                )),
-                CliAuthorityType::Owner => {
-                    check_associated_token_account()?;
-                    Ok(Some(token_account.base.owner))
-                }
-                CliAuthorityType::Close => {
-                    check_associated_token_account()?;
-                    Ok(Some(
-                        token_account
-                            .base
-                            .close_authority
-                            .unwrap_or(token_account.base.owner),
-                    ))
-                }
-            }?;
-
-            Ok((token_account.base.mint, previous_authority))
-        } else {
-            Err("Unsupported account data format".to_string())
-        }?;
-
-        (mint_pubkey, previous_authority)
-    } else {
-        // default is safe here because authorize doesn't use it
-        (Pubkey::default(), None)
-    };
-
-    let token = token_client_from_config(config, &mint_pubkey, None)?;
-
-    println_display(
-        config,
-        format!(
-            "Updating {}\n  Current {}: {}\n  New {}: {}",
-            account,
-            auth_str,
-            previous_authority
-                .map(|pubkey| pubkey.to_string())
-                .unwrap_or_else(|| if config.sign_only {
-                    "unknown".to_string()
-                } else {
-                    "disabled".to_string()
-                }),
-            auth_str,
-            new_authority
-                .map(|pubkey| pubkey.to_string())
-                .unwrap_or_else(|| "disabled".to_string())
-        ),
-    );
-
-    let res = match authority_type {
-        CliAuthorityType::Metadata => {
-            token
-                .token_metadata_update_authority(&authority, new_authority, &bulk_signers)
-                .await?
-        }
-        CliAuthorityType::Group => {
-            token
-                .token_group_update_authority(&authority, new_authority, &bulk_signers)
-                .await?
-        }
-        _ => {
-            token
-                .set_authority(
-                    &account,
-                    &authority,
-                    new_authority.as_ref(),
-                    authority_type.try_into()?,
-                    &bulk_signers,
-                )
-                .await?
-        }
-    };
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_transfer(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    ui_amount: Option<f64>,
-    recipient: Pubkey,
-    sender: Option<Pubkey>,
-    sender_owner: Pubkey,
-    allow_unfunded_recipient: bool,
-    fund_recipient: bool,
-    mint_decimals: Option<u8>,
-    no_recipient_is_ata_owner: bool,
-    use_unchecked_instruction: bool,
-    ui_fee: Option<f64>,
-    memo: Option<String>,
-    bulk_signers: BulkSigners,
-    no_wait: bool,
-    allow_non_system_account_recipient: bool,
-    transfer_hook_accounts: Option<Vec<AccountMeta>>,
-    confidential_transfer_args: Option<&ConfidentialTransferArgs>,
-) -> CommandResult {
-    let mint_info = config.get_mint_info(&token_pubkey, mint_decimals).await?;
-
-    // if the user got the decimals wrong, they may well have calculated the
-    // transfer amount wrong we only check in online mode, because in offline,
-    // mint_info.decimals is always 9
-    if !config.sign_only && mint_decimals.is_some() && mint_decimals != Some(mint_info.decimals) {
-        return Err(format!(
-            "Decimals {} was provided, but actual value is {}",
-            mint_decimals.unwrap(),
-            mint_info.decimals
-        )
-        .into());
-    }
-
-    // decimals determines whether transfer_checked is used or not
-    // in online mode, mint_decimals may be None but mint_info.decimals is always
-    // correct in offline mode, mint_info.decimals may be wrong, but
-    // mint_decimals is always provided and in online mode, when mint_decimals
-    // is provided, it is verified correct hence the fallthrough logic here
-    let decimals = if use_unchecked_instruction {
-        None
-    } else if mint_decimals.is_some() {
-        mint_decimals
-    } else {
-        Some(mint_info.decimals)
-    };
-
-    let token = if let Some(transfer_hook_accounts) = transfer_hook_accounts {
-        token_client_from_config(config, &token_pubkey, decimals)?
-            .with_transfer_hook_accounts(transfer_hook_accounts)
-    } else if config.sign_only {
-        // we need to pass in empty transfer hook accounts on sign-only,
-        // otherwise the token client will try to fetch the mint account and fail
-        token_client_from_config(config, &token_pubkey, decimals)?
-            .with_transfer_hook_accounts(vec![])
-    } else {
-        token_client_from_config(config, &token_pubkey, decimals)?
-    };
-
-    // pubkey of the actual account we are sending from
-    let sender = if let Some(sender) = sender {
-        sender
-    } else {
-        token.get_associated_token_address(&sender_owner)
-    };
-
-    // the amount the user wants to transfer, as a f64
-    let maybe_transfer_balance =
-        ui_amount.map(|ui_amount| spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals));
-
-    // the amount we will transfer, as a u64
-    let transfer_balance = if !config.sign_only {
-        let sender_balance = token.get_account_info(&sender).await?.base.amount;
-        let transfer_balance = maybe_transfer_balance.unwrap_or(sender_balance);
-
-        println_display(
-            config,
-            format!(
-                "{}Transfer {} tokens\n  Sender: {}\n  Recipient: {}",
-                if confidential_transfer_args.is_some() {
-                    "Confidential "
-                } else {
-                    ""
-                },
-                spl_token::amount_to_ui_amount(transfer_balance, mint_info.decimals),
-                sender,
-                recipient
-            ),
-        );
-
-        if transfer_balance > sender_balance && confidential_transfer_args.is_none() {
-            return Err(format!(
-                "Error: Sender has insufficient funds, current balance is {}",
-                spl_token_2022::amount_to_ui_amount_string_trimmed(
-                    sender_balance,
-                    mint_info.decimals
-                )
-            )
-            .into());
-        }
-
-        transfer_balance
-    } else {
-        maybe_transfer_balance.unwrap()
-    };
-
-    let maybe_fee =
-        ui_fee.map(|ui_amount| spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals));
-
-    // determine whether recipient is a token account or an expected owner of one
-    let recipient_is_token_account = if !config.sign_only {
-        // in online mode we can fetch it and see
-        let maybe_recipient_account_data = config.program_client.get_account(recipient).await?;
-
-        // if the account exists, and:
-        // * its a token for this program, we are happy
-        // * its a system account, we are happy
-        // * its a non-account for this program, we error helpfully
-        // * its a token account for a different program, we error helpfully
-        // * otherwise its probably a program account owner of an ata, in which case we
-        //   gate transfer with a flag
-        if let Some(recipient_account_data) = maybe_recipient_account_data {
-            let recipient_account_owner = recipient_account_data.owner;
-            let maybe_account_state =
-                StateWithExtensionsOwned::<Account>::unpack(recipient_account_data.data);
-
-            if recipient_account_owner == config.program_id && maybe_account_state.is_ok() {
-                if let Ok(memo_transfer) = maybe_account_state?.get_extension::<MemoTransfer>() {
-                    if memo_transfer.require_incoming_transfer_memos.into() && memo.is_none() {
-                        return Err(
-                            "Error: Recipient expects a transfer memo, but none was provided. \
-                                    Provide a memo using `--with-memo`."
-                                .into(),
-                        );
-                    }
-                }
-
-                true
-            } else if recipient_account_owner == system_program::id() {
-                false
-            } else if recipient_account_owner == config.program_id {
-                return Err(
-                    "Error: Recipient is owned by this token program, but is not a token account."
-                        .into(),
-                );
-            } else if VALID_TOKEN_PROGRAM_IDS.contains(&recipient_account_owner) {
-                return Err(format!(
-                    "Error: Recipient is owned by {}, but the token mint is owned by {}.",
-                    recipient_account_owner, config.program_id
-                )
-                .into());
-            } else if allow_non_system_account_recipient {
-                false
-            } else {
-                return Err("Error: The recipient address is not owned by the System Program. \
-                                     Add `--allow-non-system-account-recipient` to complete the transfer.".into());
-            }
-        }
-        // if it doesn't exist, it definitely isn't a token account!
-        // we gate transfer with a different flag
-        else if maybe_recipient_account_data.is_none() && allow_unfunded_recipient {
-            false
-        } else {
-            return Err("Error: The recipient address is not funded. \
-                        Add `--allow-unfunded-recipient` to complete the transfer."
-                .into());
-        }
-    } else {
-        // in offline mode we gotta trust them
-        no_recipient_is_ata_owner
-    };
-
-    // now if its a token account, life is ez
-    let (recipient_token_account, fundable_owner) = if recipient_is_token_account {
-        (recipient, None)
-    }
-    // but if not, we need to determine if we can or should create an ata for recipient
-    else {
-        // first, get the ata address
-        let recipient_token_account = token.get_associated_token_address(&recipient);
-
-        println_display(
-            config,
-            format!(
-                "  Recipient associated token account: {}",
-                recipient_token_account
-            ),
-        );
-
-        // if we can fetch it to determine if it exists, do so
-        let needs_funding = if !config.sign_only {
-            if let Some(recipient_token_account_data) = config
-                .program_client
-                .get_account(recipient_token_account)
-                .await?
-            {
-                let recipient_token_account_owner = recipient_token_account_data.owner;
-
-                if let Ok(account_state) =
-                    StateWithExtensionsOwned::<Account>::unpack(recipient_token_account_data.data)
-                {
-                    if let Ok(memo_transfer) = account_state.get_extension::<MemoTransfer>() {
-                        if memo_transfer.require_incoming_transfer_memos.into() && memo.is_none() {
-                            return Err(
-                                "Error: Recipient expects a transfer memo, but none was provided. \
-                                        Provide a memo using `--with-memo`."
-                                    .into(),
-                            );
-                        }
-                    }
-                }
-
-                if recipient_token_account_owner == system_program::id() {
-                    true
-                } else if recipient_token_account_owner == config.program_id {
-                    false
-                } else {
-                    return Err(
-                        format!("Error: Unsupported recipient address: {}", recipient).into(),
-                    );
-                }
-            } else {
-                true
-            }
-        }
-        // otherwise trust the cli flag
-        else {
-            fund_recipient
-        };
-
-        // and now we determine if we will actually fund it, based on its need and our
-        // willingness
-        let fundable_owner = if needs_funding {
-            if confidential_transfer_args.is_some() {
-                return Err(
-                    "Error: Recipient's associated token account does not exist. \
-                        Accounts cannot be funded for confidential transfers."
-                        .into(),
-                );
-            } else if fund_recipient {
-                println_display(
-                    config,
-                    format!("  Funding recipient: {}", recipient_token_account,),
-                );
-
-                Some(recipient)
-            } else {
-                return Err(
-                    "Error: Recipient's associated token account does not exist. \
-                                    Add `--fund-recipient` to fund their account"
-                        .into(),
-                );
-            }
-        } else {
-            None
-        };
-
-        (recipient_token_account, fundable_owner)
-    };
-
-    // set up memo if provided...
-    if let Some(text) = memo {
-        token.with_memo(text, vec![config.default_signer()?.pubkey()]);
-    }
-
-    // fetch confidential transfer info for recipient and auditor
-    let (recipient_elgamal_pubkey, auditor_elgamal_pubkey) = if let Some(args) =
-        confidential_transfer_args
-    {
-        if !config.sign_only {
-            // we can use the mint data from the start of the function, but will require
-            // non-trivial amount of refactoring the code due to ownership; for now, we
-            // fetch the mint a second time. This can potentially be optimized
-            // in the future.
-            let confidential_transfer_mint = config.get_account_checked(&token_pubkey).await?;
-            let mint_state =
-                StateWithExtensionsOwned::<Mint>::unpack(confidential_transfer_mint.data)
-                    .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-
-            let auditor_elgamal_pubkey = if let Ok(confidential_transfer_mint) =
-                mint_state.get_extension::<ConfidentialTransferMint>()
-            {
-                let expected_auditor_elgamal_pubkey = Option::<ElGamalPubkey>::from(
-                    confidential_transfer_mint.auditor_elgamal_pubkey,
-                );
-
-                // if auditor ElGamal pubkey is provided, check consistency with the one in the
-                // mint if auditor ElGamal pubkey is not provided, then use the
-                // expected one from the   mint, which could also be `None` if
-                // auditing is disabled
-                if args.auditor_elgamal_pubkey.is_some()
-                    && expected_auditor_elgamal_pubkey != args.auditor_elgamal_pubkey
-                {
-                    return Err(format!(
-                        "Mint {} has confidential transfer auditor {}, but {} was provided",
-                        token_pubkey,
-                        expected_auditor_elgamal_pubkey
-                            .map(|pubkey| pubkey.to_string())
-                            .unwrap_or_else(|| "disabled".to_string()),
-                        args.auditor_elgamal_pubkey.unwrap(),
-                    )
-                    .into());
-                }
-
-                expected_auditor_elgamal_pubkey
-            } else {
-                return Err(format!(
-                    "Mint {} does not support confidential transfers",
-                    token_pubkey
-                )
-                .into());
-            };
-
-            let recipient_account = config.get_account_checked(&recipient_token_account).await?;
-            let recipient_elgamal_pubkey =
-                StateWithExtensionsOwned::<Account>::unpack(recipient_account.data)?
-                    .get_extension::<ConfidentialTransferAccount>()?
-                    .elgamal_pubkey;
-
-            (Some(recipient_elgamal_pubkey), auditor_elgamal_pubkey)
-        } else {
-            let recipient_elgamal_pubkey = args
-                .recipient_elgamal_pubkey
-                .expect("Recipient ElGamal pubkey must be provided");
-            let auditor_elgamal_pubkey = args
-                .auditor_elgamal_pubkey
-                .expect("Auditor ElGamal pubkey must be provided");
-
-            (Some(recipient_elgamal_pubkey), Some(auditor_elgamal_pubkey))
-        }
-    } else {
-        (None, None)
-    };
-
-    // ...and, finally, the transfer
-    let res = match (fundable_owner, maybe_fee, confidential_transfer_args) {
-        (Some(recipient_owner), None, None) => {
-            token
-                .create_recipient_associated_account_and_transfer(
-                    &sender,
-                    &recipient_token_account,
-                    &recipient_owner,
-                    &sender_owner,
-                    transfer_balance,
-                    maybe_fee,
-                    &bulk_signers,
-                )
-                .await?
-        }
-        (Some(_), _, _) => {
-            panic!("Recipient account cannot be created for transfer with fees or confidential transfers");
-        }
-        (None, Some(fee), None) => {
-            token
-                .transfer_with_fee(
-                    &sender,
-                    &recipient_token_account,
-                    &sender_owner,
-                    transfer_balance,
-                    fee,
-                    &bulk_signers,
-                )
-                .await?
-        }
-        (None, None, Some(args)) => {
-            // deserialize `pod` ElGamal pubkeys
-            let recipient_elgamal_pubkey: elgamal::ElGamalPubkey = recipient_elgamal_pubkey
-                .unwrap()
-                .try_into()
-                .expect("Invalid recipient ElGamal pubkey");
-            let auditor_elgamal_pubkey = auditor_elgamal_pubkey.map(|pubkey| {
-                let auditor_elgamal_pubkey: elgamal::ElGamalPubkey =
-                    pubkey.try_into().expect("Invalid auditor ElGamal pubkey");
-                auditor_elgamal_pubkey
-            });
-
-            let context_state_authority = config.fee_payer()?;
-            let equality_proof_context_state_account = Keypair::new();
-            let equality_proof_pubkey = equality_proof_context_state_account.pubkey();
-            let ciphertext_validity_proof_context_state_account = Keypair::new();
-            let ciphertext_validity_proof_pubkey =
-                ciphertext_validity_proof_context_state_account.pubkey();
-            let range_proof_context_state_account = Keypair::new();
-            let range_proof_pubkey = range_proof_context_state_account.pubkey();
-
-            let transfer_context_state_accounts = TransferSplitContextStateAccounts {
-                equality_proof: &equality_proof_pubkey,
-                ciphertext_validity_proof: &ciphertext_validity_proof_pubkey,
-                range_proof: &range_proof_pubkey,
-                authority: &context_state_authority.pubkey(),
-                no_op_on_uninitialized_split_context_state: false,
-                close_split_context_state_accounts: None,
-            };
-
-            let state = token.get_account_info(&sender).await.unwrap();
-            let extension = state
-                .get_extension::<ConfidentialTransferAccount>()
-                .unwrap();
-            let transfer_account_info = TransferAccountInfo::new(extension);
-
-            let (
-                equality_proof_data,
-                ciphertext_validity_proof_data,
-                range_proof_data,
-                source_decrypt_handles,
-            ) = transfer_account_info
-                .generate_split_transfer_proof_data(
-                    transfer_balance,
-                    &args.sender_elgamal_keypair,
-                    &args.sender_aes_key,
-                    &recipient_elgamal_pubkey,
-                    auditor_elgamal_pubkey.as_ref(),
-                )
-                .unwrap();
-
-            // setup proofs
-            let _ = try_join!(
-                token.create_range_proof_context_state_for_transfer(
-                    transfer_context_state_accounts,
-                    &range_proof_data,
-                    &range_proof_context_state_account,
-                ),
-                token.create_equality_proof_context_state_for_transfer(
-                    transfer_context_state_accounts,
-                    &equality_proof_data,
-                    &equality_proof_context_state_account,
-                ),
-                token.create_ciphertext_validity_proof_context_state_for_transfer(
-                    transfer_context_state_accounts,
-                    &ciphertext_validity_proof_data,
-                    &ciphertext_validity_proof_context_state_account,
-                )
-            )?;
-
-            // do the transfer
-            let transfer_result = token
-                .confidential_transfer_transfer_with_split_proofs(
-                    &sender,
-                    &recipient_token_account,
-                    &sender_owner,
-                    transfer_context_state_accounts,
-                    transfer_balance,
-                    Some(transfer_account_info),
-                    &args.sender_aes_key,
-                    &source_decrypt_handles,
-                    &bulk_signers,
-                )
-                .await?;
-
-            // close context state accounts
-            let context_state_authority_pubkey = context_state_authority.pubkey();
-            let close_context_state_signers = &[context_state_authority];
-            let _ = try_join!(
-                token.confidential_transfer_close_context_state(
-                    &equality_proof_pubkey,
-                    &sender,
-                    &context_state_authority_pubkey,
-                    close_context_state_signers,
-                ),
-                token.confidential_transfer_close_context_state(
-                    &ciphertext_validity_proof_pubkey,
-                    &sender,
-                    &context_state_authority_pubkey,
-                    close_context_state_signers,
-                ),
-                token.confidential_transfer_close_context_state(
-                    &range_proof_pubkey,
-                    &sender,
-                    &context_state_authority_pubkey,
-                    close_context_state_signers,
-                ),
-            )?;
-
-            transfer_result
-        }
-        (None, Some(_), Some(_)) => {
-            panic!("Confidential transfer with fee is not yet supported.");
-        }
-        (None, None, None) => {
-            token
-                .transfer(
-                    &sender,
-                    &recipient_token_account,
-                    &sender_owner,
-                    transfer_balance,
-                    &bulk_signers,
-                )
-                .await?
-        }
-    };
-
-    let tx_return = finish_tx(config, &res, no_wait).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_burn(
-    config: &Config<'_>,
-    account: Pubkey,
-    owner: Pubkey,
-    ui_amount: Option<f64>,
-    mint_address: Option<Pubkey>,
-    mint_decimals: Option<u8>,
-    use_unchecked_instruction: bool,
-    memo: Option<String>,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let mint_address = config.check_account(&account, mint_address).await?;
-    let mint_info = config.get_mint_info(&mint_address, mint_decimals).await?;
-    let decimals = if use_unchecked_instruction {
-        None
-    } else {
-        Some(mint_info.decimals)
-    };
-
-    let token = token_client_from_config(config, &mint_info.address, decimals)?;
-
-    let amount = if let Some(ui_amount) = ui_amount {
-        spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals)
-    } else {
-        if config.sign_only {
-            return Err("Use of ALL keyword to burn tokens requires online signing"
-                .to_string()
-                .into());
-        }
-        token.get_account_info(&account).await?.base.amount
-    };
-
-    println_display(
-        config,
-        format!(
-            "Burn {} tokens\n  Source: {}",
-            spl_token::amount_to_ui_amount(amount, mint_info.decimals),
-            account
-        ),
-    );
-
-    if let Some(text) = memo {
-        token.with_memo(text, vec![config.default_signer()?.pubkey()]);
-    }
-
-    let res = token.burn(&account, &owner, amount, &bulk_signers).await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_mint(
-    config: &Config<'_>,
-    token: Pubkey,
-    ui_amount: f64,
-    recipient: Pubkey,
-    mint_info: MintInfo,
-    mint_authority: Pubkey,
-    use_unchecked_instruction: bool,
-    memo: Option<String>,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    println_display(
-        config,
-        format!(
-            "Minting {} tokens\n  Token: {}\n  Recipient: {}",
-            ui_amount, token, recipient
-        ),
-    );
-
-    let amount = spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals);
-    let decimals = if use_unchecked_instruction {
-        None
-    } else {
-        Some(mint_info.decimals)
-    };
-
-    let token = token_client_from_config(config, &mint_info.address, decimals)?;
-    if let Some(text) = memo {
-        token.with_memo(text, vec![config.default_signer()?.pubkey()]);
-    }
-
-    let res = token
-        .mint_to(&recipient, &mint_authority, amount, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_freeze(
-    config: &Config<'_>,
-    account: Pubkey,
-    mint_address: Option<Pubkey>,
-    freeze_authority: Pubkey,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let mint_address = config.check_account(&account, mint_address).await?;
-    let mint_info = config.get_mint_info(&mint_address, None).await?;
-
-    println_display(
-        config,
-        format!(
-            "Freezing account: {}\n  Token: {}",
-            account, mint_info.address
-        ),
-    );
-
-    // we dont use the decimals from mint_info because its not need and in sign-only
-    // its wrong
-    let token = token_client_from_config(config, &mint_info.address, None)?;
-    let res = token
-        .freeze(&account, &freeze_authority, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_thaw(
-    config: &Config<'_>,
-    account: Pubkey,
-    mint_address: Option<Pubkey>,
-    freeze_authority: Pubkey,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let mint_address = config.check_account(&account, mint_address).await?;
-    let mint_info = config.get_mint_info(&mint_address, None).await?;
-
-    println_display(
-        config,
-        format!(
-            "Thawing account: {}\n  Token: {}",
-            account, mint_info.address
-        ),
-    );
-
-    // we dont use the decimals from mint_info because its not need and in sign-only
-    // its wrong
-    let token = token_client_from_config(config, &mint_info.address, None)?;
-    let res = token
-        .thaw(&account, &freeze_authority, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_wrap(
-    config: &Config<'_>,
-    sol: f64,
-    wallet_address: Pubkey,
-    wrapped_sol_account: Option<Pubkey>,
-    immutable_owner: bool,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let lamports = sol_to_lamports(sol);
-    let token = native_token_client_from_config(config)?;
-
-    let account =
-        wrapped_sol_account.unwrap_or_else(|| token.get_associated_token_address(&wallet_address));
-
-    println_display(config, format!("Wrapping {} SOL into {}", sol, account));
-
-    if !config.sign_only {
-        if let Some(account_data) = config.program_client.get_account(account).await? {
-            if account_data.owner != system_program::id() {
-                return Err(format!("Error: Account already exists: {}", account).into());
-            }
-        }
-
-        check_wallet_balance(config, &wallet_address, lamports).await?;
-    }
-
-    let res = if immutable_owner {
-        if config.program_id == spl_token::id() {
-            return Err(format!(
-                "Specified --immutable, but token program {} does not support the extension",
-                config.program_id
-            )
-            .into());
-        }
-
-        token
-            .wrap(&account, &wallet_address, lamports, &bulk_signers)
-            .await?
-    } else {
-        // this case is hit for a token22 ata, which is always immutable. but it does
-        // the right thing anyway
-        token
-            .wrap_with_mutable_ownership(&account, &wallet_address, lamports, &bulk_signers)
-            .await?
-    };
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_unwrap(
-    config: &Config<'_>,
-    wallet_address: Pubkey,
-    maybe_account: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let use_associated_account = maybe_account.is_none();
-    let token = native_token_client_from_config(config)?;
-
-    let account =
-        maybe_account.unwrap_or_else(|| token.get_associated_token_address(&wallet_address));
-
-    println_display(config, format!("Unwrapping {}", account));
-
-    if !config.sign_only {
-        let account_data = config.get_account_checked(&account).await?;
-
-        if !use_associated_account {
-            let account_state = StateWithExtensionsOwned::<Account>::unpack(account_data.data)?;
-
-            if account_state.base.mint != *token.get_address() {
-                return Err(format!("{} is not a native token account", account).into());
-            }
-        }
-
-        if account_data.lamports == 0 {
-            if use_associated_account {
-                return Err("No wrapped SOL in associated account; did you mean to specify an auxiliary address?".to_string().into());
-            } else {
-                return Err(format!("No wrapped SOL in {}", account).into());
-            }
-        }
-
-        println_display(
-            config,
-            format!("  Amount: {} SOL", lamports_to_sol(account_data.lamports)),
-        );
-    }
-
-    println_display(config, format!("  Recipient: {}", &wallet_address));
-
-    let res = token
-        .close_account(&account, &wallet_address, &wallet_address, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_approve(
-    config: &Config<'_>,
-    account: Pubkey,
-    owner: Pubkey,
-    ui_amount: f64,
-    delegate: Pubkey,
-    mint_address: Option<Pubkey>,
-    mint_decimals: Option<u8>,
-    use_unchecked_instruction: bool,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    println_display(
-        config,
-        format!(
-            "Approve {} tokens\n  Account: {}\n  Delegate: {}",
-            ui_amount, account, delegate
-        ),
-    );
-
-    let mint_address = config.check_account(&account, mint_address).await?;
-    let mint_info = config.get_mint_info(&mint_address, mint_decimals).await?;
-    let amount = spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals);
-    let decimals = if use_unchecked_instruction {
-        None
-    } else {
-        Some(mint_info.decimals)
-    };
-
-    let token = token_client_from_config(config, &mint_info.address, decimals)?;
-    let res = token
-        .approve(&account, &delegate, &owner, amount, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_revoke(
-    config: &Config<'_>,
-    account: Pubkey,
-    owner: Pubkey,
-    delegate: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let (mint_pubkey, delegate) = if !config.sign_only {
-        let source_account = config.get_account_checked(&account).await?;
-        let source_state = StateWithExtensionsOwned::<Account>::unpack(source_account.data)
-            .map_err(|_| format!("Could not deserialize token account {}", account))?;
-
-        let delegate = if let COption::Some(delegate) = source_state.base.delegate {
-            Some(delegate)
-        } else {
-            None
-        };
-
-        (source_state.base.mint, delegate)
-    } else {
-        // default is safe here because revoke doesn't use it
-        (Pubkey::default(), delegate)
-    };
-
-    if let Some(delegate) = delegate {
-        println_display(
-            config,
-            format!(
-                "Revoking approval\n  Account: {}\n  Delegate: {}",
-                account, delegate
-            ),
-        );
-    } else {
-        return Err(format!("No delegate on account {}", account).into());
-    }
-
-    let token = token_client_from_config(config, &mint_pubkey, None)?;
-    let res = token.revoke(&account, &owner, &bulk_signers).await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_close(
-    config: &Config<'_>,
-    account: Pubkey,
-    close_authority: Pubkey,
-    recipient: Pubkey,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    let mut results = vec![];
-    let token = if !config.sign_only {
-        let source_account = config.get_account_checked(&account).await?;
-
-        let source_state = StateWithExtensionsOwned::<Account>::unpack(source_account.data)
-            .map_err(|_| format!("Could not deserialize token account {}", account))?;
-        let source_amount = source_state.base.amount;
-
-        if !source_state.base.is_native() && source_amount > 0 {
-            return Err(format!(
-                "Account {} still has {} tokens; empty the account in order to close it.",
-                account, source_amount,
-            )
-            .into());
-        }
-
-        let token = token_client_from_config(config, &source_state.base.mint, None)?;
-        if let Ok(extension) = source_state.get_extension::<TransferFeeAmount>() {
-            if u64::from(extension.withheld_amount) != 0 {
-                let res = token.harvest_withheld_tokens_to_mint(&[&account]).await?;
-                let tx_return = finish_tx(config, &res, false).await?;
-                results.push(match tx_return {
-                    TransactionReturnData::CliSignature(signature) => {
-                        config.output_format.formatted_string(&signature)
-                    }
-                    TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-                        config.output_format.formatted_string(&sign_only_data)
-                    }
-                });
-            }
-        }
-
-        token
-    } else {
-        // default is safe here because close doesn't use it
-        token_client_from_config(config, &Pubkey::default(), None)?
-    };
-
-    let res = token
-        .close_account(&account, &recipient, &close_authority, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    results.push(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    });
-    Ok(results.join(""))
-}
-
-async fn command_close_mint(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    close_authority: Pubkey,
-    recipient: Pubkey,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    if !config.sign_only {
-        let mint_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-            .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-        let mint_supply = mint_state.base.supply;
-
-        if mint_supply > 0 {
-            return Err(format!(
-                "Mint {} still has {} outstanding tokens; these must be burned before closing the mint.",
-                token_pubkey, mint_supply,
-            )
-            .into());
-        }
-
-        if let Ok(mint_close_authority) = mint_state.get_extension::<MintCloseAuthority>() {
-            let mint_close_authority_pubkey =
-                Option::<Pubkey>::from(mint_close_authority.close_authority);
-
-            if mint_close_authority_pubkey != Some(close_authority) {
-                return Err(format!(
-                    "Mint {} has close authority {}, but {} was provided",
-                    token_pubkey,
-                    mint_close_authority_pubkey
-                        .map(|pubkey| pubkey.to_string())
-                        .unwrap_or_else(|| "disabled".to_string()),
-                    close_authority
-                )
-                .into());
-            }
-        } else {
-            return Err(format!("Mint {} does not support close authority", token_pubkey).into());
-        }
-    }
-
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let res = token
-        .close_account(&token_pubkey, &recipient, &close_authority, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_balance(config: &Config<'_>, address: Pubkey) -> CommandResult {
-    let balance = config
-        .rpc_client
-        .get_token_account_balance(&address)
-        .await
-        .map_err(|_| format!("Could not find token account {}", address))?;
-    let cli_token_amount = CliTokenAmount { amount: balance };
-    Ok(config.output_format.formatted_string(&cli_token_amount))
-}
-
-async fn command_supply(config: &Config<'_>, token: Pubkey) -> CommandResult {
-    let supply = config.rpc_client.get_token_supply(&token).await?;
-    let cli_token_amount = CliTokenAmount { amount: supply };
-    Ok(config.output_format.formatted_string(&cli_token_amount))
-}
-
-async fn command_accounts(
-    config: &Config<'_>,
-    maybe_token: Option<Pubkey>,
-    owner: Pubkey,
-    account_filter: AccountFilter,
-    print_addresses_only: bool,
-) -> CommandResult {
-    let filters = if let Some(token_pubkey) = maybe_token {
-        let _ = config.get_mint_info(&token_pubkey, None).await?;
-        vec![TokenAccountsFilter::Mint(token_pubkey)]
-    } else if config.restrict_to_program_id {
-        vec![TokenAccountsFilter::ProgramId(config.program_id)]
-    } else {
-        vec![
-            TokenAccountsFilter::ProgramId(spl_token::id()),
-            TokenAccountsFilter::ProgramId(spl_token_2022::id()),
-        ]
-    };
-
-    let mut accounts = vec![];
-    for filter in filters {
-        accounts.push(
-            config
-                .rpc_client
-                .get_token_accounts_by_owner(&owner, filter)
-                .await?,
-        );
-    }
-    let accounts = accounts.into_iter().flatten().collect();
-
-    let cli_token_accounts =
-        sort_and_parse_token_accounts(&owner, accounts, maybe_token.is_some(), account_filter)?;
-
-    if print_addresses_only {
-        Ok(cli_token_accounts
-            .accounts
-            .into_iter()
-            .flatten()
-            .map(|a| a.address)
-            .collect::<Vec<_>>()
-            .join("\n"))
-    } else {
-        Ok(config.output_format.formatted_string(&cli_token_accounts))
-    }
-}
-
-async fn command_address(
-    config: &Config<'_>,
-    token: Option<Pubkey>,
-    owner: Pubkey,
-) -> CommandResult {
-    let mut cli_address = CliWalletAddress {
-        wallet_address: owner.to_string(),
-        ..CliWalletAddress::default()
-    };
-    if let Some(token) = token {
-        config.get_mint_info(&token, None).await?;
-        let associated_token_address =
-            get_associated_token_address_with_program_id(&owner, &token, &config.program_id);
-        cli_address.associated_token_address = Some(associated_token_address.to_string());
-    }
-    Ok(config.output_format.formatted_string(&cli_address))
-}
-
-async fn command_display(config: &Config<'_>, address: Pubkey) -> CommandResult {
-    let account_data = config.get_account_checked(&address).await?;
-
-    let (decimals, has_permanent_delegate) =
-        if let Some(mint_address) = get_token_account_mint(&account_data.data) {
-            let mint_account = config.get_account_checked(&mint_address).await?;
-            let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-                .map_err(|_| format!("Could not deserialize token mint {}", mint_address))?;
-
-            let has_permanent_delegate =
-                if let Ok(permanent_delegate) = mint_state.get_extension::<PermanentDelegate>() {
-                    Option::<Pubkey>::from(permanent_delegate.delegate).is_some()
-                } else {
-                    false
-                };
-
-            (Some(mint_state.base.decimals), has_permanent_delegate)
-        } else {
-            (None, false)
-        };
-
-    let token_data = parse_token(&account_data.data, decimals);
-
-    match token_data {
-        Ok(TokenAccountType::Account(account)) => {
-            let mint_address = Pubkey::from_str(&account.mint)?;
-            let owner = Pubkey::from_str(&account.owner)?;
-            let associated_address = get_associated_token_address_with_program_id(
-                &owner,
-                &mint_address,
-                &config.program_id,
-            );
-
-            let cli_output = CliTokenAccount {
-                address: address.to_string(),
-                program_id: config.program_id.to_string(),
-                is_associated: associated_address == address,
-                account,
-                has_permanent_delegate,
-            };
-
-            Ok(config.output_format.formatted_string(&cli_output))
-        }
-        Ok(TokenAccountType::Mint(mint)) => {
-            let epoch_info = config.rpc_client.get_epoch_info().await?;
-            let cli_output = CliMint {
-                address: address.to_string(),
-                epoch: epoch_info.epoch,
-                program_id: config.program_id.to_string(),
-                mint,
-            };
-
-            Ok(config.output_format.formatted_string(&cli_output))
-        }
-        Ok(TokenAccountType::Multisig(multisig)) => {
-            let cli_output = CliMultisig {
-                address: address.to_string(),
-                program_id: config.program_id.to_string(),
-                multisig,
-            };
-
-            Ok(config.output_format.formatted_string(&cli_output))
-        }
-        Err(e) => Err(e.into()),
-    }
-}
-
-async fn command_gc(
-    config: &Config<'_>,
-    owner: Pubkey,
-    close_empty_associated_accounts: bool,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    println_display(
-        config,
-        format!(
-            "Fetching token accounts associated with program {}",
-            config.program_id
-        ),
-    );
-    let accounts = config
-        .rpc_client
-        .get_token_accounts_by_owner(&owner, TokenAccountsFilter::ProgramId(config.program_id))
-        .await?;
-    if accounts.is_empty() {
-        println_display(config, "Nothing to do".to_string());
-        return Ok("".to_string());
-    }
-
-    let mut accounts_by_token = HashMap::new();
-
-    for keyed_account in accounts {
-        if let UiAccountData::Json(parsed_account) = keyed_account.account.data {
-            if let Ok(TokenAccountType::Account(ui_token_account)) =
-                serde_json::from_value(parsed_account.parsed)
-            {
-                let frozen = ui_token_account.state == UiAccountState::Frozen;
-                let decimals = ui_token_account.token_amount.decimals;
-
-                let token = ui_token_account
-                    .mint
-                    .parse::<Pubkey>()
-                    .unwrap_or_else(|err| panic!("Invalid mint: {}", err));
-                let token_account = keyed_account
-                    .pubkey
-                    .parse::<Pubkey>()
-                    .unwrap_or_else(|err| panic!("Invalid token account: {}", err));
-                let token_amount = ui_token_account
-                    .token_amount
-                    .amount
-                    .parse::<u64>()
-                    .unwrap_or_else(|err| panic!("Invalid token amount: {}", err));
-
-                let close_authority = ui_token_account.close_authority.map_or(owner, |s| {
-                    s.parse::<Pubkey>()
-                        .unwrap_or_else(|err| panic!("Invalid close authority: {}", err))
-                });
-
-                let entry = accounts_by_token
-                    .entry((token, decimals))
-                    .or_insert_with(HashMap::new);
-                entry.insert(token_account, (token_amount, frozen, close_authority));
-            }
-        }
-    }
-
-    let mut results = vec![];
-    for ((token_pubkey, decimals), accounts) in accounts_by_token.into_iter() {
-        println_display(config, format!("Processing token: {}", token_pubkey));
-
-        let token = token_client_from_config(config, &token_pubkey, Some(decimals))?;
-        let total_balance: u64 = accounts.values().map(|account| account.0).sum();
-
-        let associated_token_account = token.get_associated_token_address(&owner);
-        if !accounts.contains_key(&associated_token_account) && total_balance > 0 {
-            token.create_associated_token_account(&owner).await?;
-        }
-
-        for (address, (amount, frozen, close_authority)) in accounts {
-            let is_associated = address == associated_token_account;
-
-            // only close the associated account if --close-empty-associated-accounts is
-            // provided
-            if is_associated && !close_empty_associated_accounts {
-                continue;
-            }
-
-            // never close the associated account if *any* account carries a balance
-            if is_associated && total_balance > 0 {
-                continue;
-            }
-
-            // dont attempt to close frozen accounts
-            if frozen {
-                continue;
-            }
-
-            if is_associated {
-                println!("Closing associated account {}", address);
-            }
-
-            // this logic is quite fiendish, but its more readable this way than if/else
-            let maybe_res = match (close_authority == owner, is_associated, amount == 0) {
-                // owner authority, associated or auxiliary, empty -> close
-                (true, _, true) => Some(
-                    token
-                        .close_account(&address, &owner, &owner, &bulk_signers)
-                        .await,
-                ),
-                // owner authority, auxiliary, nonempty -> empty and close
-                (true, false, false) => Some(
-                    token
-                        .empty_and_close_account(
-                            &address,
-                            &owner,
-                            &associated_token_account,
-                            &owner,
-                            &bulk_signers,
-                        )
-                        .await,
-                ),
-                // separate authority, auxiliary, nonempty -> transfer
-                (false, false, false) => Some(
-                    token
-                        .transfer(
-                            &address,
-                            &associated_token_account,
-                            &owner,
-                            amount,
-                            &bulk_signers,
-                        )
-                        .await,
-                ),
-                // separate authority, associated or auxiliary, empty -> print warning
-                (false, _, true) => {
-                    println_display(
-                        config,
-                        format!(
-                            "Note: skipping {} due to separate close authority {}; \
-                             revoke authority and rerun gc, or rerun gc with --owner",
-                            address, close_authority
-                        ),
-                    );
-                    None
-                }
-                // anything else, including a nonempty associated account -> unreachable
-                (_, _, _) => unreachable!(),
-            };
-
-            if let Some(res) = maybe_res {
-                let tx_return = finish_tx(config, &res?, false).await?;
-
-                results.push(match tx_return {
-                    TransactionReturnData::CliSignature(signature) => {
-                        config.output_format.formatted_string(&signature)
-                    }
-                    TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-                        config.output_format.formatted_string(&sign_only_data)
-                    }
-                });
-            };
-        }
-    }
-
-    Ok(results.join(""))
-}
-
-async fn command_sync_native(config: &Config<'_>, native_account_address: Pubkey) -> CommandResult {
-    let token = native_token_client_from_config(config)?;
-
-    if !config.sign_only {
-        let account_data = config.get_account_checked(&native_account_address).await?;
-        let account_state = StateWithExtensionsOwned::<Account>::unpack(account_data.data)?;
-
-        if account_state.base.mint != *token.get_address() {
-            return Err(format!("{} is not a native token account", native_account_address).into());
-        }
-    }
-
-    let res = token.sync_native(&native_account_address).await?;
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_withdraw_excess_lamports(
-    config: &Config<'_>,
-    source_account: Pubkey,
-    destination_account: Pubkey,
-    authority: Pubkey,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    // default is safe here because withdraw_excess_lamports doesn't use it
-    let token = token_client_from_config(config, &Pubkey::default(), None)?;
-    println_display(
-        config,
-        format!(
-            "Withdrawing excess lamports\n  Sender: {}\n  Destination: {}",
-            source_account, destination_account
-        ),
-    );
-
-    let res = token
-        .withdraw_excess_lamports(
-            &source_account,
-            &destination_account,
-            &authority,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-// both enables and disables required transfer memos, via enable_memos bool
-async fn command_required_transfer_memos(
-    config: &Config<'_>,
-    token_account_address: Pubkey,
-    owner: Pubkey,
-    bulk_signers: BulkSigners,
-    enable_memos: bool,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Config can not be sign-only for enabling/disabling required transfer memos.");
-    }
-
-    let account = config.get_account_checked(&token_account_address).await?;
-    let current_account_len = account.data.len();
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    // Reallocation (if needed)
-    let mut existing_extensions: Vec<ExtensionType> = state_with_extension.get_extension_types()?;
-    if existing_extensions.contains(&ExtensionType::MemoTransfer) {
-        let extension_state = state_with_extension
-            .get_extension::<MemoTransfer>()?
-            .require_incoming_transfer_memos
-            .into();
-
-        if extension_state == enable_memos {
-            return Ok(format!(
-                "Required transfer memos were already {}",
-                if extension_state {
-                    "enabled"
-                } else {
-                    "disabled"
-                }
-            ));
-        }
-    } else {
-        existing_extensions.push(ExtensionType::MemoTransfer);
-        let needed_account_len =
-            ExtensionType::try_calculate_account_len::<Account>(&existing_extensions)?;
-        if needed_account_len > current_account_len {
-            token
-                .reallocate(
-                    &token_account_address,
-                    &owner,
-                    &[ExtensionType::MemoTransfer],
-                    &bulk_signers,
-                )
-                .await?;
-        }
-    }
-
-    let res = if enable_memos {
-        token
-            .enable_required_transfer_memos(&token_account_address, &owner, &bulk_signers)
-            .await
-    } else {
-        token
-            .disable_required_transfer_memos(&token_account_address, &owner, &bulk_signers)
-            .await
-    }?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-// both enables and disables cpi guard, via enable_guard bool
-async fn command_cpi_guard(
-    config: &Config<'_>,
-    token_account_address: Pubkey,
-    owner: Pubkey,
-    bulk_signers: BulkSigners,
-    enable_guard: bool,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Config can not be sign-only for enabling/disabling required transfer memos.");
-    }
-
-    let account = config.get_account_checked(&token_account_address).await?;
-    let current_account_len = account.data.len();
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    // reallocation (if needed)
-    let mut existing_extensions: Vec<ExtensionType> = state_with_extension.get_extension_types()?;
-    if existing_extensions.contains(&ExtensionType::CpiGuard) {
-        let extension_state = state_with_extension
-            .get_extension::<CpiGuard>()?
-            .lock_cpi
-            .into();
-
-        if extension_state == enable_guard {
-            return Ok(format!(
-                "CPI Guard was already {}",
-                if extension_state {
-                    "enabled"
-                } else {
-                    "disabled"
-                }
-            ));
-        }
-    } else {
-        existing_extensions.push(ExtensionType::CpiGuard);
-        let required_account_len =
-            ExtensionType::try_calculate_account_len::<Account>(&existing_extensions)?;
-        if required_account_len > current_account_len {
-            token
-                .reallocate(
-                    &token_account_address,
-                    &owner,
-                    &[ExtensionType::CpiGuard],
-                    &bulk_signers,
-                )
-                .await?;
-        }
-    }
-
-    let res = if enable_guard {
-        token
-            .enable_cpi_guard(&token_account_address, &owner, &bulk_signers)
-            .await
-    } else {
-        token
-            .disable_cpi_guard(&token_account_address, &owner, &bulk_signers)
-            .await
-    }?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_update_pointer_address(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    authority: Pubkey,
-    new_address: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-    pointer: Pointer,
-) -> CommandResult {
-    if config.sign_only {
-        panic!(
-            "Config can not be sign-only for updating {} pointer address.",
-            pointer
-        );
-    }
-
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let res = match pointer {
-        Pointer::Metadata => {
-            token
-                .update_metadata_address(&authority, new_address, &bulk_signers)
-                .await
-        }
-        Pointer::Group => {
-            token
-                .update_group_address(&authority, new_address, &bulk_signers)
-                .await
-        }
-        Pointer::GroupMember => {
-            token
-                .update_group_member_address(&authority, new_address, &bulk_signers)
-                .await
-        }
-    }?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_update_default_account_state(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    freeze_authority: Pubkey,
-    new_default_state: AccountState,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    if !config.sign_only {
-        let mint_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data)
-            .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-        match mint_state.base.freeze_authority {
-            COption::None => {
-                return Err(format!("Mint {} has no freeze authority.", token_pubkey).into())
-            }
-            COption::Some(mint_freeze_authority) => {
-                if mint_freeze_authority != freeze_authority {
-                    return Err(format!(
-                        "Mint {} has a freeze authority {}, {} provided",
-                        token_pubkey, mint_freeze_authority, freeze_authority
-                    )
-                    .into());
-                }
-            }
-        }
-
-        if let Ok(default_account_state) = mint_state.get_extension::<DefaultAccountState>() {
-            if default_account_state.state == u8::from(new_default_state) {
-                let state_string = match new_default_state {
-                    AccountState::Frozen => "frozen",
-                    AccountState::Initialized => "initialized",
-                    _ => unreachable!(),
-                };
-                return Err(format!(
-                    "Mint {} already has default account state {}",
-                    token_pubkey, state_string
-                )
-                .into());
-            }
-        } else {
-            return Err(format!(
-                "Mint {} does not support default account states",
-                token_pubkey
-            )
-            .into());
-        }
-    }
-
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let res = token
-        .set_default_account_state(&freeze_authority, &new_default_state, &bulk_signers)
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_withdraw_withheld_tokens(
-    config: &Config<'_>,
-    destination_token_account: Pubkey,
-    source_token_accounts: Vec<Pubkey>,
-    authority: Pubkey,
-    include_mint: bool,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Config can not be sign-only for withdrawing withheld tokens.");
-    }
-    let destination_account = config
-        .get_account_checked(&destination_token_account)
-        .await?;
-    let destination_state = StateWithExtensionsOwned::<Account>::unpack(destination_account.data)
-        .map_err(|_| {
-        format!(
-            "Could not deserialize token account {}",
-            destination_token_account
-        )
-    })?;
-    let token_pubkey = destination_state.base.mint;
-    destination_state
-        .get_extension::<TransferFeeAmount>()
-        .map_err(|_| format!("Token mint {} has no transfer fee configured", token_pubkey))?;
-
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let mut results = vec![];
-    if include_mint {
-        let res = token
-            .withdraw_withheld_tokens_from_mint(
-                &destination_token_account,
-                &authority,
-                &bulk_signers,
-            )
-            .await;
-        let tx_return = finish_tx(config, &res?, false).await?;
-        results.push(match tx_return {
-            TransactionReturnData::CliSignature(signature) => {
-                config.output_format.formatted_string(&signature)
-            }
-            TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-                config.output_format.formatted_string(&sign_only_data)
-            }
-        });
-    }
-
-    let source_refs = source_token_accounts.iter().collect::<Vec<_>>();
-    // this can be tweaked better, but keep it simple for now
-    const MAX_WITHDRAWAL_ACCOUNTS: usize = 25;
-    for sources in source_refs.chunks(MAX_WITHDRAWAL_ACCOUNTS) {
-        let res = token
-            .withdraw_withheld_tokens_from_accounts(
-                &destination_token_account,
-                &authority,
-                sources,
-                &bulk_signers,
-            )
-            .await;
-        let tx_return = finish_tx(config, &res?, false).await?;
-        results.push(match tx_return {
-            TransactionReturnData::CliSignature(signature) => {
-                config.output_format.formatted_string(&signature)
-            }
-            TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-                config.output_format.formatted_string(&sign_only_data)
-            }
-        });
-    }
-
-    Ok(results.join(""))
-}
-
-async fn command_update_confidential_transfer_settings(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    authority: Pubkey,
-    auto_approve: Option<bool>,
-    auditor_pubkey: Option<ElGamalPubkeyOrNone>,
-    bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    let (new_auto_approve, new_auditor_pubkey) = if !config.sign_only {
-        let confidential_transfer_account = config.get_account_checked(&token_pubkey).await?;
-
-        let mint_state =
-            StateWithExtensionsOwned::<Mint>::unpack(confidential_transfer_account.data)
-                .map_err(|_| format!("Could not deserialize token mint {}", token_pubkey))?;
-
-        if let Ok(confidential_transfer_mint) =
-            mint_state.get_extension::<ConfidentialTransferMint>()
-        {
-            let expected_authority = Option::<Pubkey>::from(confidential_transfer_mint.authority);
-
-            if expected_authority != Some(authority) {
-                return Err(format!(
-                    "Mint {} has confidential transfer authority {}, but {} was provided",
-                    token_pubkey,
-                    expected_authority
-                        .map(|pubkey| pubkey.to_string())
-                        .unwrap_or_else(|| "disabled".to_string()),
-                    authority
-                )
-                .into());
-            }
-
-            let new_auto_approve = if let Some(auto_approve) = auto_approve {
-                auto_approve
-            } else {
-                bool::from(confidential_transfer_mint.auto_approve_new_accounts)
-            };
-
-            let new_auditor_pubkey = if let Some(auditor_pubkey) = auditor_pubkey {
-                auditor_pubkey.into()
-            } else {
-                Option::<ElGamalPubkey>::from(confidential_transfer_mint.auditor_elgamal_pubkey)
-            };
-
-            (new_auto_approve, new_auditor_pubkey)
-        } else {
-            return Err(format!(
-                "Mint {} does not support confidential transfers",
-                token_pubkey
-            )
-            .into());
-        }
-    } else {
-        let new_auto_approve = auto_approve.expect("The approve policy must be provided");
-        let new_auditor_pubkey = auditor_pubkey
-            .expect("The auditor encryption pubkey must be provided")
-            .into();
-
-        (new_auto_approve, new_auditor_pubkey)
-    };
-
-    println_display(
-        config,
-        format!(
-            "Updating confidential transfer settings for {}:",
-            token_pubkey,
-        ),
-    );
-
-    if auto_approve.is_some() {
-        println_display(
-            config,
-            format!(
-                "  approve policy set to {}",
-                if new_auto_approve { "auto" } else { "manual" }
-            ),
-        );
-    }
-
-    if auditor_pubkey.is_some() {
-        if let Some(new_auditor_pubkey) = new_auditor_pubkey {
-            println_display(
-                config,
-                format!("  auditor encryption pubkey set to {}", new_auditor_pubkey,),
-            );
-        } else {
-            println_display(config, "  auditability disabled".to_string())
-        }
-    }
-
-    let token = token_client_from_config(config, &token_pubkey, None)?;
-    let res = token
-        .confidential_transfer_update_mint(
-            &authority,
-            new_auto_approve,
-            new_auditor_pubkey,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_configure_confidential_transfer_account(
-    config: &Config<'_>,
-    maybe_token: Option<Pubkey>,
-    owner: Pubkey,
-    maybe_account: Option<Pubkey>,
-    maximum_credit_counter: Option<u64>,
-    elgamal_keypair: &ElGamalKeypair,
-    aes_key: &AeKey,
-    bulk_signers: BulkSigners,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Sign-only is not yet supported.");
-    }
-
-    let token_account_address = if let Some(account) = maybe_account {
-        account
-    } else {
-        let token_pubkey =
-            maybe_token.expect("Either a valid token or account address must be provided");
-        let token = token_client_from_config(config, &token_pubkey, None)?;
-        token.get_associated_token_address(&owner)
-    };
-
-    let account = config.get_account_checked(&token_account_address).await?;
-    let current_account_len = account.data.len();
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    // Reallocation (if needed)
-    let mut existing_extensions: Vec<ExtensionType> = state_with_extension.get_extension_types()?;
-    if !existing_extensions.contains(&ExtensionType::ConfidentialTransferAccount) {
-        let mut extra_extensions = vec![ExtensionType::ConfidentialTransferAccount];
-        if existing_extensions.contains(&ExtensionType::TransferFeeAmount) {
-            extra_extensions.push(ExtensionType::ConfidentialTransferFeeAmount);
-        }
-        existing_extensions.extend_from_slice(&extra_extensions);
-        let needed_account_len =
-            ExtensionType::try_calculate_account_len::<Account>(&existing_extensions)?;
-        if needed_account_len > current_account_len {
-            token
-                .reallocate(
-                    &token_account_address,
-                    &owner,
-                    &extra_extensions,
-                    &bulk_signers,
-                )
-                .await?;
-        }
-    }
-
-    let res = token
-        .confidential_transfer_configure_token_account(
-            &token_account_address,
-            &owner,
-            None,
-            maximum_credit_counter,
-            elgamal_keypair,
-            aes_key,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-async fn command_enable_disable_confidential_transfers(
-    config: &Config<'_>,
-    maybe_token: Option<Pubkey>,
-    owner: Pubkey,
-    maybe_account: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-    allow_confidential_credits: Option<bool>,
-    allow_non_confidential_credits: Option<bool>,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Sign-only is not yet supported.");
-    }
-
-    let token_account_address = if let Some(account) = maybe_account {
-        account
-    } else {
-        let token_pubkey =
-            maybe_token.expect("Either a valid token or account address must be provided");
-        let token = token_client_from_config(config, &token_pubkey, None)?;
-        token.get_associated_token_address(&owner)
-    };
-
-    let account = config.get_account_checked(&token_account_address).await?;
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    let existing_extensions: Vec<ExtensionType> = state_with_extension.get_extension_types()?;
-    if !existing_extensions.contains(&ExtensionType::ConfidentialTransferAccount) {
-        panic!(
-            "Confidential transfer is not yet configured for this account. \
-        Use `configure-confidential-transfer-account` command instead."
-        );
-    }
-
-    let res = if let Some(allow_confidential_credits) = allow_confidential_credits {
-        let extension_state = state_with_extension
-            .get_extension::<ConfidentialTransferAccount>()?
-            .allow_confidential_credits
-            .into();
-
-        if extension_state == allow_confidential_credits {
-            return Ok(format!(
-                "Confidential transfers are already {}",
-                if extension_state {
-                    "enabled"
-                } else {
-                    "disabled"
-                }
-            ));
-        }
-
-        if allow_confidential_credits {
-            token
-                .confidential_transfer_enable_confidential_credits(
-                    &token_account_address,
-                    &owner,
-                    &bulk_signers,
-                )
-                .await
-        } else {
-            token
-                .confidential_transfer_disable_confidential_credits(
-                    &token_account_address,
-                    &owner,
-                    &bulk_signers,
-                )
-                .await
-        }
-    } else {
-        let allow_non_confidential_credits =
-            allow_non_confidential_credits.expect("Nothing to be done");
-        let extension_state = state_with_extension
-            .get_extension::<ConfidentialTransferAccount>()?
-            .allow_non_confidential_credits
-            .into();
-
-        if extension_state == allow_non_confidential_credits {
-            return Ok(format!(
-                "Non-confidential transfers are already {}",
-                if extension_state {
-                    "enabled"
-                } else {
-                    "disabled"
-                }
-            ));
-        }
-
-        if allow_non_confidential_credits {
-            token
-                .confidential_transfer_enable_non_confidential_credits(
-                    &token_account_address,
-                    &owner,
-                    &bulk_signers,
-                )
-                .await
-        } else {
-            token
-                .confidential_transfer_disable_non_confidential_credits(
-                    &token_account_address,
-                    &owner,
-                    &bulk_signers,
-                )
-                .await
-        }
-    }?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-#[derive(PartialEq, Eq)]
-enum ConfidentialInstructionType {
-    Deposit,
-    Withdraw,
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_deposit_withdraw_confidential_tokens(
-    config: &Config<'_>,
-    token_pubkey: Pubkey,
-    owner: Pubkey,
-    maybe_account: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-    ui_amount: Option<f64>,
-    mint_decimals: Option<u8>,
-    instruction_type: ConfidentialInstructionType,
-    elgamal_keypair: Option<&ElGamalKeypair>,
-    aes_key: Option<&AeKey>,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Sign-only is not yet supported.");
-    }
-
-    // check if mint decimals provided is consistent
-    let mint_info = config.get_mint_info(&token_pubkey, mint_decimals).await?;
-
-    if !config.sign_only && mint_decimals.is_some() && mint_decimals != Some(mint_info.decimals) {
-        return Err(format!(
-            "Decimals {} was provided, but actual value is {}",
-            mint_decimals.unwrap(),
-            mint_info.decimals
-        )
-        .into());
-    }
-
-    let decimals = if let Some(decimals) = mint_decimals {
-        decimals
-    } else {
-        mint_info.decimals
-    };
-
-    // derive ATA if account address not provided
-    let token_account_address = if let Some(account) = maybe_account {
-        account
-    } else {
-        let token = token_client_from_config(config, &token_pubkey, Some(decimals))?;
-        token.get_associated_token_address(&owner)
-    };
-
-    let account = config.get_account_checked(&token_account_address).await?;
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    // the amount the user wants to deposit or withdraw, as an f64
-    let maybe_amount =
-        ui_amount.map(|ui_amount| spl_token::ui_amount_to_amount(ui_amount, mint_info.decimals));
-
-    // the amount we will deposit or withdraw, as a u64
-    let amount = if !config.sign_only && instruction_type == ConfidentialInstructionType::Deposit {
-        let current_balance = state_with_extension.base.amount;
-        let deposit_amount = maybe_amount.unwrap_or(current_balance);
-
-        println_display(
-            config,
-            format!(
-                "Depositing {} confidential tokens",
-                spl_token::amount_to_ui_amount(deposit_amount, mint_info.decimals),
-            ),
-        );
-
-        if deposit_amount > current_balance {
-            return Err(format!(
-                "Error: Insufficient funds, current balance is {}",
-                spl_token_2022::amount_to_ui_amount_string_trimmed(
-                    current_balance,
-                    mint_info.decimals
-                )
-            )
-            .into());
-        }
-
-        deposit_amount
-    } else if !config.sign_only && instruction_type == ConfidentialInstructionType::Withdraw {
-        // // TODO: expose account balance decryption in token
-        // let aes_key = aes_key.expect("AES key must be provided");
-        // let current_balance = token
-        //     .confidential_transfer_get_available_balance_with_key(
-        //         &token_account_address,
-        //         aes_key,
-        //     )
-        //     .await?;
-        let withdraw_amount =
-            maybe_amount.expect("ALL keyword is not currently supported for withdraw");
-
-        println_display(
-            config,
-            format!(
-                "Withdrawing {} confidential tokens",
-                spl_token::amount_to_ui_amount(withdraw_amount, mint_info.decimals)
-            ),
-        );
-
-        withdraw_amount
-    } else {
-        maybe_amount.unwrap()
-    };
-
-    let res = match instruction_type {
-        ConfidentialInstructionType::Deposit => {
-            token
-                .confidential_transfer_deposit(
-                    &token_account_address,
-                    &owner,
-                    amount,
-                    decimals,
-                    &bulk_signers,
-                )
-                .await?
-        }
-        ConfidentialInstructionType::Withdraw => {
-            let elgamal_keypair = elgamal_keypair.expect("ElGamal keypair must be provided");
-            let aes_key = aes_key.expect("AES key must be provided");
-
-            let extension_state =
-                state_with_extension.get_extension::<ConfidentialTransferAccount>()?;
-            let withdraw_account_info = WithdrawAccountInfo::new(extension_state);
-
-            let context_state_authority = config.fee_payer()?;
-            let context_state_keypair = Keypair::new();
-            let context_state_pubkey = context_state_keypair.pubkey();
-
-            let withdraw_proof_data =
-                withdraw_account_info.generate_proof_data(amount, elgamal_keypair, aes_key)?;
-
-            // setup proof
-            token
-                .create_withdraw_proof_context_state(
-                    &context_state_pubkey,
-                    &context_state_authority.pubkey(),
-                    &withdraw_proof_data,
-                    &context_state_keypair,
-                )
-                .await?;
-
-            // do the withdrawal
-            token
-                .confidential_transfer_withdraw(
-                    &token_account_address,
-                    &owner,
-                    Some(&context_state_pubkey),
-                    amount,
-                    decimals,
-                    Some(withdraw_account_info),
-                    elgamal_keypair,
-                    aes_key,
-                    &bulk_signers,
-                )
-                .await?;
-
-            // close context state account
-            let context_state_authority_pubkey = context_state_authority.pubkey();
-            let close_context_state_signers = &[context_state_authority];
-            token
-                .confidential_transfer_close_context_state(
-                    &context_state_pubkey,
-                    &token_account_address,
-                    &context_state_authority_pubkey,
-                    close_context_state_signers,
-                )
-                .await?
-        }
-    };
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-async fn command_apply_pending_balance(
-    config: &Config<'_>,
-    maybe_token: Option<Pubkey>,
-    owner: Pubkey,
-    maybe_account: Option<Pubkey>,
-    bulk_signers: BulkSigners,
-    elgamal_keypair: &ElGamalKeypair,
-    aes_key: &AeKey,
-) -> CommandResult {
-    if config.sign_only {
-        panic!("Sign-only is not yet supported.");
-    }
-
-    // derive ATA if account address not provided
-    let token_account_address = if let Some(account) = maybe_account {
-        account
-    } else {
-        let token_pubkey =
-            maybe_token.expect("Either a valid token or account address must be provided");
-        let token = token_client_from_config(config, &token_pubkey, None)?;
-        token.get_associated_token_address(&owner)
-    };
-
-    let account = config.get_account_checked(&token_account_address).await?;
-
-    let state_with_extension = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-    let token = token_client_from_config(config, &state_with_extension.base.mint, None)?;
-
-    let extension_state = state_with_extension.get_extension::<ConfidentialTransferAccount>()?;
-    let account_info = ApplyPendingBalanceAccountInfo::new(extension_state);
-
-    let res = token
-        .confidential_transfer_apply_pending_balance(
-            &token_account_address,
-            &owner,
-            Some(account_info),
-            elgamal_keypair.secret(),
-            aes_key,
-            &bulk_signers,
-        )
-        .await?;
-
-    let tx_return = finish_tx(config, &res, false).await?;
-    Ok(match tx_return {
-        TransactionReturnData::CliSignature(signature) => {
-            config.output_format.formatted_string(&signature)
-        }
-        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
-            config.output_format.formatted_string(&sign_only_data)
-        }
-    })
-}
-
-struct ConfidentialTransferArgs {
-    sender_elgamal_keypair: ElGamalKeypair,
-    sender_aes_key: AeKey,
-    recipient_elgamal_pubkey: Option<ElGamalPubkey>,
-    auditor_elgamal_pubkey: Option<ElGamalPubkey>,
-}
-
-pub async fn process_command<'a>(
-    sub_command: &CommandName,
-    sub_matches: &ArgMatches<'_>,
-    config: &Config<'a>,
-    mut wallet_manager: Option<Rc<RemoteWalletManager>>,
-    mut bulk_signers: Vec<Arc<dyn Signer>>,
-) -> CommandResult {
-    match (sub_command, sub_matches) {
-        (CommandName::Bench, arg_matches) => {
-            bench_process_command(
-                arg_matches,
-                config,
-                std::mem::take(&mut bulk_signers),
-                &mut wallet_manager,
-            )
-            .await
-        }
-        (CommandName::CreateToken, arg_matches) => {
-            let decimals = value_t_or_exit!(arg_matches, "decimals", u8);
-            let mint_authority =
-                config.pubkey_or_default(arg_matches, "mint_authority", &mut wallet_manager)?;
-            let memo = value_t!(arg_matches, "memo", String).ok();
-            let rate_bps = value_t!(arg_matches, "interest_rate", i16).ok();
-            let metadata_address = value_t!(arg_matches, "metadata_address", Pubkey).ok();
-            let group_address = value_t!(arg_matches, "group_address", Pubkey).ok();
-            let member_address = value_t!(arg_matches, "member_address", Pubkey).ok();
-
-            let transfer_fee = arg_matches.values_of("transfer_fee").map(|mut v| {
-                (
-                    v.next()
-                        .unwrap()
-                        .parse::<u16>()
-                        .unwrap_or_else(print_error_and_exit),
-                    v.next()
-                        .unwrap()
-                        .parse::<u64>()
-                        .unwrap_or_else(print_error_and_exit),
-                )
-            });
-
-            let (token_signer, token) =
-                get_signer(arg_matches, "token_keypair", &mut wallet_manager)
-                    .unwrap_or_else(new_throwaway_signer);
-            push_signer_with_dedup(token_signer, &mut bulk_signers);
-            let default_account_state =
-                arg_matches
-                    .value_of("default_account_state")
-                    .map(|s| match s {
-                        "initialized" => AccountState::Initialized,
-                        "frozen" => AccountState::Frozen,
-                        _ => unreachable!(),
-                    });
-            let transfer_hook_program_id =
-                pubkey_of_signer(arg_matches, "transfer_hook", &mut wallet_manager).unwrap();
-
-            let confidential_transfer_auto_approve = arg_matches
-                .value_of("enable_confidential_transfers")
-                .map(|b| b == "auto");
-
-            command_create_token(
-                config,
-                decimals,
-                token,
-                mint_authority,
-                arg_matches.is_present("enable_freeze"),
-                arg_matches.is_present("enable_close"),
-                arg_matches.is_present("enable_non_transferable"),
-                arg_matches.is_present("enable_permanent_delegate"),
-                memo,
-                metadata_address,
-                group_address,
-                member_address,
-                rate_bps,
-                default_account_state,
-                transfer_fee,
-                confidential_transfer_auto_approve,
-                transfer_hook_program_id,
-                arg_matches.is_present("enable_metadata"),
-                arg_matches.is_present("enable_group"),
-                arg_matches.is_present("enable_member"),
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::SetInterestRate, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let rate_bps = value_t_or_exit!(arg_matches, "rate", i16);
-            let (rate_authority_signer, rate_authority_pubkey) =
-                config.signer_or_default(arg_matches, "rate_authority", &mut wallet_manager);
-            let bulk_signers = vec![rate_authority_signer];
-
-            command_set_interest_rate(
-                config,
-                token_pubkey,
-                rate_authority_pubkey,
-                rate_bps,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::SetTransferHook, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let new_program_id =
-                pubkey_of_signer(arg_matches, "new_program_id", &mut wallet_manager).unwrap();
-            let (authority_signer, authority_pubkey) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            let bulk_signers = vec![authority_signer];
-
-            command_set_transfer_hook_program(
-                config,
-                token_pubkey,
-                authority_pubkey,
-                new_program_id,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::InitializeMetadata, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let name = arg_matches.value_of("name").unwrap().to_string();
-            let symbol = arg_matches.value_of("symbol").unwrap().to_string();
-            let uri = arg_matches.value_of("uri").unwrap().to_string();
-            let (mint_authority_signer, mint_authority) =
-                config.signer_or_default(arg_matches, "mint_authority", &mut wallet_manager);
-            let bulk_signers = vec![mint_authority_signer];
-            let update_authority =
-                config.pubkey_or_default(arg_matches, "update_authority", &mut wallet_manager)?;
-
-            command_initialize_metadata(
-                config,
-                token_pubkey,
-                update_authority,
-                mint_authority,
-                name,
-                symbol,
-                uri,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::UpdateMetadata, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let (authority_signer, authority) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            let field = arg_matches.value_of("field").unwrap();
-            let field = match field.to_lowercase().as_str() {
-                "name" => Field::Name,
-                "symbol" => Field::Symbol,
-                "uri" => Field::Uri,
-                _ => Field::Key(field.to_string()),
-            };
-            let value = arg_matches.value_of("value").map(|v| v.to_string());
-            let transfer_lamports = value_of::<u64>(arg_matches, TRANSFER_LAMPORTS_ARG.name);
-            let bulk_signers = vec![authority_signer];
-
-            command_update_metadata(
-                config,
-                token_pubkey,
-                authority,
-                field,
-                value,
-                transfer_lamports,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::InitializeGroup, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let max_size = value_t_or_exit!(arg_matches, "max_size", u32);
-            let (mint_authority_signer, mint_authority) =
-                config.signer_or_default(arg_matches, "mint_authority", &mut wallet_manager);
-            let update_authority =
-                config.pubkey_or_default(arg_matches, "update_authority", &mut wallet_manager)?;
-            let bulk_signers = vec![mint_authority_signer];
-
-            command_initialize_group(
-                config,
-                token_pubkey,
-                mint_authority,
-                update_authority,
-                max_size,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::UpdateGroupMaxSize, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let new_max_size = value_t_or_exit!(arg_matches, "new_max_size", u32);
-            let (update_authority_signer, update_authority) =
-                config.signer_or_default(arg_matches, "update_authority", &mut wallet_manager);
-            let bulk_signers = vec![update_authority_signer];
-
-            command_update_group_max_size(
-                config,
-                token_pubkey,
-                update_authority,
-                new_max_size,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::InitializeMember, arg_matches) => {
-            let member_token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let group_token_pubkey =
-                pubkey_of_signer(arg_matches, "group_token", &mut wallet_manager)
-                    .unwrap()
-                    .unwrap();
-            let (mint_authority_signer, mint_authority) =
-                config.signer_or_default(arg_matches, "mint_authority", &mut wallet_manager);
-            let (group_update_authority_signer, group_update_authority) = config.signer_or_default(
-                arg_matches,
-                "group_update_authority",
-                &mut wallet_manager,
-            );
-            let mut bulk_signers = vec![mint_authority_signer];
-            push_signer_with_dedup(group_update_authority_signer, &mut bulk_signers);
-
-            command_initialize_member(
-                config,
-                member_token_pubkey,
-                mint_authority,
-                group_token_pubkey,
-                group_update_authority,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::CreateAccount, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            // No need to add a signer when creating an associated token account
-            let account = get_signer(arg_matches, "account_keypair", &mut wallet_manager).map(
-                |(signer, account)| {
-                    push_signer_with_dedup(signer, &mut bulk_signers);
-                    account
-                },
-            );
-
-            let owner = config.pubkey_or_default(arg_matches, "owner", &mut wallet_manager)?;
-            command_create_account(
-                config,
-                token,
-                owner,
-                account,
-                arg_matches.is_present("immutable"),
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::CreateMultisig, arg_matches) => {
-            let minimum_signers = value_of::<u8>(arg_matches, "minimum_signers").unwrap();
-            let multisig_members =
-                pubkeys_of_multiple_signers(arg_matches, "multisig_member", &mut wallet_manager)
-                    .unwrap_or_else(print_error_and_exit)
-                    .unwrap();
-            if minimum_signers as usize > multisig_members.len() {
-                eprintln!(
-                    "error: MINIMUM_SIGNERS cannot be greater than the number \
-                          of MULTISIG_MEMBERs passed"
-                );
-                exit(1);
-            }
-
-            let (signer, _) = get_signer(arg_matches, "address_keypair", &mut wallet_manager)
-                .unwrap_or_else(new_throwaway_signer);
-
-            command_create_multisig(config, signer, minimum_signers, multisig_members).await
-        }
-        (CommandName::Authorize, arg_matches) => {
-            let address = pubkey_of_signer(arg_matches, "address", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let authority_type = arg_matches.value_of("authority_type").unwrap();
-            let authority_type = CliAuthorityType::from_str(authority_type)?;
-
-            let (authority_signer, authority) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(authority_signer, &mut bulk_signers);
-            }
-
-            let new_authority =
-                pubkey_of_signer(arg_matches, "new_authority", &mut wallet_manager).unwrap();
-            let force_authorize = arg_matches.is_present("force");
-            command_authorize(
-                config,
-                address,
-                authority_type,
-                authority,
-                new_authority,
-                force_authorize,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Transfer, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let amount = parse_amount_or_all(arg_matches);
-            let recipient = pubkey_of_signer(arg_matches, "recipient", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let sender = pubkey_of_signer(arg_matches, "from", &mut wallet_manager).unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-
-            let confidential_transfer_args = if arg_matches.is_present("confidential") {
-                // Deriving ElGamal and AES key from signer. Custom ElGamal and AES keys will be
-                // supported in the future once upgrading to clap-v3.
-                //
-                // NOTE:: Seed bytes are hardcoded to be empty bytes for now. They will be
-                // updated once custom ElGamal and AES keys are supported.
-                let sender_elgamal_keypair =
-                    ElGamalKeypair::new_from_signer(&*owner_signer, b"").unwrap();
-                let sender_aes_key = AeKey::new_from_signer(&*owner_signer, b"").unwrap();
-
-                // Sign-only mode is not yet supported for confidential transfers, so set
-                // recipient and auditor ElGamal public to `None` by default.
-                Some(ConfidentialTransferArgs {
-                    sender_elgamal_keypair,
-                    sender_aes_key,
-                    recipient_elgamal_pubkey: None,
-                    auditor_elgamal_pubkey: None,
-                })
-            } else {
-                None
-            };
-
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-            let fund_recipient = arg_matches.is_present("fund_recipient");
-            let allow_unfunded_recipient = arg_matches.is_present("allow_empty_recipient")
-                || arg_matches.is_present("allow_unfunded_recipient");
-
-            let recipient_is_ata_owner = arg_matches.is_present("recipient_is_ata_owner");
-            let no_recipient_is_ata_owner =
-                arg_matches.is_present("no_recipient_is_ata_owner") || !recipient_is_ata_owner;
-            if recipient_is_ata_owner {
-                println_display(config, "recipient-is-ata-owner is now the default behavior. The option has been deprecated and will be removed in a future release.".to_string());
-            }
-            let use_unchecked_instruction = arg_matches.is_present("use_unchecked_instruction");
-            let expected_fee = value_of::<f64>(arg_matches, "expected_fee");
-            let memo = value_t!(arg_matches, "memo", String).ok();
-            let transfer_hook_accounts = arg_matches.values_of("transfer_hook_account").map(|v| {
-                v.into_iter()
-                    .map(|s| parse_transfer_hook_account(s).unwrap())
-                    .collect::<Vec<_>>()
-            });
-
-            command_transfer(
-                config,
-                token,
-                amount,
-                recipient,
-                sender,
-                owner,
-                allow_unfunded_recipient,
-                fund_recipient,
-                mint_decimals,
-                no_recipient_is_ata_owner,
-                use_unchecked_instruction,
-                expected_fee,
-                memo,
-                bulk_signers,
-                arg_matches.is_present("no_wait"),
-                arg_matches.is_present("allow_non_system_account_recipient"),
-                transfer_hook_accounts,
-                confidential_transfer_args.as_ref(),
-            )
-            .await
-        }
-        (CommandName::Burn, arg_matches) => {
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let amount = parse_amount_or_all(arg_matches);
-            let mint_address =
-                pubkey_of_signer(arg_matches, MINT_ADDRESS_ARG.name, &mut wallet_manager).unwrap();
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-            let use_unchecked_instruction = arg_matches.is_present("use_unchecked_instruction");
-            let memo = value_t!(arg_matches, "memo", String).ok();
-            command_burn(
-                config,
-                account,
-                owner,
-                amount,
-                mint_address,
-                mint_decimals,
-                use_unchecked_instruction,
-                memo,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Mint, arg_matches) => {
-            let (mint_authority_signer, mint_authority) =
-                config.signer_or_default(arg_matches, "mint_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(mint_authority_signer, &mut bulk_signers);
-            }
-
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-            let mint_info = config.get_mint_info(&token, mint_decimals).await?;
-            let recipient = if let Some(address) =
-                pubkey_of_signer(arg_matches, "recipient", &mut wallet_manager).unwrap()
-            {
-                address
-            } else if let Some(address) =
-                pubkey_of_signer(arg_matches, "recipient_owner", &mut wallet_manager).unwrap()
-            {
-                get_associated_token_address_with_program_id(&address, &token, &config.program_id)
-            } else {
-                let owner = config.default_signer()?.pubkey();
-                config.associated_token_address_for_token_and_program(
-                    &mint_info.address,
-                    &owner,
-                    &mint_info.program_id,
-                )?
-            };
-            config.check_account(&recipient, Some(token)).await?;
-            let use_unchecked_instruction = arg_matches.is_present("use_unchecked_instruction");
-            let memo = value_t!(arg_matches, "memo", String).ok();
-            command_mint(
-                config,
-                token,
-                amount,
-                recipient,
-                mint_info,
-                mint_authority,
-                use_unchecked_instruction,
-                memo,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Freeze, arg_matches) => {
-            let (freeze_authority_signer, freeze_authority) =
-                config.signer_or_default(arg_matches, "freeze_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(freeze_authority_signer, &mut bulk_signers);
-            }
-
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let mint_address =
-                pubkey_of_signer(arg_matches, MINT_ADDRESS_ARG.name, &mut wallet_manager).unwrap();
-            command_freeze(
-                config,
-                account,
-                mint_address,
-                freeze_authority,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Thaw, arg_matches) => {
-            let (freeze_authority_signer, freeze_authority) =
-                config.signer_or_default(arg_matches, "freeze_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(freeze_authority_signer, &mut bulk_signers);
-            }
-
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let mint_address =
-                pubkey_of_signer(arg_matches, MINT_ADDRESS_ARG.name, &mut wallet_manager).unwrap();
-            command_thaw(
-                config,
-                account,
-                mint_address,
-                freeze_authority,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Wrap, arg_matches) => {
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let account = if arg_matches.is_present("create_aux_account") {
-                let (signer, account) = new_throwaway_signer();
-                bulk_signers.push(signer);
-                Some(account)
-            } else {
-                // No need to add a signer when creating an associated token account
-                None
-            };
-
-            let (wallet_signer, wallet_address) =
-                config.signer_or_default(arg_matches, "wallet_keypair", &mut wallet_manager);
-            push_signer_with_dedup(wallet_signer, &mut bulk_signers);
-
-            command_wrap(
-                config,
-                amount,
-                wallet_address,
-                account,
-                arg_matches.is_present("immutable"),
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Unwrap, arg_matches) => {
-            let (wallet_signer, wallet_address) =
-                config.signer_or_default(arg_matches, "wallet_keypair", &mut wallet_manager);
-            push_signer_with_dedup(wallet_signer, &mut bulk_signers);
-
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager).unwrap();
-            command_unwrap(config, wallet_address, account, bulk_signers).await
-        }
-        (CommandName::Approve, arg_matches) => {
-            let (owner_signer, owner_address) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let amount = value_t_or_exit!(arg_matches, "amount", f64);
-            let delegate = pubkey_of_signer(arg_matches, "delegate", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let mint_address =
-                pubkey_of_signer(arg_matches, MINT_ADDRESS_ARG.name, &mut wallet_manager).unwrap();
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-            let use_unchecked_instruction = arg_matches.is_present("use_unchecked_instruction");
-            command_approve(
-                config,
-                account,
-                owner_address,
-                amount,
-                delegate,
-                mint_address,
-                mint_decimals,
-                use_unchecked_instruction,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Revoke, arg_matches) => {
-            let (owner_signer, owner_address) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let account = pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let delegate_address =
-                pubkey_of_signer(arg_matches, DELEGATE_ADDRESS_ARG.name, &mut wallet_manager)
-                    .unwrap();
-            command_revoke(
-                config,
-                account,
-                owner_address,
-                delegate_address,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::Close, arg_matches) => {
-            let (close_authority_signer, close_authority) =
-                config.signer_or_default(arg_matches, "close_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(close_authority_signer, &mut bulk_signers);
-            }
-
-            let address = config
-                .associated_token_address_or_override(arg_matches, "address", &mut wallet_manager)
-                .await?;
-            let recipient =
-                config.pubkey_or_default(arg_matches, "recipient", &mut wallet_manager)?;
-            command_close(config, address, close_authority, recipient, bulk_signers).await
-        }
-        (CommandName::CloseMint, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let (close_authority_signer, close_authority) =
-                config.signer_or_default(arg_matches, "close_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(close_authority_signer, &mut bulk_signers);
-            }
-            let recipient =
-                config.pubkey_or_default(arg_matches, "recipient", &mut wallet_manager)?;
-
-            command_close_mint(config, token, close_authority, recipient, bulk_signers).await
-        }
-        (CommandName::Balance, arg_matches) => {
-            let address = config
-                .associated_token_address_or_override(arg_matches, "address", &mut wallet_manager)
-                .await?;
-            command_balance(config, address).await
-        }
-        (CommandName::Supply, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            command_supply(config, token).await
-        }
-        (CommandName::Accounts, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager).unwrap();
-            let owner = config.pubkey_or_default(arg_matches, "owner", &mut wallet_manager)?;
-            let filter = if arg_matches.is_present("delegated") {
-                AccountFilter::Delegated
-            } else if arg_matches.is_present("externally_closeable") {
-                AccountFilter::ExternallyCloseable
-            } else {
-                AccountFilter::All
-            };
-
-            command_accounts(
-                config,
-                token,
-                owner,
-                filter,
-                arg_matches.is_present("addresses_only"),
-            )
-            .await
-        }
-        (CommandName::Address, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager).unwrap();
-            let owner = config.pubkey_or_default(arg_matches, "owner", &mut wallet_manager)?;
-            command_address(config, token, owner).await
-        }
-        (CommandName::AccountInfo, arg_matches) => {
-            let address = config
-                .associated_token_address_or_override(arg_matches, "address", &mut wallet_manager)
-                .await?;
-            command_display(config, address).await
-        }
-        (CommandName::MultisigInfo, arg_matches) => {
-            let address = pubkey_of_signer(arg_matches, "address", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            command_display(config, address).await
-        }
-        (CommandName::Display, arg_matches) => {
-            let address = pubkey_of_signer(arg_matches, "address", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            command_display(config, address).await
-        }
-        (CommandName::Gc, arg_matches) => {
-            match config.output_format {
-                OutputFormat::Json | OutputFormat::JsonCompact => {
-                    eprintln!(
-                        "`spl-token gc` does not support the `--output` parameter at this time"
-                    );
-                    exit(1);
-                }
-                _ => {}
-            }
-
-            let close_empty_associated_accounts =
-                arg_matches.is_present("close_empty_associated_accounts");
-
-            let (owner_signer, owner_address) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            command_gc(
-                config,
-                owner_address,
-                close_empty_associated_accounts,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::SyncNative, arg_matches) => {
-            let native_mint = *native_token_client_from_config(config)?.get_address();
-            let address = config
-                .associated_token_address_for_token_or_override(
-                    arg_matches,
-                    "address",
-                    &mut wallet_manager,
-                    Some(native_mint),
-                )
-                .await;
-            command_sync_native(config, address?).await
-        }
-        (CommandName::EnableRequiredTransferMemos, arg_matches) => {
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-            // Since account is required argument it will always be present
-            let token_account =
-                config.pubkey_or_default(arg_matches, "account", &mut wallet_manager)?;
-            command_required_transfer_memos(config, token_account, owner, bulk_signers, true).await
-        }
-        (CommandName::DisableRequiredTransferMemos, arg_matches) => {
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-            // Since account is required argument it will always be present
-            let token_account =
-                config.pubkey_or_default(arg_matches, "account", &mut wallet_manager)?;
-            command_required_transfer_memos(config, token_account, owner, bulk_signers, false).await
-        }
-        (CommandName::EnableCpiGuard, arg_matches) => {
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-            // Since account is required argument it will always be present
-            let token_account =
-                config.pubkey_or_default(arg_matches, "account", &mut wallet_manager)?;
-            command_cpi_guard(config, token_account, owner, bulk_signers, true).await
-        }
-        (CommandName::DisableCpiGuard, arg_matches) => {
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-            // Since account is required argument it will always be present
-            let token_account =
-                config.pubkey_or_default(arg_matches, "account", &mut wallet_manager)?;
-            command_cpi_guard(config, token_account, owner, bulk_signers, false).await
-        }
-        (CommandName::UpdateDefaultAccountState, arg_matches) => {
-            // Since account is required argument it will always be present
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let (freeze_authority_signer, freeze_authority) =
-                config.signer_or_default(arg_matches, "freeze_authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(freeze_authority_signer, &mut bulk_signers);
-            }
-            let new_default_state = arg_matches.value_of("state").unwrap();
-            let new_default_state = match new_default_state {
-                "initialized" => AccountState::Initialized,
-                "frozen" => AccountState::Frozen,
-                _ => unreachable!(),
-            };
-            command_update_default_account_state(
-                config,
-                token,
-                freeze_authority,
-                new_default_state,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::UpdateMetadataAddress, arg_matches) => {
-            // Since account is required argument it will always be present
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            let (authority_signer, authority) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(authority_signer, &mut bulk_signers);
-            }
-            let metadata_address = value_t!(arg_matches, "metadata_address", Pubkey).ok();
-
-            command_update_pointer_address(
-                config,
-                token,
-                authority,
-                metadata_address,
-                bulk_signers,
-                Pointer::Metadata,
-            )
-            .await
-        }
-        (CommandName::UpdateGroupAddress, arg_matches) => {
-            // Since account is required argument it will always be present
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            let (authority_signer, authority) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(authority_signer, &mut bulk_signers);
-            }
-            let group_address = value_t!(arg_matches, "group_address", Pubkey).ok();
-
-            command_update_pointer_address(
-                config,
-                token,
-                authority,
-                group_address,
-                bulk_signers,
-                Pointer::Group,
-            )
-            .await
-        }
-        (CommandName::UpdateMemberAddress, arg_matches) => {
-            // Since account is required argument it will always be present
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            let (authority_signer, authority) =
-                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(authority_signer, &mut bulk_signers);
-            }
-            let member_address = value_t!(arg_matches, "member_address", Pubkey).ok();
-
-            command_update_pointer_address(
-                config,
-                token,
-                authority,
-                member_address,
-                bulk_signers,
-                Pointer::GroupMember,
-            )
-            .await
-        }
-        (CommandName::WithdrawWithheldTokens, arg_matches) => {
-            let (authority_signer, authority) = config.signer_or_default(
-                arg_matches,
-                "withdraw_withheld_authority",
-                &mut wallet_manager,
-            );
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(authority_signer, &mut bulk_signers);
-            }
-            // Since destination is required it will always be present
-            let destination_token_account =
-                pubkey_of_signer(arg_matches, "account", &mut wallet_manager)
-                    .unwrap()
-                    .unwrap();
-            let include_mint = arg_matches.is_present("include_mint");
-            let source_accounts = arg_matches
-                .values_of("source")
-                .unwrap_or_default()
-                .map(|s| Pubkey::from_str(s).unwrap_or_else(print_error_and_exit))
-                .collect::<Vec<_>>();
-            command_withdraw_withheld_tokens(
-                config,
-                destination_token_account,
-                source_accounts,
-                authority,
-                include_mint,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::SetTransferFee, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let transfer_fee_basis_points =
-                value_t_or_exit!(arg_matches, "transfer_fee_basis_points", u16);
-            let maximum_fee = value_t_or_exit!(arg_matches, "maximum_fee", f64);
-            let (transfer_fee_authority_signer, transfer_fee_authority_pubkey) = config
-                .signer_or_default(arg_matches, "transfer_fee_authority", &mut wallet_manager);
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-            let bulk_signers = vec![transfer_fee_authority_signer];
-
-            command_set_transfer_fee(
-                config,
-                token_pubkey,
-                transfer_fee_authority_pubkey,
-                transfer_fee_basis_points,
-                maximum_fee,
-                mint_decimals,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::WithdrawExcessLamports, arg_matches) => {
-            let (signer, authority) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(signer, &mut bulk_signers);
-            }
-
-            let source = config.pubkey_or_default(arg_matches, "from", &mut wallet_manager)?;
-            let destination =
-                config.pubkey_or_default(arg_matches, "recipient", &mut wallet_manager)?;
-
-            command_withdraw_excess_lamports(config, source, destination, authority, bulk_signers)
-                .await
-        }
-        (CommandName::UpdateConfidentialTransferSettings, arg_matches) => {
-            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-
-            let auto_approve = arg_matches.value_of("approve_policy").map(|b| b == "auto");
-
-            let auditor_encryption_pubkey = if arg_matches.is_present("auditor_pubkey") {
-                Some(elgamal_pubkey_or_none(arg_matches, "auditor_pubkey")?)
-            } else {
-                None
-            };
-
-            let (authority_signer, authority_pubkey) = config.signer_or_default(
-                arg_matches,
-                "confidential_transfer_authority",
-                &mut wallet_manager,
-            );
-            let bulk_signers = vec![authority_signer];
-
-            command_update_confidential_transfer_settings(
-                config,
-                token_pubkey,
-                authority_pubkey,
-                auto_approve,
-                auditor_encryption_pubkey,
-                bulk_signers,
-            )
-            .await
-        }
-        (CommandName::ConfigureConfidentialTransferAccount, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager).unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-
-            let account = pubkey_of_signer(arg_matches, "address", &mut wallet_manager).unwrap();
-
-            // Deriving ElGamal and AES key from signer. Custom ElGamal and AES keys will be
-            // supported in the future once upgrading to clap-v3.
-            //
-            // NOTE:: Seed bytes are hardcoded to be empty bytes for now. They will be
-            // updated once custom ElGamal and AES keys are supported.
-            let elgamal_keypair = ElGamalKeypair::new_from_signer(&*owner_signer, b"").unwrap();
-            let aes_key = AeKey::new_from_signer(&*owner_signer, b"").unwrap();
-
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let maximum_credit_counter =
-                if arg_matches.is_present("maximum_pending_balance_credit_counter") {
-                    let maximum_credit_counter = value_t_or_exit!(
-                        arg_matches.value_of("maximum_pending_balance_credit_counter"),
-                        u64
-                    );
-                    Some(maximum_credit_counter)
-                } else {
-                    None
-                };
-
-            command_configure_confidential_transfer_account(
-                config,
-                token,
-                owner,
-                account,
-                maximum_credit_counter,
-                &elgamal_keypair,
-                &aes_key,
-                bulk_signers,
-            )
-            .await
-        }
-        (c @ CommandName::EnableConfidentialCredits, arg_matches)
-        | (c @ CommandName::DisableConfidentialCredits, arg_matches)
-        | (c @ CommandName::EnableNonConfidentialCredits, arg_matches)
-        | (c @ CommandName::DisableNonConfidentialCredits, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager).unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-
-            let account = pubkey_of_signer(arg_matches, "address", &mut wallet_manager).unwrap();
-
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            let (allow_confidential_credits, allow_non_confidential_credits) = match c {
-                CommandName::EnableConfidentialCredits => (Some(true), None),
-                CommandName::DisableConfidentialCredits => (Some(false), None),
-                CommandName::EnableNonConfidentialCredits => (None, Some(true)),
-                CommandName::DisableNonConfidentialCredits => (None, Some(false)),
-                _ => (None, None),
-            };
-
-            command_enable_disable_confidential_transfers(
-                config,
-                token,
-                owner,
-                account,
-                bulk_signers,
-                allow_confidential_credits,
-                allow_non_confidential_credits,
-            )
-            .await
-        }
-        (c @ CommandName::DepositConfidentialTokens, arg_matches)
-        | (c @ CommandName::WithdrawConfidentialTokens, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
-                .unwrap()
-                .unwrap();
-            let amount = parse_amount_or_all(arg_matches);
-            let account = pubkey_of_signer(arg_matches, "address", &mut wallet_manager).unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-
-            let mint_decimals = value_of::<u8>(arg_matches, MINT_DECIMALS_ARG.name);
-
-            let (instruction_type, elgamal_keypair, aes_key) = match c {
-                CommandName::DepositConfidentialTokens => {
-                    (ConfidentialInstructionType::Deposit, None, None)
-                }
-                CommandName::WithdrawConfidentialTokens => {
-                    // Deriving ElGamal and AES key from signer. Custom ElGamal and AES keys will be
-                    // supported in the future once upgrading to clap-v3.
-                    //
-                    // NOTE:: Seed bytes are hardcoded to be empty bytes for now. They will be
-                    // updated once custom ElGamal and AES keys are supported.
-                    let elgamal_keypair =
-                        ElGamalKeypair::new_from_signer(&*owner_signer, b"").unwrap();
-                    let aes_key = AeKey::new_from_signer(&*owner_signer, b"").unwrap();
-
-                    (
-                        ConfidentialInstructionType::Withdraw,
-                        Some(elgamal_keypair),
-                        Some(aes_key),
-                    )
-                }
-                _ => panic!("Instruction not supported"),
-            };
-
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            command_deposit_withdraw_confidential_tokens(
-                config,
-                token,
-                owner,
-                account,
-                bulk_signers,
-                amount,
-                mint_decimals,
-                instruction_type,
-                elgamal_keypair.as_ref(),
-                aes_key.as_ref(),
-            )
-            .await
-        }
-        (CommandName::ApplyPendingBalance, arg_matches) => {
-            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager).unwrap();
-
-            let (owner_signer, owner) =
-                config.signer_or_default(arg_matches, "owner", &mut wallet_manager);
-
-            let account = pubkey_of_signer(arg_matches, "address", &mut wallet_manager).unwrap();
-
-            // Deriving ElGamal and AES key from signer. Custom ElGamal and AES keys will be
-            // supported in the future once upgrading to clap-v3.
-            //
-            // NOTE:: Seed bytes are hardcoded to be empty bytes for now. They will be
-            // updated once custom ElGamal and AES keys are supported.
-            let elgamal_keypair = ElGamalKeypair::new_from_signer(&*owner_signer, b"").unwrap();
-            let aes_key = AeKey::new_from_signer(&*owner_signer, b"").unwrap();
-
-            if config.multisigner_pubkeys.is_empty() {
-                push_signer_with_dedup(owner_signer, &mut bulk_signers);
-            }
-
-            command_apply_pending_balance(
-                config,
-                token,
-                owner,
-                account,
-                bulk_signers,
-                &elgamal_keypair,
-                &aes_key,
-            )
-            .await
-        }
-    }
-}
-
-fn format_output<T>(command_output: T, command_name: &CommandName, config: &Config) -> String
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    config.output_format.formatted_string(&CommandOutput {
-        command_name: command_name.to_string(),
-        command_output,
-    })
-}
-enum TransactionReturnData {
-    CliSignature(CliSignature),
-    CliSignOnlyData(CliSignOnlyData),
-}
-
-async fn finish_tx<'a>(
-    config: &Config<'a>,
-    rpc_response: &RpcClientResponse,
-    no_wait: bool,
-) -> Result<TransactionReturnData, Error> {
-    match rpc_response {
-        RpcClientResponse::Transaction(transaction) => {
-            Ok(TransactionReturnData::CliSignOnlyData(return_signers_data(
-                transaction,
-                &ReturnSignersConfig {
-                    dump_transaction_message: config.dump_transaction_message,
-                },
-            )))
-        }
-        RpcClientResponse::Signature(signature) if no_wait => {
-            Ok(TransactionReturnData::CliSignature(CliSignature {
-                signature: signature.to_string(),
-            }))
-        }
-        RpcClientResponse::Signature(signature) => {
-            let blockhash = config.program_client.get_latest_blockhash().await?;
-            config
-                .rpc_client
-                .confirm_transaction_with_spinner(
-                    signature,
-                    &blockhash,
-                    config.rpc_client.commitment(),
-                )
-                .await?;
-
-            Ok(TransactionReturnData::CliSignature(CliSignature {
-                signature: signature.to_string(),
-            }))
-        }
-        RpcClientResponse::Simulation(_) => {
-            // Implement this once the CLI supports dry-running / simulation
-            unreachable!()
-        }
-    }
-}
diff --git a/token/cli/src/config.rs b/token/cli/src/config.rs
deleted file mode 100644
index 89137a51b31..00000000000
--- a/token/cli/src/config.rs
+++ /dev/null
@@ -1,539 +0,0 @@
-use {
-    crate::clap_app::{Error, COMPUTE_UNIT_LIMIT_ARG, COMPUTE_UNIT_PRICE_ARG, MULTISIG_SIGNER_ARG},
-    clap::ArgMatches,
-    solana_clap_utils::{
-        input_parsers::{pubkey_of_signer, value_of},
-        input_validators::normalize_to_url_if_moniker,
-        keypair::{signer_from_path, signer_from_path_with_config, SignerFromPathConfig},
-        nonce::{NONCE_ARG, NONCE_AUTHORITY_ARG},
-        offline::{BLOCKHASH_ARG, DUMP_TRANSACTION_MESSAGE, SIGN_ONLY_ARG},
-    },
-    solana_cli_output::OutputFormat,
-    solana_client::nonblocking::rpc_client::RpcClient,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        account::Account as RawAccount, commitment_config::CommitmentConfig, hash::Hash,
-        pubkey::Pubkey, signature::Signer,
-    },
-    spl_associated_token_account::*,
-    spl_token_2022::{
-        extension::StateWithExtensionsOwned,
-        state::{Account, Mint},
-    },
-    spl_token_client::{
-        client::{
-            ProgramClient, ProgramOfflineClient, ProgramRpcClient, ProgramRpcClientSendTransaction,
-        },
-        token::ComputeUnitLimit,
-    },
-    std::{process::exit, rc::Rc, sync::Arc},
-};
-
-type SignersOf = Vec<(Arc<dyn Signer>, Pubkey)>;
-fn signers_of(
-    matches: &ArgMatches<'_>,
-    name: &str,
-    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-) -> Result<Option<SignersOf>, Box<dyn std::error::Error>> {
-    if let Some(values) = matches.values_of(name) {
-        let mut results = Vec::new();
-        for (i, value) in values.enumerate() {
-            let name = format!("{}-{}", name, i.saturating_add(1));
-            let signer = signer_from_path(matches, value, &name, wallet_manager)?;
-            let signer_pubkey = signer.pubkey();
-            results.push((Arc::from(signer), signer_pubkey));
-        }
-        Ok(Some(results))
-    } else {
-        Ok(None)
-    }
-}
-
-pub(crate) struct MintInfo {
-    pub program_id: Pubkey,
-    pub address: Pubkey,
-    pub decimals: u8,
-}
-
-pub struct Config<'a> {
-    pub default_signer: Option<Arc<dyn Signer>>,
-    pub rpc_client: Arc<RpcClient>,
-    pub program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>>,
-    pub websocket_url: String,
-    pub output_format: OutputFormat,
-    pub fee_payer: Option<Arc<dyn Signer>>,
-    pub nonce_account: Option<Pubkey>,
-    pub nonce_authority: Option<Arc<dyn Signer>>,
-    pub nonce_blockhash: Option<Hash>,
-    pub sign_only: bool,
-    pub dump_transaction_message: bool,
-    pub multisigner_pubkeys: Vec<&'a Pubkey>,
-    pub program_id: Pubkey,
-    pub restrict_to_program_id: bool,
-    pub compute_unit_price: Option<u64>,
-    pub compute_unit_limit: ComputeUnitLimit,
-}
-
-impl<'a> Config<'a> {
-    pub async fn new(
-        matches: &ArgMatches<'_>,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-        bulk_signers: &mut Vec<Arc<dyn Signer>>,
-        multisigner_ids: &'a mut Vec<Pubkey>,
-    ) -> Config<'a> {
-        let cli_config = if let Some(config_file) = matches.value_of("config_file") {
-            solana_cli_config::Config::load(config_file).unwrap_or_else(|_| {
-                eprintln!("error: Could not find config file `{}`", config_file);
-                exit(1);
-            })
-        } else if let Some(config_file) = &*solana_cli_config::CONFIG_FILE {
-            solana_cli_config::Config::load(config_file).unwrap_or_default()
-        } else {
-            solana_cli_config::Config::default()
-        };
-        let json_rpc_url = normalize_to_url_if_moniker(
-            matches
-                .value_of("json_rpc_url")
-                .unwrap_or(&cli_config.json_rpc_url),
-        );
-        let websocket_url = solana_cli_config::Config::compute_websocket_url(&json_rpc_url);
-        let rpc_client = Arc::new(RpcClient::new_with_commitment(
-            json_rpc_url,
-            CommitmentConfig::confirmed(),
-        ));
-        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = if sign_only {
-            let blockhash = value_of(matches, BLOCKHASH_ARG.name).unwrap_or_default();
-            Arc::new(ProgramOfflineClient::new(
-                blockhash,
-                ProgramRpcClientSendTransaction,
-            ))
-        } else {
-            Arc::new(ProgramRpcClient::new(
-                rpc_client.clone(),
-                ProgramRpcClientSendTransaction,
-            ))
-        };
-        Self::new_with_clients_and_ws_url(
-            matches,
-            wallet_manager,
-            bulk_signers,
-            multisigner_ids,
-            rpc_client,
-            program_client,
-            websocket_url,
-        )
-        .await
-    }
-
-    fn extract_multisig_signers(
-        matches: &ArgMatches<'_>,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-        bulk_signers: &mut Vec<Arc<dyn Signer>>,
-        multisigner_ids: &'a mut Vec<Pubkey>,
-    ) -> Vec<&'a Pubkey> {
-        let multisig_signers = signers_of(matches, MULTISIG_SIGNER_ARG.name, wallet_manager)
-            .unwrap_or_else(|e| {
-                eprintln!("error: {}", e);
-                exit(1);
-            });
-        if let Some(mut multisig_signers) = multisig_signers {
-            multisig_signers.sort_by(|(_, lp), (_, rp)| lp.cmp(rp));
-            let (signers, pubkeys): (Vec<_>, Vec<_>) = multisig_signers.into_iter().unzip();
-            bulk_signers.extend(signers);
-            multisigner_ids.extend(pubkeys);
-        }
-        multisigner_ids.iter().collect::<Vec<_>>()
-    }
-
-    pub async fn new_with_clients_and_ws_url(
-        matches: &ArgMatches<'_>,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-        bulk_signers: &mut Vec<Arc<dyn Signer>>,
-        multisigner_ids: &'a mut Vec<Pubkey>,
-        rpc_client: Arc<RpcClient>,
-        program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>>,
-        websocket_url: String,
-    ) -> Config<'a> {
-        let cli_config = if let Some(config_file) = matches.value_of("config_file") {
-            solana_cli_config::Config::load(config_file).unwrap_or_else(|_| {
-                eprintln!("error: Could not find config file `{}`", config_file);
-                exit(1);
-            })
-        } else if let Some(config_file) = &*solana_cli_config::CONFIG_FILE {
-            solana_cli_config::Config::load(config_file).unwrap_or_default()
-        } else {
-            solana_cli_config::Config::default()
-        };
-        let multisigner_pubkeys =
-            Self::extract_multisig_signers(matches, wallet_manager, bulk_signers, multisigner_ids);
-
-        let config = SignerFromPathConfig {
-            allow_null_signer: !multisigner_pubkeys.is_empty(),
-        };
-
-        let default_keypair = cli_config.keypair_path.clone();
-
-        let default_signer: Option<Arc<dyn Signer>> = {
-            if let Some(owner_path) = matches.value_of("owner") {
-                signer_from_path_with_config(matches, owner_path, "owner", wallet_manager, &config)
-                    .ok()
-            } else {
-                signer_from_path_with_config(
-                    matches,
-                    &default_keypair,
-                    "default",
-                    wallet_manager,
-                    &config,
-                )
-                .map_err(|e| {
-                    if std::fs::metadata(&default_keypair).is_ok() {
-                        eprintln!("error: {}", e);
-                        exit(1);
-                    } else {
-                        e
-                    }
-                })
-                .ok()
-            }
-        }
-        .map(Arc::from);
-
-        let fee_payer: Option<Arc<dyn Signer>> = matches
-            .value_of("fee_payer")
-            .map(|path| {
-                Arc::from(
-                    signer_from_path(matches, path, "fee_payer", wallet_manager).unwrap_or_else(
-                        |e| {
-                            eprintln!("error: {}", e);
-                            exit(1);
-                        },
-                    ),
-                )
-            })
-            .or_else(|| default_signer.clone());
-
-        let verbose = matches.is_present("verbose");
-        let output_format = matches
-            .value_of("output_format")
-            .map(|value| match value {
-                "json" => OutputFormat::Json,
-                "json-compact" => OutputFormat::JsonCompact,
-                _ => unreachable!(),
-            })
-            .unwrap_or(if verbose {
-                OutputFormat::DisplayVerbose
-            } else {
-                OutputFormat::Display
-            });
-
-        let nonce_account = pubkey_of_signer(matches, NONCE_ARG.name, wallet_manager)
-            .unwrap_or_else(|e| {
-                eprintln!("error: {}", e);
-                exit(1);
-            });
-        let nonce_authority = if nonce_account.is_some() {
-            let (nonce_authority, _) = signer_from_path(
-                matches,
-                matches
-                    .value_of(NONCE_AUTHORITY_ARG.name)
-                    .unwrap_or(&cli_config.keypair_path),
-                NONCE_AUTHORITY_ARG.name,
-                wallet_manager,
-            )
-            .map(Arc::from)
-            .map(|s: Arc<dyn Signer>| {
-                let p = s.pubkey();
-                (s, p)
-            })
-            .unwrap_or_else(|e| {
-                eprintln!("error: {}", e);
-                exit(1);
-            });
-
-            Some(nonce_authority)
-        } else {
-            None
-        };
-
-        let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
-        let dump_transaction_message = matches.is_present(DUMP_TRANSACTION_MESSAGE.name);
-
-        let default_program_id = spl_token::id();
-        let (program_id, restrict_to_program_id) =
-            if let Some(program_id) = value_of(matches, "program_id") {
-                (program_id, true)
-            } else if !sign_only {
-                if let Some(address) = value_of(matches, "token")
-                    .or_else(|| value_of(matches, "account"))
-                    .or_else(|| value_of(matches, "address"))
-                {
-                    (
-                        rpc_client
-                            .get_account(&address)
-                            .await
-                            .map(|account| account.owner)
-                            .unwrap_or(default_program_id),
-                        false,
-                    )
-                } else {
-                    (default_program_id, false)
-                }
-            } else {
-                (default_program_id, false)
-            };
-
-        // need to specify a compute limit if compute price and blockhash are specified
-        if matches.is_present(BLOCKHASH_ARG.name)
-            && matches.is_present(COMPUTE_UNIT_PRICE_ARG.name)
-            && !matches.is_present(COMPUTE_UNIT_LIMIT_ARG.name)
-        {
-            clap::Error::with_description(
-                &format!(
-                    "Need to set `{}` if `{}` and `--{}` are set",
-                    COMPUTE_UNIT_LIMIT_ARG.long, COMPUTE_UNIT_PRICE_ARG.long, BLOCKHASH_ARG.long,
-                ),
-                clap::ErrorKind::MissingRequiredArgument,
-            )
-            .exit();
-        }
-
-        let nonce_blockhash = value_of(matches, BLOCKHASH_ARG.name);
-        let compute_unit_price = value_of(matches, COMPUTE_UNIT_PRICE_ARG.name);
-        let compute_unit_limit = value_of(matches, COMPUTE_UNIT_LIMIT_ARG.name)
-            .map(ComputeUnitLimit::Static)
-            .unwrap_or_else(|| {
-                if nonce_blockhash.is_some() {
-                    ComputeUnitLimit::Default
-                } else {
-                    ComputeUnitLimit::Simulated
-                }
-            });
-        Self {
-            default_signer,
-            rpc_client,
-            program_client,
-            websocket_url,
-            output_format,
-            fee_payer,
-            nonce_account,
-            nonce_authority,
-            nonce_blockhash,
-            sign_only,
-            dump_transaction_message,
-            multisigner_pubkeys,
-            program_id,
-            restrict_to_program_id,
-            compute_unit_price,
-            compute_unit_limit,
-        }
-    }
-
-    // Returns Ok(default signer), or Err if there is no default signer configured
-    pub(crate) fn default_signer(&self) -> Result<Arc<dyn Signer>, Error> {
-        if let Some(default_signer) = &self.default_signer {
-            Ok(default_signer.clone())
-        } else {
-            Err("default signer is required, please specify a valid default signer by identifying a \
-                 valid configuration file using the --config argument, or by creating a valid config \
-                 at the default location of ~/.config/solana/cli/config.yml using the solana config \
-                 command".to_string().into())
-        }
-    }
-
-    // Returns Ok(fee payer), or Err if there is no fee payer configured
-    pub fn fee_payer(&self) -> Result<Arc<dyn Signer>, Error> {
-        if let Some(fee_payer) = &self.fee_payer {
-            Ok(fee_payer.clone())
-        } else {
-            Err("fee payer is required, please specify a valid fee payer using the --fee-payer argument, \
-                 or by identifying a valid configuration file using the --config argument, or by creating \
-                 a valid config at the default location of ~/.config/solana/cli/config.yml using the solana \
-                 config command".to_string().into())
-        }
-    }
-
-    // Check if an explicit token account address was provided, otherwise
-    // return the associated token address for the default address.
-    pub(crate) async fn associated_token_address_or_override(
-        &self,
-        arg_matches: &ArgMatches<'_>,
-        override_name: &str,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    ) -> Result<Pubkey, Error> {
-        let token = pubkey_of_signer(arg_matches, "token", wallet_manager)
-            .map_err(|e| -> Error { e.to_string().into() })?;
-        self.associated_token_address_for_token_or_override(
-            arg_matches,
-            override_name,
-            wallet_manager,
-            token,
-        )
-        .await
-    }
-
-    // Check if an explicit token account address was provided, otherwise
-    // return the associated token address for the default address.
-    pub(crate) async fn associated_token_address_for_token_or_override(
-        &self,
-        arg_matches: &ArgMatches<'_>,
-        override_name: &str,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-        token: Option<Pubkey>,
-    ) -> Result<Pubkey, Error> {
-        if let Some(address) = pubkey_of_signer(arg_matches, override_name, wallet_manager)
-            .map_err(|e| -> Error { e.to_string().into() })?
-        {
-            return Ok(address);
-        }
-
-        let token = token.unwrap();
-        let program_id = self.get_mint_info(&token, None).await?.program_id;
-        let owner = self.pubkey_or_default(arg_matches, "owner", wallet_manager)?;
-        self.associated_token_address_for_token_and_program(&token, &owner, &program_id)
-    }
-
-    pub(crate) fn associated_token_address_for_token_and_program(
-        &self,
-        token: &Pubkey,
-        owner: &Pubkey,
-        program_id: &Pubkey,
-    ) -> Result<Pubkey, Error> {
-        Ok(get_associated_token_address_with_program_id(
-            owner, token, program_id,
-        ))
-    }
-
-    // Checks if an explicit address was provided, otherwise return the default
-    // address if there is one
-    pub(crate) fn pubkey_or_default(
-        &self,
-        arg_matches: &ArgMatches<'_>,
-        address_name: &str,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    ) -> Result<Pubkey, Error> {
-        if let Some(address) = pubkey_of_signer(arg_matches, address_name, wallet_manager)
-            .map_err(|e| -> Error { e.to_string().into() })?
-        {
-            return Ok(address);
-        }
-
-        Ok(self.default_signer()?.pubkey())
-    }
-
-    // Checks if an explicit signer was provided, otherwise return the default
-    // signer.
-    pub(crate) fn signer_or_default(
-        &self,
-        arg_matches: &ArgMatches,
-        authority_name: &str,
-        wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
-    ) -> (Arc<dyn Signer>, Pubkey) {
-        // If there are `--multisig-signers` on the command line, allow `NullSigner`s to
-        // be returned for multisig account addresses
-        let config = SignerFromPathConfig {
-            allow_null_signer: !self.multisigner_pubkeys.is_empty(),
-        };
-        let mut load_authority = move || -> Result<Arc<dyn Signer>, Error> {
-            if authority_name != "owner" {
-                if let Some(keypair_path) = arg_matches.value_of(authority_name) {
-                    return signer_from_path_with_config(
-                        arg_matches,
-                        keypair_path,
-                        authority_name,
-                        wallet_manager,
-                        &config,
-                    )
-                    .map(Arc::from)
-                    .map_err(|e| e.to_string().into());
-                }
-            }
-
-            self.default_signer()
-        };
-
-        let authority = load_authority().unwrap_or_else(|e| {
-            eprintln!("error: {}", e);
-            exit(1);
-        });
-
-        let authority_address = authority.pubkey();
-        (authority, authority_address)
-    }
-
-    pub(crate) async fn get_account_checked(
-        &self,
-        account_pubkey: &Pubkey,
-    ) -> Result<RawAccount, Error> {
-        if let Ok(Some(account)) = self.program_client.get_account(*account_pubkey).await {
-            if self.program_id == account.owner {
-                Ok(account)
-            } else {
-                Err(format!(
-                    "Account {} is owned by {}, not configured program id {}",
-                    account_pubkey, account.owner, self.program_id
-                )
-                .into())
-            }
-        } else {
-            Err(format!("Account {} not found", account_pubkey).into())
-        }
-    }
-
-    pub(crate) async fn get_mint_info(
-        &self,
-        mint: &Pubkey,
-        mint_decimals: Option<u8>,
-    ) -> Result<MintInfo, Error> {
-        if self.sign_only {
-            Ok(MintInfo {
-                program_id: self.program_id,
-                address: *mint,
-                decimals: mint_decimals.unwrap_or_default(),
-            })
-        } else {
-            let account = self.get_account_checked(mint).await?;
-            let mint_account = StateWithExtensionsOwned::<Mint>::unpack(account.data)
-                .map_err(|_| format!("Could not find mint account {}", mint))?;
-            if let Some(decimals) = mint_decimals {
-                if decimals != mint_account.base.decimals {
-                    return Err(format!(
-                        "Mint {:?} has decimals {}, not configured decimals {}",
-                        mint, mint_account.base.decimals, decimals
-                    )
-                    .into());
-                }
-            }
-            Ok(MintInfo {
-                program_id: account.owner,
-                address: *mint,
-                decimals: mint_account.base.decimals,
-            })
-        }
-    }
-
-    pub(crate) async fn check_account(
-        &self,
-        token_account: &Pubkey,
-        mint_address: Option<Pubkey>,
-    ) -> Result<Pubkey, Error> {
-        if !self.sign_only {
-            let account = self.get_account_checked(token_account).await?;
-            let source_account = StateWithExtensionsOwned::<Account>::unpack(account.data)
-                .map_err(|_| format!("Could not find token account {}", token_account))?;
-            let source_mint = source_account.base.mint;
-            if let Some(mint) = mint_address {
-                if source_mint != mint {
-                    return Err(format!(
-                        "Source {:?} does not contain {:?} tokens",
-                        token_account, mint
-                    )
-                    .into());
-                }
-            }
-            Ok(source_mint)
-        } else {
-            Ok(mint_address.unwrap_or_default())
-        }
-    }
-}
diff --git a/token/cli/src/encryption_keypair.rs b/token/cli/src/encryption_keypair.rs
deleted file mode 100644
index 302c21520d9..00000000000
--- a/token/cli/src/encryption_keypair.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! Temporary ElGamal keypair argument parser.
-//!
-//! NOTE: this module should be remoeved in the next Solana upgrade.
-
-use {
-    base64::{prelude::BASE64_STANDARD, Engine},
-    clap::ArgMatches,
-    spl_token_2022::solana_zk_token_sdk::{
-        encryption::elgamal::{ElGamalKeypair, ElGamalPubkey},
-        zk_token_elgamal::pod::ElGamalPubkey as PodElGamalPubkey,
-    },
-};
-
-const ELGAMAL_PUBKEY_MAX_BASE64_LEN: usize = 44;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) enum ElGamalPubkeyOrNone {
-    ElGamalPubkey(PodElGamalPubkey),
-    None,
-}
-
-impl From<ElGamalPubkeyOrNone> for Option<PodElGamalPubkey> {
-    fn from(val: ElGamalPubkeyOrNone) -> Self {
-        match val {
-            ElGamalPubkeyOrNone::ElGamalPubkey(pubkey) => Some(pubkey),
-            ElGamalPubkeyOrNone::None => None,
-        }
-    }
-}
-
-pub(crate) fn elgamal_pubkey_or_none(
-    matches: &ArgMatches,
-    name: &str,
-) -> Result<ElGamalPubkeyOrNone, String> {
-    let arg_str = matches.value_of(name).unwrap();
-    if arg_str == "none" {
-        return Ok(ElGamalPubkeyOrNone::None);
-    }
-    let elgamal_pubkey = elgamal_pubkey_of(matches, name)?;
-    Ok(ElGamalPubkeyOrNone::ElGamalPubkey(elgamal_pubkey))
-}
-
-pub(crate) fn elgamal_pubkey_of(
-    matches: &ArgMatches,
-    name: &str,
-) -> Result<PodElGamalPubkey, String> {
-    if let Ok(keypair) = elgamal_keypair_of(matches, name) {
-        let elgamal_pubkey = (*keypair.pubkey()).into();
-        Ok(elgamal_pubkey)
-    } else {
-        let arg_str = matches.value_of(name).unwrap();
-        if let Some(pubkey) = elgamal_pubkey_from_str(arg_str) {
-            Ok(pubkey)
-        } else {
-            Err("failed to read ElGamal pubkey".to_string())
-        }
-    }
-}
-
-pub(crate) fn elgamal_keypair_of(
-    matches: &ArgMatches,
-    name: &str,
-) -> Result<ElGamalKeypair, String> {
-    let path = matches.value_of(name).unwrap();
-    ElGamalKeypair::read_json_file(path).map_err(|e| e.to_string())
-}
-
-fn elgamal_pubkey_from_str(s: &str) -> Option<PodElGamalPubkey> {
-    if s.len() > ELGAMAL_PUBKEY_MAX_BASE64_LEN {
-        return None;
-    }
-    let pubkey_vec = BASE64_STANDARD.decode(s).ok()?;
-    let elgamal_pubkey = ElGamalPubkey::from_bytes(&pubkey_vec)?;
-    Some(elgamal_pubkey.into())
-}
diff --git a/token/cli/src/lib.rs b/token/cli/src/lib.rs
deleted file mode 100644
index b38c26b44fd..00000000000
--- a/token/cli/src/lib.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-mod bench;
-pub mod clap_app;
-pub mod command;
-pub mod config;
-mod encryption_keypair;
-mod output;
-mod sort;
diff --git a/token/cli/src/main.rs b/token/cli/src/main.rs
deleted file mode 100644
index 6566efe8d1e..00000000000
--- a/token/cli/src/main.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use {
-    solana_sdk::signer::Signer,
-    spl_token_cli::{clap_app::*, command::process_command, config::Config},
-    std::{str::FromStr, sync::Arc},
-};
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    let default_decimals = format!("{}", spl_token_2022::native_mint::DECIMALS);
-    let minimum_signers_help = minimum_signers_help_string();
-    let multisig_member_help = multisig_member_help_string();
-    let app_matches = app(
-        &default_decimals,
-        &minimum_signers_help,
-        &multisig_member_help,
-    )
-    .get_matches();
-
-    let mut wallet_manager = None;
-    let mut bulk_signers: Vec<Arc<dyn Signer>> = Vec::new();
-
-    let (sub_command, sub_matches) = app_matches.subcommand();
-    let sub_command = CommandName::from_str(sub_command).unwrap();
-    let matches = sub_matches.unwrap();
-
-    let mut multisigner_ids = Vec::new();
-    let config = Config::new(
-        matches,
-        &mut wallet_manager,
-        &mut bulk_signers,
-        &mut multisigner_ids,
-    )
-    .await;
-
-    solana_logger::setup_with_default("solana=info");
-    let result =
-        process_command(&sub_command, matches, &config, wallet_manager, bulk_signers).await?;
-    println!("{}", result);
-    Ok(())
-}
diff --git a/token/cli/src/output.rs b/token/cli/src/output.rs
deleted file mode 100644
index 97964c3b51f..00000000000
--- a/token/cli/src/output.rs
+++ /dev/null
@@ -1,1005 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-use {
-    crate::{config::Config, sort::UnsupportedAccount},
-    console::{style, Emoji},
-    serde::{Deserialize, Serialize, Serializer},
-    solana_account_decoder::{
-        parse_token::{UiAccountState, UiMint, UiMultisig, UiTokenAccount, UiTokenAmount},
-        parse_token_extension::{
-            UiConfidentialTransferAccount, UiConfidentialTransferFeeAmount,
-            UiConfidentialTransferFeeConfig, UiConfidentialTransferMint, UiCpiGuard,
-            UiDefaultAccountState, UiExtension, UiGroupMemberPointer, UiGroupPointer,
-            UiInterestBearingConfig, UiMemoTransfer, UiMetadataPointer, UiMintCloseAuthority,
-            UiPermanentDelegate, UiTokenGroup, UiTokenGroupMember, UiTokenMetadata,
-            UiTransferFeeAmount, UiTransferFeeConfig, UiTransferHook, UiTransferHookAccount,
-        },
-    },
-    solana_cli_output::{display::writeln_name_value, OutputFormat, QuietDisplay, VerboseDisplay},
-    std::fmt::{self, Display},
-};
-
-pub(crate) trait Output: Serialize + fmt::Display + QuietDisplay + VerboseDisplay {}
-
-static WARNING: Emoji = Emoji("⚠️", "!");
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    pub(crate) command_name: String,
-    pub(crate) command_output: T,
-}
-
-impl<T> Display for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.command_output, f)
-    }
-}
-
-impl<T> QuietDisplay for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        QuietDisplay::write_str(&self.command_output, w)
-    }
-}
-
-impl<T> VerboseDisplay for CommandOutput<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        writeln_name_value(w, "Command: ", &self.command_name)?;
-        VerboseDisplay::write_str(&self.command_output, w)
-    }
-}
-
-pub(crate) fn println_display(config: &Config, message: String) {
-    match config.output_format {
-        OutputFormat::Display | OutputFormat::DisplayVerbose => {
-            println!("{}", message);
-        }
-        _ => {}
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliCreateToken<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    pub(crate) address: String,
-    pub(crate) decimals: u8,
-    pub(crate) transaction_data: T,
-}
-
-impl<T> Display for CliCreateToken<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f)?;
-        writeln_name_value(f, "Address: ", &self.address)?;
-        writeln_name_value(f, "Decimals: ", &format!("{}", self.decimals))?;
-        Display::fmt(&self.transaction_data, f)
-    }
-}
-impl<T> QuietDisplay for CliCreateToken<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        writeln!(w)?;
-        writeln_name_value(w, "Address: ", &self.address)?;
-        writeln_name_value(w, "Decimals: ", &format!("{}", self.decimals))?;
-        QuietDisplay::write_str(&self.transaction_data, w)
-    }
-}
-impl<T> VerboseDisplay for CliCreateToken<T>
-where
-    T: Serialize + Display + QuietDisplay + VerboseDisplay,
-{
-    fn write_str(&self, w: &mut dyn std::fmt::Write) -> std::fmt::Result {
-        writeln!(w)?;
-        writeln_name_value(w, "Address: ", &self.address)?;
-        writeln_name_value(w, "Decimals: ", &format!("{}", self.decimals))?;
-        VerboseDisplay::write_str(&self.transaction_data, w)
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliTokenAmount {
-    #[serde(flatten)]
-    pub(crate) amount: UiTokenAmount,
-}
-
-impl QuietDisplay for CliTokenAmount {}
-impl VerboseDisplay for CliTokenAmount {
-    fn write_str(&self, w: &mut dyn fmt::Write) -> fmt::Result {
-        writeln!(w, "ui amount: {}", self.amount.real_number_string_trimmed())?;
-        writeln!(w, "decimals: {}", self.amount.decimals)?;
-        writeln!(w, "amount: {}", self.amount.amount)
-    }
-}
-
-impl fmt::Display for CliTokenAmount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "{}", self.amount.real_number_string_trimmed())
-    }
-}
-
-#[derive(Default, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliWalletAddress {
-    pub(crate) wallet_address: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(crate) associated_token_address: Option<String>,
-}
-
-impl QuietDisplay for CliWalletAddress {}
-impl VerboseDisplay for CliWalletAddress {}
-
-impl fmt::Display for CliWalletAddress {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "Wallet address: {}", self.wallet_address)?;
-        if let Some(associated_token_address) = &self.associated_token_address {
-            writeln!(f, "Associated token address: {}", associated_token_address)?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliMultisig {
-    pub(crate) address: String,
-    pub(crate) program_id: String,
-    #[serde(flatten)]
-    pub(crate) multisig: UiMultisig,
-}
-
-impl QuietDisplay for CliMultisig {}
-impl VerboseDisplay for CliMultisig {}
-
-impl fmt::Display for CliMultisig {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let m = self.multisig.num_required_signers;
-        let n = self.multisig.num_valid_signers;
-
-        writeln!(f)?;
-        writeln!(f, "{}", style("SPL Token Multisig").bold())?;
-        writeln_name_value(f, "  Address:", &self.address)?;
-        writeln_name_value(f, "  Program:", &self.program_id)?;
-        writeln_name_value(f, "  M/N:", &format!("{}/{}", m, n))?;
-        writeln!(f, "  {}", style("Signers:").bold())?;
-        let width = if n >= 9 { 4 } else { 3 };
-        for i in 0..n as usize {
-            let title = format!("  {1:>0$}:", width, i + 1);
-            let pubkey = &self.multisig.signers[i];
-            writeln_name_value(f, &title, pubkey)?;
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliTokenAccount {
-    pub(crate) address: String,
-    pub(crate) program_id: String,
-    pub(crate) is_associated: bool,
-    #[serde(flatten)]
-    pub(crate) account: UiTokenAccount,
-    #[serde(skip_serializing)]
-    pub(crate) has_permanent_delegate: bool,
-}
-
-impl QuietDisplay for CliTokenAccount {}
-impl VerboseDisplay for CliTokenAccount {}
-
-impl fmt::Display for CliTokenAccount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln!(f, "{}", style("SPL Token Account").bold())?;
-        if self.is_associated {
-            writeln_name_value(f, "  Address:", &self.address)?;
-        } else {
-            writeln_name_value(f, "  Address:", &format!("{}  (Aux*)", self.address))?;
-        }
-        writeln_name_value(f, "  Program:", &self.program_id)?;
-        writeln_name_value(
-            f,
-            "  Balance:",
-            &self.account.token_amount.real_number_string_trimmed(),
-        )?;
-        writeln_name_value(
-            f,
-            "  Decimals:",
-            self.account.token_amount.decimals.to_string().as_ref(),
-        )?;
-        let mint = format!(
-            "{}{}",
-            self.account.mint,
-            if self.account.is_native {
-                " (native)"
-            } else {
-                ""
-            }
-        );
-        writeln_name_value(f, "  Mint:", &mint)?;
-        writeln_name_value(f, "  Owner:", &self.account.owner)?;
-        writeln_name_value(f, "  State:", &format!("{:?}", self.account.state))?;
-        if let Some(delegate) = &self.account.delegate {
-            writeln!(f, "  {}", style("Delegation:").bold())?;
-            writeln_name_value(f, "    Delegate:", delegate)?;
-            let allowance = self.account.delegated_amount.as_ref().unwrap();
-            writeln_name_value(f, "    Allowance:", &allowance.real_number_string_trimmed())?;
-        } else {
-            writeln_name_value(f, "  Delegation:", "")?;
-        }
-        writeln_name_value(
-            f,
-            "  Close authority:",
-            self.account
-                .close_authority
-                .as_ref()
-                .unwrap_or(&String::new()),
-        )?;
-
-        if !self.account.extensions.is_empty() {
-            writeln!(f, "{}", style("Extensions:").bold())?;
-            for extension in &self.account.extensions {
-                display_ui_extension(f, 0, extension)?;
-            }
-        }
-
-        if !self.is_associated {
-            writeln!(f)?;
-            writeln!(f, "* Please run `spl-token gc` to clean up Aux accounts")?;
-        }
-
-        if self.has_permanent_delegate {
-            writeln!(f)?;
-            writeln!(
-                f,
-                "* {} ",
-                style("This token has a permanent delegate!").bold()
-            )?;
-            writeln!(
-                f,
-                "  This means the mint may withdraw {} funds from this account at {} time.",
-                style("all").bold(),
-                style("any").bold(),
-            )?;
-            writeln!(f, "  If this was not adequately disclosed to you, you may be dealing with a malicious mint.")?;
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliMint {
-    pub(crate) address: String,
-    pub(crate) program_id: String,
-    #[serde(skip_serializing)]
-    pub(crate) epoch: u64,
-    #[serde(flatten)]
-    pub(crate) mint: UiMint,
-}
-
-impl QuietDisplay for CliMint {}
-impl VerboseDisplay for CliMint {}
-
-impl fmt::Display for CliMint {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f)?;
-        writeln!(f, "{}", style("SPL Token Mint").bold())?;
-
-        writeln_name_value(f, "  Address:", &self.address)?;
-        writeln_name_value(f, "  Program:", &self.program_id)?;
-        writeln_name_value(f, "  Supply:", &self.mint.supply)?;
-        writeln_name_value(f, "  Decimals:", &self.mint.decimals.to_string())?;
-        writeln_name_value(
-            f,
-            "  Mint authority:",
-            self.mint.mint_authority.as_ref().unwrap_or(&String::new()),
-        )?;
-        writeln_name_value(
-            f,
-            "  Freeze authority:",
-            self.mint
-                .freeze_authority
-                .as_ref()
-                .unwrap_or(&String::new()),
-        )?;
-
-        if !self.mint.extensions.is_empty() {
-            writeln!(f, "{}", style("Extensions").bold())?;
-            for extension in &self.mint.extensions {
-                display_ui_extension(f, self.epoch, extension)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct CliTokenAccounts {
-    #[serde(serialize_with = "flattened")]
-    pub(crate) accounts: Vec<Vec<CliTokenAccount>>,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub(crate) unsupported_accounts: Vec<UnsupportedAccount>,
-    #[serde(skip_serializing)]
-    pub(crate) max_len_balance: usize,
-    #[serde(skip_serializing)]
-    pub(crate) aux_len: usize,
-    #[serde(skip_serializing)]
-    pub(crate) explicit_token: bool,
-}
-
-impl QuietDisplay for CliTokenAccounts {}
-impl VerboseDisplay for CliTokenAccounts {
-    fn write_str(&self, w: &mut dyn fmt::Write) -> fmt::Result {
-        let mut gc_alert = false;
-
-        let mut delegate_padding = 9;
-        let mut close_authority_padding = 15;
-        for accounts_list in self.accounts.iter() {
-            for account in accounts_list {
-                if account.account.delegated_amount.is_some() {
-                    delegate_padding = delegate_padding.max(
-                        account
-                            .account
-                            .delegated_amount
-                            .as_ref()
-                            .unwrap()
-                            .amount
-                            .len(),
-                    );
-                }
-
-                if account.account.close_authority.is_some() {
-                    close_authority_padding = 44;
-                }
-            }
-        }
-
-        let header = if self.explicit_token {
-            format!(
-                "{:<44}  {:<44}  {:<5$}  {:<6$}  {:<7$}",
-                "Program",
-                "Account",
-                "Delegated",
-                "Close Authority",
-                "Balance",
-                delegate_padding,
-                close_authority_padding,
-                self.max_len_balance
-            )
-        } else {
-            format!(
-                "{:<44}  {:<44}  {:<44}  {:<6$}  {:<7$}  {:<8$}",
-                "Program",
-                "Token",
-                "Account",
-                "Delegated",
-                "Close Authority",
-                "Balance",
-                delegate_padding,
-                close_authority_padding,
-                self.max_len_balance
-            )
-        };
-        writeln!(w, "{}", header)?;
-        writeln!(w, "{}", "-".repeat(header.len() + self.aux_len))?;
-
-        for accounts_list in self.accounts.iter() {
-            let mut aux_counter = 1;
-            for account in accounts_list {
-                let maybe_aux = if !account.is_associated {
-                    gc_alert = true;
-                    let message = format!("  (Aux-{}*)", aux_counter);
-                    aux_counter += 1;
-                    message
-                } else {
-                    "".to_string()
-                };
-
-                let maybe_frozen = if let UiAccountState::Frozen = account.account.state {
-                    format!(" {}  Frozen", WARNING)
-                } else {
-                    "".to_string()
-                };
-
-                let maybe_delegated = account
-                    .account
-                    .delegated_amount
-                    .clone()
-                    .map(|d| d.amount)
-                    .unwrap_or_else(|| "".to_string());
-
-                let maybe_close_authority =
-                    account.account.close_authority.clone().unwrap_or_default();
-
-                if self.explicit_token {
-                    writeln!(
-                        w,
-                        "{:<44}  {:<44}  {:<7$}  {:<8$}  {:<9$}{:<10$}{}",
-                        account.program_id,
-                        account.address,
-                        maybe_delegated,
-                        maybe_close_authority,
-                        account.account.token_amount.real_number_string_trimmed(),
-                        maybe_aux,
-                        maybe_frozen,
-                        delegate_padding,
-                        close_authority_padding,
-                        self.max_len_balance,
-                        self.aux_len,
-                    )?;
-                } else {
-                    writeln!(
-                        w,
-                        "{:<44}  {:<44}  {:<44}  {:<8$}  {:<9$}  {:<10$}{:<11$}{}",
-                        account.program_id,
-                        account.account.mint,
-                        account.address,
-                        maybe_delegated,
-                        maybe_close_authority,
-                        account.account.token_amount.real_number_string_trimmed(),
-                        maybe_aux,
-                        maybe_frozen,
-                        delegate_padding,
-                        close_authority_padding,
-                        self.max_len_balance,
-                        self.aux_len,
-                    )?;
-                }
-            }
-        }
-        for unsupported_account in &self.unsupported_accounts {
-            writeln!(
-                w,
-                "{:<44}  {}",
-                unsupported_account.address, unsupported_account.err
-            )?;
-        }
-        if gc_alert {
-            writeln!(w)?;
-            writeln!(w, "* Please run `spl-token gc` to clean up Aux accounts")?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for CliTokenAccounts {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut gc_alert = false;
-        let header = if self.explicit_token {
-            format!("{:<1$}", "Balance", self.max_len_balance)
-        } else {
-            format!("{:<44}  {:<2$}", "Token", "Balance", self.max_len_balance)
-        };
-        writeln!(f, "{}", header)?;
-        writeln!(f, "{}", "-".repeat(header.len() + self.aux_len))?;
-
-        for accounts_list in self.accounts.iter() {
-            let mut aux_counter = 1;
-            for account in accounts_list {
-                let maybe_aux = if !account.is_associated {
-                    gc_alert = true;
-                    let message = format!("  (Aux-{}*)", aux_counter);
-                    aux_counter += 1;
-                    message
-                } else {
-                    "".to_string()
-                };
-                let maybe_frozen = if let UiAccountState::Frozen = account.account.state {
-                    format!(" {}  Frozen", WARNING)
-                } else {
-                    "".to_string()
-                };
-                if self.explicit_token {
-                    writeln!(
-                        f,
-                        "{:<3$}{:<4$}{}",
-                        account.account.token_amount.real_number_string_trimmed(),
-                        maybe_aux,
-                        maybe_frozen,
-                        self.max_len_balance,
-                        self.aux_len,
-                    )?;
-                } else {
-                    writeln!(
-                        f,
-                        "{:<44}  {:<4$}{:<5$}{}",
-                        account.account.mint,
-                        account.account.token_amount.real_number_string_trimmed(),
-                        maybe_aux,
-                        maybe_frozen,
-                        self.max_len_balance,
-                        self.aux_len,
-                    )?;
-                }
-            }
-        }
-        for unsupported_account in &self.unsupported_accounts {
-            writeln!(
-                f,
-                "{:<44}  {}",
-                unsupported_account.address, unsupported_account.err
-            )?;
-        }
-        if gc_alert {
-            writeln!(f)?;
-            writeln!(f, "* Please run `spl-token gc` to clean up Aux accounts")?;
-        }
-        Ok(())
-    }
-}
-
-fn display_ui_extension(
-    f: &mut fmt::Formatter,
-    epoch: u64,
-    ui_extension: &UiExtension,
-) -> fmt::Result {
-    match ui_extension {
-        UiExtension::TransferFeeConfig(UiTransferFeeConfig {
-            transfer_fee_config_authority,
-            withdraw_withheld_authority,
-            withheld_amount,
-            older_transfer_fee,
-            newer_transfer_fee,
-        }) => {
-            writeln!(f, "  {}", style("Transfer fees:").bold())?;
-
-            if epoch >= newer_transfer_fee.epoch {
-                writeln!(
-                    f,
-                    "    {} {}bps",
-                    style("Current fee:").bold(),
-                    newer_transfer_fee.transfer_fee_basis_points
-                )?;
-                writeln_name_value(
-                    f,
-                    "    Current maximum:",
-                    &newer_transfer_fee.maximum_fee.to_string(),
-                )?;
-            } else {
-                writeln!(
-                    f,
-                    "    {} {}bps",
-                    style("Current fee:").bold(),
-                    older_transfer_fee.transfer_fee_basis_points
-                )?;
-                writeln_name_value(
-                    f,
-                    "    Current maximum:",
-                    &older_transfer_fee.maximum_fee.to_string(),
-                )?;
-                writeln!(
-                    f,
-                    "    {} {}bps",
-                    style("Upcoming fee:").bold(),
-                    newer_transfer_fee.transfer_fee_basis_points
-                )?;
-                writeln_name_value(
-                    f,
-                    "    Upcoming maximum:",
-                    &newer_transfer_fee.maximum_fee.to_string(),
-                )?;
-                writeln!(
-                    f,
-                    "    {} Epoch {} ({} epochs)",
-                    style("Switchover at:").bold(),
-                    newer_transfer_fee.epoch,
-                    newer_transfer_fee.epoch - epoch
-                )?;
-            }
-
-            writeln_name_value(
-                f,
-                "    Config authority:",
-                transfer_fee_config_authority
-                    .as_ref()
-                    .unwrap_or(&String::new()),
-            )?;
-            writeln_name_value(
-                f,
-                "    Withdrawal authority:",
-                withdraw_withheld_authority
-                    .as_ref()
-                    .unwrap_or(&String::new()),
-            )?;
-            writeln_name_value(f, "    Withheld fees:", &withheld_amount.to_string())
-        }
-        UiExtension::TransferFeeAmount(UiTransferFeeAmount { withheld_amount }) => {
-            writeln_name_value(f, "  Transfer fees withheld:", &withheld_amount.to_string())
-        }
-        UiExtension::MintCloseAuthority(UiMintCloseAuthority { close_authority }) => {
-            if let Some(close_authority) = close_authority {
-                writeln_name_value(f, "  Close authority:", close_authority)
-            } else {
-                Ok(())
-            }
-        }
-        UiExtension::DefaultAccountState(UiDefaultAccountState { account_state }) => {
-            writeln_name_value(f, "  Default state:", &format!("{:?}", account_state))
-        }
-        UiExtension::ImmutableOwner => writeln!(f, "  {}", style("Immutable owner").bold()),
-        UiExtension::MemoTransfer(UiMemoTransfer {
-            require_incoming_transfer_memos,
-        }) => writeln_name_value(
-            f,
-            "  Transfer memo:",
-            if *require_incoming_transfer_memos {
-                "Required"
-            } else {
-                "Not required"
-            },
-        ),
-        UiExtension::NonTransferable | UiExtension::NonTransferableAccount => {
-            writeln!(f, "  {}", style("Non-transferable").bold())
-        }
-        UiExtension::InterestBearingConfig(UiInterestBearingConfig {
-            rate_authority,
-            pre_update_average_rate,
-            current_rate,
-            ..
-        }) => {
-            writeln!(f, "  {}", style("Interest-bearing:").bold())?;
-            writeln!(
-                f,
-                "    {} {}bps",
-                style("Current rate:").bold(),
-                current_rate
-            )?;
-            writeln!(
-                f,
-                "    {} {}bps",
-                style("Average rate:").bold(),
-                pre_update_average_rate
-            )?;
-            writeln_name_value(
-                f,
-                "    Rate authority:",
-                rate_authority.as_ref().unwrap_or(&String::new()),
-            )
-        }
-        UiExtension::CpiGuard(UiCpiGuard { lock_cpi }) => writeln_name_value(
-            f,
-            "  CPI Guard:",
-            if *lock_cpi { "Enabled" } else { "Disabled" },
-        ),
-        UiExtension::PermanentDelegate(UiPermanentDelegate { delegate }) => {
-            if let Some(delegate) = delegate {
-                writeln_name_value(f, "  Permanent delegate:", delegate)
-            } else {
-                Ok(())
-            }
-        }
-        UiExtension::ConfidentialTransferAccount(UiConfidentialTransferAccount {
-            approved,
-            elgamal_pubkey,
-            pending_balance_lo,
-            pending_balance_hi,
-            available_balance,
-            decryptable_available_balance,
-            allow_confidential_credits,
-            allow_non_confidential_credits,
-            pending_balance_credit_counter,
-            maximum_pending_balance_credit_counter,
-            expected_pending_balance_credit_counter,
-            actual_pending_balance_credit_counter,
-        }) => {
-            writeln!(f, "  {}", style("Confidential transfer:").bold())?;
-            writeln_name_value(f, "    Approved:", &format!("{approved}"))?;
-            writeln_name_value(f, "    Encryption key:", elgamal_pubkey)?;
-            writeln_name_value(f, "    Pending Balance Low:", pending_balance_lo)?;
-            writeln_name_value(f, "    Pending Balance High:", pending_balance_hi)?;
-            writeln_name_value(f, "    Available Balance:", available_balance)?;
-            writeln_name_value(
-                f,
-                "    Decryptable Available Balance:",
-                decryptable_available_balance,
-            )?;
-            writeln_name_value(
-                f,
-                "    Confidential Credits:",
-                if *allow_confidential_credits {
-                    "Enabled"
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Non-Confidential Credits:",
-                if *allow_non_confidential_credits {
-                    "Enabled"
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Pending Balance Credit Counter:",
-                &format!("{pending_balance_credit_counter}"),
-            )?;
-            writeln_name_value(
-                f,
-                "    Maximum Pending Balance Credit Counter:",
-                &format!("{maximum_pending_balance_credit_counter}"),
-            )?;
-            writeln_name_value(
-                f,
-                "    Expected Pending Balance Credit Counter:",
-                &format!("{expected_pending_balance_credit_counter}"),
-            )?;
-            writeln_name_value(
-                f,
-                "    Actual Pending Balance Credit Counter:",
-                &format!("{actual_pending_balance_credit_counter}"),
-            )
-        }
-        UiExtension::ConfidentialTransferMint(UiConfidentialTransferMint {
-            authority,
-            auto_approve_new_accounts,
-            auditor_elgamal_pubkey,
-        }) => {
-            writeln!(f, "  {}", style("Confidential transfer:").bold())?;
-            writeln!(
-                f,
-                "    {}: {}",
-                style("Authority").bold(),
-                if let Some(authority) = authority.as_ref() {
-                    authority
-                } else {
-                    "authority disabled"
-                }
-            )?;
-            writeln!(
-                f,
-                "    {}: {}",
-                style("Account approve policy").bold(),
-                if *auto_approve_new_accounts {
-                    "auto"
-                } else {
-                    "manual"
-                },
-            )?;
-            writeln!(
-                f,
-                "    {}: {}",
-                style("Audit key").bold(),
-                if let Some(auditor_pubkey) = auditor_elgamal_pubkey.as_ref() {
-                    auditor_pubkey
-                } else {
-                    "audits are disabled"
-                }
-            )
-        }
-        UiExtension::ConfidentialTransferFeeConfig(UiConfidentialTransferFeeConfig {
-            authority,
-            withdraw_withheld_authority_elgamal_pubkey,
-            harvest_to_mint_enabled,
-            withheld_amount,
-        }) => {
-            writeln!(f, "  {}", style("Confidential transfer fee:").bold())?;
-            writeln_name_value(
-                f,
-                "    Authority:",
-                if let Some(pubkey) = authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Withdraw Withheld Encryption key:",
-                if let Some(pubkey) = withdraw_withheld_authority_elgamal_pubkey {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Harvest to mint:",
-                if *harvest_to_mint_enabled {
-                    "Enabled"
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(f, "    Withheld Amount:", withheld_amount)
-        }
-        UiExtension::ConfidentialTransferFeeAmount(UiConfidentialTransferFeeAmount {
-            withheld_amount,
-        }) => writeln_name_value(f, "  Confidential Transfer Fee Amount:", withheld_amount),
-        UiExtension::TransferHook(UiTransferHook {
-            authority,
-            program_id,
-        }) => {
-            writeln!(f, "  {}", style("Transfer Hook:").bold())?;
-            writeln_name_value(
-                f,
-                "    Authority:",
-                if let Some(pubkey) = authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Program Id:",
-                if let Some(pubkey) = program_id {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )
-        }
-        // don't display the "transferring" flag, since it's just for internal use
-        UiExtension::TransferHookAccount(UiTransferHookAccount { .. }) => Ok(()),
-        UiExtension::MetadataPointer(UiMetadataPointer {
-            authority,
-            metadata_address,
-        }) => {
-            writeln!(f, "  {}", style("Metadata Pointer:").bold())?;
-            writeln_name_value(
-                f,
-                "    Authority:",
-                if let Some(pubkey) = authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Metadata address:",
-                if let Some(pubkey) = metadata_address {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )
-        }
-        UiExtension::TokenMetadata(UiTokenMetadata {
-            update_authority,
-            mint,
-            name,
-            symbol,
-            uri,
-            additional_metadata,
-        }) => {
-            writeln!(f, "  {}", style("Metadata:").bold())?;
-            writeln_name_value(
-                f,
-                "    Update Authority:",
-                if let Some(pubkey) = update_authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(f, "    Mint:", mint)?;
-            writeln_name_value(f, "    Name:", name)?;
-            writeln_name_value(f, "    Symbol:", symbol)?;
-            writeln_name_value(f, "    URI:", uri)?;
-            for (key, value) in additional_metadata {
-                writeln_name_value(f, &format!("    {key}:"), value)?;
-            }
-            Ok(())
-        }
-        UiExtension::GroupPointer(UiGroupPointer {
-            authority,
-            group_address,
-        }) => {
-            writeln!(f, "  {}", style("Group Pointer:").bold())?;
-            writeln_name_value(
-                f,
-                "    Authority:",
-                if let Some(pubkey) = authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Group address:",
-                if let Some(pubkey) = group_address {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )
-        }
-        UiExtension::GroupMemberPointer(UiGroupMemberPointer {
-            authority,
-            member_address,
-        }) => {
-            writeln!(f, "  {}", style("Group Member Pointer:").bold())?;
-            writeln_name_value(
-                f,
-                "    Authority:",
-                if let Some(pubkey) = authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(
-                f,
-                "    Member address:",
-                if let Some(pubkey) = member_address {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )
-        }
-        UiExtension::TokenGroup(UiTokenGroup {
-            update_authority,
-            mint,
-            size,
-            max_size,
-        }) => {
-            writeln!(f, "  {}", style("Token Group:").bold())?;
-            writeln_name_value(
-                f,
-                "    Update Authority:",
-                if let Some(pubkey) = update_authority {
-                    pubkey
-                } else {
-                    "Disabled"
-                },
-            )?;
-            writeln_name_value(f, "    Mint:", mint)?;
-            writeln_name_value(f, "    Size:", &format!("{size}"))?;
-            writeln_name_value(f, "    Max Size:", &format!("{max_size}"))
-        }
-        UiExtension::TokenGroupMember(UiTokenGroupMember {
-            mint,
-            group,
-            member_number,
-        }) => {
-            writeln!(f, "  {}", style("Token Group Member:").bold())?;
-            writeln_name_value(f, "    Mint:", mint)?;
-            writeln_name_value(f, "    Group:", group)?;
-            writeln_name_value(f, "    Member Number:", &format!("{member_number}"))
-        }
-        // ExtensionType::Uninitialized is a hack to ensure a mint/account is never the same length
-        // as a multisig
-        UiExtension::Uninitialized => Ok(()),
-        UiExtension::UnparseableExtension => writeln_name_value(
-            f,
-            "  Unparseable extension:",
-            "Consider upgrading to a newer version of spl-token",
-        ),
-    }
-}
-
-fn flattened<S: Serializer>(
-    vec: &[Vec<CliTokenAccount>],
-    serializer: S,
-) -> Result<S::Ok, S::Error> {
-    let flattened: Vec<_> = vec.iter().flatten().collect();
-    flattened.serialize(serializer)
-}
diff --git a/token/cli/src/sort.rs b/token/cli/src/sort.rs
deleted file mode 100644
index 09423694519..00000000000
--- a/token/cli/src/sort.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-use {
-    crate::{
-        clap_app::Error,
-        output::{CliTokenAccount, CliTokenAccounts},
-    },
-    serde::{Deserialize, Serialize},
-    solana_account_decoder::{parse_token::TokenAccountType, UiAccountData},
-    solana_client::rpc_response::RpcKeyedAccount,
-    solana_sdk::pubkey::Pubkey,
-    spl_associated_token_account::get_associated_token_address_with_program_id,
-    std::{
-        collections::{btree_map::Entry, BTreeMap},
-        str::FromStr,
-    },
-};
-
-#[derive(Serialize, Deserialize)]
-pub(crate) struct UnsupportedAccount {
-    pub address: String,
-    pub err: String,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub(crate) enum AccountFilter {
-    Delegated,
-    ExternallyCloseable,
-    All,
-}
-
-pub(crate) fn sort_and_parse_token_accounts(
-    owner: &Pubkey,
-    accounts: Vec<RpcKeyedAccount>,
-    explicit_token: bool,
-    account_filter: AccountFilter,
-) -> Result<CliTokenAccounts, Error> {
-    let mut cli_accounts: BTreeMap<(Pubkey, Pubkey), Vec<CliTokenAccount>> = BTreeMap::new();
-    let mut unsupported_accounts = vec![];
-    let mut max_len_balance = 0;
-    let mut aux_count = 0;
-
-    for keyed_account in accounts {
-        let address_str = keyed_account.pubkey;
-        let address = Pubkey::from_str(&address_str)?;
-        let program_id = Pubkey::from_str(&keyed_account.account.owner)?;
-
-        if let UiAccountData::Json(parsed_account) = keyed_account.account.data {
-            match serde_json::from_value(parsed_account.parsed) {
-                Ok(TokenAccountType::Account(ui_token_account)) => {
-                    let mint = Pubkey::from_str(&ui_token_account.mint)?;
-                    let btree_key = (program_id, mint);
-                    let is_associated =
-                        get_associated_token_address_with_program_id(owner, &mint, &program_id)
-                            == address;
-
-                    match account_filter {
-                        AccountFilter::Delegated if ui_token_account.delegate.is_none() => continue,
-                        AccountFilter::ExternallyCloseable
-                            if ui_token_account.close_authority.is_none() =>
-                        {
-                            continue
-                        }
-                        _ => (),
-                    }
-
-                    if !is_associated {
-                        aux_count += 1;
-                    }
-
-                    max_len_balance = max_len_balance.max(
-                        ui_token_account
-                            .token_amount
-                            .real_number_string_trimmed()
-                            .len(),
-                    );
-
-                    let cli_account = CliTokenAccount {
-                        address: address_str,
-                        program_id: program_id.to_string(),
-                        account: ui_token_account,
-                        is_associated,
-                        has_permanent_delegate: false,
-                    };
-
-                    let entry = cli_accounts.entry(btree_key);
-                    match entry {
-                        Entry::Occupied(_) => {
-                            entry.and_modify(|e| {
-                                if is_associated {
-                                    e.insert(0, cli_account)
-                                } else {
-                                    e.push(cli_account)
-                                }
-                            });
-                        }
-                        Entry::Vacant(_) => {
-                            entry.or_insert_with(|| vec![cli_account]);
-                        }
-                    }
-                }
-                Ok(_) => unsupported_accounts.push(UnsupportedAccount {
-                    address: address_str,
-                    err: "Not a token account".to_string(),
-                }),
-                Err(err) => unsupported_accounts.push(UnsupportedAccount {
-                    address: address_str,
-                    err: format!("Account parse failure: {}", err),
-                }),
-            }
-        }
-    }
-
-    Ok(CliTokenAccounts {
-        accounts: cli_accounts.into_values().collect(),
-        unsupported_accounts,
-        max_len_balance,
-        aux_len: if aux_count > 0 {
-            format!("  (Aux-{}*)", aux_count).chars().count() + 1
-        } else {
-            0
-        },
-        explicit_token,
-    })
-}
diff --git a/token/cli/tests/command.rs b/token/cli/tests/command.rs
deleted file mode 100644
index a4c3dbe2066..00000000000
--- a/token/cli/tests/command.rs
+++ /dev/null
@@ -1,4106 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-use {
-    libtest_mimic::{Arguments, Trial},
-    solana_cli_output::OutputFormat,
-    solana_client::{nonblocking::rpc_client::RpcClient, rpc_request::TokenAccountsFilter},
-    solana_sdk::{
-        bpf_loader_upgradeable,
-        hash::Hash,
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{write_keypair_file, Keypair, Signer},
-        system_instruction, system_program,
-        transaction::Transaction,
-    },
-    solana_test_validator::{TestValidator, TestValidatorGenesis, UpgradeableProgramInfo},
-    spl_associated_token_account::get_associated_token_address_with_program_id,
-    spl_token_2022::{
-        extension::{
-            confidential_transfer::{ConfidentialTransferAccount, ConfidentialTransferMint},
-            confidential_transfer_fee::ConfidentialTransferFeeConfig,
-            cpi_guard::CpiGuard,
-            default_account_state::DefaultAccountState,
-            group_member_pointer::GroupMemberPointer,
-            group_pointer::GroupPointer,
-            interest_bearing_mint::InterestBearingConfig,
-            memo_transfer::MemoTransfer,
-            metadata_pointer::MetadataPointer,
-            non_transferable::NonTransferable,
-            transfer_fee::{TransferFeeAmount, TransferFeeConfig},
-            transfer_hook::TransferHook,
-            BaseStateWithExtensions, StateWithExtensionsOwned,
-        },
-        instruction::create_native_mint,
-        solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-        state::{Account, AccountState, Mint, Multisig},
-    },
-    spl_token_cli::{
-        clap_app::*,
-        command::{process_command, CommandResult},
-        config::Config,
-    },
-    spl_token_client::{
-        client::{
-            ProgramClient, ProgramOfflineClient, ProgramRpcClient, ProgramRpcClientSendTransaction,
-        },
-        token::{ComputeUnitLimit, Token},
-    },
-    spl_token_group_interface::state::{TokenGroup, TokenGroupMember},
-    spl_token_metadata_interface::state::TokenMetadata,
-    std::{
-        ffi::{OsStr, OsString},
-        path::PathBuf,
-        str::FromStr,
-        sync::Arc,
-    },
-    tempfile::NamedTempFile,
-};
-
-macro_rules! async_trial {
-    ($test_func:ident, $test_validator:ident, $payer:ident) => {{
-        let local_test_validator = $test_validator.clone();
-        let local_payer = $payer.clone();
-        Trial::test(stringify!($test_func), move || {
-            tokio::runtime::Builder::new_current_thread()
-                .enable_all()
-                .build()
-                .unwrap()
-                .block_on(async {
-                    $test_func(local_test_validator.as_ref(), local_payer.as_ref()).await
-                });
-            Ok(())
-        })
-    }};
-}
-
-#[tokio::main]
-async fn main() {
-    let args = Arguments::from_args();
-    let (test_validator, payer) = new_validator_for_test().await;
-    let test_validator = Arc::new(test_validator);
-    let payer = Arc::new(payer);
-
-    // setup the native mint to be used by other tests
-    do_create_native_mint(&test_validator.get_async_rpc_client(), payer.as_ref()).await;
-
-    // the GC test requires its own whole environment
-    let (gc_test_validator, gc_payer) = new_validator_for_test().await;
-    let gc_test_validator = Arc::new(gc_test_validator);
-    let gc_payer = Arc::new(gc_payer);
-
-    // maybe come up with a way to do this through a some macro tag on the function?
-    let tests = vec![
-        async_trial!(create_token_default, test_validator, payer),
-        async_trial!(create_token_interest_bearing, test_validator, payer),
-        async_trial!(set_interest_rate, test_validator, payer),
-        async_trial!(supply, test_validator, payer),
-        async_trial!(create_account_default, test_validator, payer),
-        async_trial!(account_info, test_validator, payer),
-        async_trial!(balance, test_validator, payer),
-        async_trial!(mint, test_validator, payer),
-        async_trial!(balance_after_mint, test_validator, payer),
-        async_trial!(balance_after_mint_with_owner, test_validator, payer),
-        async_trial!(accounts, test_validator, payer),
-        async_trial!(accounts_with_owner, test_validator, payer),
-        async_trial!(wrapped_sol, test_validator, payer),
-        async_trial!(transfer, test_validator, payer),
-        async_trial!(transfer_fund_recipient, test_validator, payer),
-        async_trial!(transfer_non_standard_recipient, test_validator, payer),
-        async_trial!(allow_non_system_account_recipient, test_validator, payer),
-        async_trial!(close_account, test_validator, payer),
-        async_trial!(disable_mint_authority, test_validator, payer),
-        async_trial!(set_owner, test_validator, payer),
-        async_trial!(transfer_with_account_delegate, test_validator, payer),
-        async_trial!(burn, test_validator, payer),
-        async_trial!(burn_with_account_delegate, test_validator, payer),
-        async_trial!(burn_with_permanent_delegate, test_validator, payer),
-        async_trial!(transfer_with_permanent_delegate, test_validator, payer),
-        async_trial!(close_mint, test_validator, payer),
-        async_trial!(required_transfer_memos, test_validator, payer),
-        async_trial!(cpi_guard, test_validator, payer),
-        async_trial!(immutable_accounts, test_validator, payer),
-        async_trial!(non_transferable, test_validator, payer),
-        async_trial!(default_account_state, test_validator, payer),
-        async_trial!(transfer_fee, test_validator, payer),
-        async_trial!(confidential_transfer, test_validator, payer),
-        async_trial!(multisig_transfer, test_validator, payer),
-        async_trial!(offline_multisig_transfer_with_nonce, test_validator, payer),
-        async_trial!(
-            withdraw_excess_lamports_from_multisig,
-            test_validator,
-            payer
-        ),
-        async_trial!(withdraw_excess_lamports_from_mint, test_validator, payer),
-        async_trial!(withdraw_excess_lamports_from_account, test_validator, payer),
-        async_trial!(metadata_pointer, test_validator, payer),
-        async_trial!(group_pointer, test_validator, payer),
-        async_trial!(group_member_pointer, test_validator, payer),
-        async_trial!(transfer_hook, test_validator, payer),
-        async_trial!(metadata, test_validator, payer),
-        async_trial!(group, test_validator, payer),
-        async_trial!(confidential_transfer_with_fee, test_validator, payer),
-        async_trial!(compute_budget, test_validator, payer),
-        // GC messes with every other test, so have it on its own test validator
-        async_trial!(gc, gc_test_validator, gc_payer),
-    ];
-
-    libtest_mimic::run(&args, tests).exit();
-}
-
-fn clone_keypair(keypair: &Keypair) -> Keypair {
-    Keypair::from_bytes(&keypair.to_bytes()).unwrap()
-}
-
-const TEST_DECIMALS: u8 = 9;
-
-async fn new_validator_for_test() -> (TestValidator, Keypair) {
-    solana_logger::setup();
-    let mut test_validator_genesis = TestValidatorGenesis::default();
-    test_validator_genesis.add_upgradeable_programs_with_path(&[
-        UpgradeableProgramInfo {
-            program_id: spl_token::id(),
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../../target/deploy/spl_token.so"),
-            upgrade_authority: Pubkey::new_unique(),
-        },
-        UpgradeableProgramInfo {
-            program_id: spl_associated_token_account::id(),
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../../target/deploy/spl_associated_token_account.so"),
-            upgrade_authority: Pubkey::new_unique(),
-        },
-        UpgradeableProgramInfo {
-            program_id: spl_token_2022::id(),
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../../target/deploy/spl_token_2022.so"),
-            upgrade_authority: Pubkey::new_unique(),
-        },
-    ]);
-    test_validator_genesis.start_async().await
-}
-
-fn test_config_with_default_signer<'a>(
-    test_validator: &TestValidator,
-    payer: &Keypair,
-    program_id: &Pubkey,
-) -> Config<'a> {
-    let websocket_url = test_validator.rpc_pubsub_url();
-    let rpc_client = Arc::new(test_validator.get_async_rpc_client());
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction),
-    );
-    Config {
-        rpc_client,
-        program_client,
-        websocket_url,
-        output_format: OutputFormat::JsonCompact,
-        fee_payer: Some(Arc::new(clone_keypair(payer))),
-        default_signer: Some(Arc::new(clone_keypair(payer))),
-        nonce_account: None,
-        nonce_authority: None,
-        nonce_blockhash: None,
-        sign_only: false,
-        dump_transaction_message: false,
-        multisigner_pubkeys: vec![],
-        program_id: *program_id,
-        restrict_to_program_id: true,
-        compute_unit_price: None,
-        compute_unit_limit: ComputeUnitLimit::Simulated,
-    }
-}
-
-fn test_config_without_default_signer<'a>(
-    test_validator: &TestValidator,
-    program_id: &Pubkey,
-) -> Config<'a> {
-    let websocket_url = test_validator.rpc_pubsub_url();
-    let rpc_client = Arc::new(test_validator.get_async_rpc_client());
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramRpcClient::new(rpc_client.clone(), ProgramRpcClientSendTransaction),
-    );
-    Config {
-        rpc_client,
-        program_client,
-        websocket_url,
-        output_format: OutputFormat::JsonCompact,
-        fee_payer: None,
-        default_signer: None,
-        nonce_account: None,
-        nonce_authority: None,
-        nonce_blockhash: None,
-        sign_only: false,
-        dump_transaction_message: false,
-        multisigner_pubkeys: vec![],
-        program_id: *program_id,
-        restrict_to_program_id: true,
-        compute_unit_price: None,
-        compute_unit_limit: ComputeUnitLimit::Simulated,
-    }
-}
-
-async fn create_nonce(config: &Config<'_>, authority: &Keypair) -> Pubkey {
-    let nonce = Keypair::new();
-
-    let nonce_rent = config
-        .rpc_client
-        .get_minimum_balance_for_rent_exemption(solana_sdk::nonce::State::size())
-        .await
-        .unwrap();
-    let instr = system_instruction::create_nonce_account(
-        &authority.pubkey(),
-        &nonce.pubkey(),
-        &authority.pubkey(), // Make the fee payer the nonce account authority
-        nonce_rent,
-    );
-
-    let blockhash = config.rpc_client.get_latest_blockhash().await.unwrap();
-    let tx = Transaction::new_signed_with_payer(
-        &instr,
-        Some(&authority.pubkey()),
-        &[&nonce, authority],
-        blockhash,
-    );
-
-    config
-        .rpc_client
-        .send_and_confirm_transaction(&tx)
-        .await
-        .unwrap();
-    nonce.pubkey()
-}
-
-async fn do_create_native_mint(rpc_client: &RpcClient, payer: &Keypair) {
-    let native_mint = spl_token_2022::native_mint::id();
-    if rpc_client.get_account(&native_mint).await.is_err() {
-        let transaction = Transaction::new_signed_with_payer(
-            &[create_native_mint(&spl_token_2022::id(), &payer.pubkey()).unwrap()],
-            Some(&payer.pubkey()),
-            &[payer],
-            rpc_client.get_latest_blockhash().await.unwrap(),
-        );
-        rpc_client
-            .send_and_confirm_transaction(&transaction)
-            .await
-            .unwrap();
-    }
-}
-
-async fn create_token(config: &Config<'_>, payer: &Keypair) -> Pubkey {
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-        ],
-    )
-    .await
-    .unwrap();
-    token.pubkey()
-}
-
-async fn create_interest_bearing_token(
-    config: &Config<'_>,
-    payer: &Keypair,
-    rate_bps: i16,
-) -> Pubkey {
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--interest-rate",
-            &rate_bps.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    token.pubkey()
-}
-
-async fn create_auxiliary_account(config: &Config<'_>, payer: &Keypair, mint: Pubkey) -> Pubkey {
-    let auxiliary = Keypair::new();
-    let auxiliary_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&auxiliary, &auxiliary_keypair_file).unwrap();
-    process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateAccount.into(),
-            &mint.to_string(),
-            auxiliary_keypair_file.path().to_str().unwrap(),
-        ],
-    )
-    .await
-    .unwrap();
-    auxiliary.pubkey()
-}
-
-async fn create_associated_account(
-    config: &Config<'_>,
-    payer: &Keypair,
-    mint: &Pubkey,
-    owner: &Pubkey,
-) -> Pubkey {
-    process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateAccount.into(),
-            &mint.to_string(),
-            "--owner",
-            &owner.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    get_associated_token_address_with_program_id(owner, mint, &config.program_id)
-}
-
-async fn mint_tokens(
-    config: &Config<'_>,
-    payer: &Keypair,
-    mint: Pubkey,
-    ui_amount: f64,
-    recipient: Pubkey,
-) -> CommandResult {
-    process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Mint.into(),
-            &mint.to_string(),
-            &ui_amount.to_string(),
-            &recipient.to_string(),
-        ],
-    )
-    .await
-}
-
-async fn run_transfer_test(config: &Config<'_>, payer: &Keypair) {
-    let token = create_token(config, payer).await;
-    let source = create_associated_account(config, payer, &token, &payer.pubkey()).await;
-    let destination = create_auxiliary_account(config, payer, token).await;
-    let ui_amount = 100.0;
-    mint_tokens(config, payer, token, ui_amount, source)
-        .await
-        .unwrap();
-    let result = process_test_command(
-        config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            &token.to_string(),
-            "10",
-            &destination.to_string(),
-        ],
-    )
-    .await;
-    result.unwrap();
-
-    let account = config.rpc_client.get_account(&source).await.unwrap();
-    let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-    assert_eq!(token_account.base.amount, amount);
-    let account = config.rpc_client.get_account(&destination).await.unwrap();
-    let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let amount = spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS);
-    assert_eq!(token_account.base.amount, amount);
-}
-
-async fn process_test_command<I, T>(config: &Config<'_>, payer: &Keypair, args: I) -> CommandResult
-where
-    I: IntoIterator<Item = T>,
-    T: Into<OsString> + Clone,
-{
-    let default_decimals = format!("{}", spl_token_2022::native_mint::DECIMALS);
-    let minimum_signers_help = minimum_signers_help_string();
-    let multisig_member_help = multisig_member_help_string();
-
-    let app_matches = app(
-        &default_decimals,
-        &minimum_signers_help,
-        &multisig_member_help,
-    )
-    .get_matches_from(args);
-    let (sub_command, sub_matches) = app_matches.subcommand();
-    let sub_command = CommandName::from_str(sub_command).unwrap();
-    let matches = sub_matches.unwrap();
-
-    let wallet_manager = None;
-    let bulk_signers: Vec<Arc<dyn Signer>> = vec![Arc::new(clone_keypair(payer))];
-    process_command(&sub_command, matches, config, wallet_manager, bulk_signers).await
-}
-
-async fn exec_test_cmd<T: AsRef<OsStr>>(config: &Config<'_>, args: &[T]) -> CommandResult {
-    let default_decimals = format!("{}", spl_token_2022::native_mint::DECIMALS);
-    let minimum_signers_help = minimum_signers_help_string();
-    let multisig_member_help = multisig_member_help_string();
-
-    let app_matches = app(
-        &default_decimals,
-        &minimum_signers_help,
-        &multisig_member_help,
-    )
-    .get_matches_from(args);
-    let (sub_command, sub_matches) = app_matches.subcommand();
-    let sub_command = CommandName::from_str(sub_command).unwrap();
-    let matches = sub_matches.unwrap();
-
-    let mut wallet_manager = None;
-    let mut bulk_signers: Vec<Arc<dyn Signer>> = Vec::new();
-    let mut multisigner_ids = Vec::new();
-
-    let config = Config::new_with_clients_and_ws_url(
-        matches,
-        &mut wallet_manager,
-        &mut bulk_signers,
-        &mut multisigner_ids,
-        config.rpc_client.clone(),
-        config.program_client.clone(),
-        config.websocket_url.clone(),
-    )
-    .await;
-
-    process_command(&sub_command, matches, &config, wallet_manager, bulk_signers).await
-}
-
-async fn create_token_default(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::CreateToken.into()],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-        let account = config.rpc_client.get_account(&mint).await.unwrap();
-        assert_eq!(account.owner, *program_id);
-    }
-}
-
-async fn create_token_interest_bearing(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-    let rate_bps: i16 = 100;
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--interest-rate",
-            &rate_bps.to_string(),
-        ],
-    )
-    .await;
-    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_account = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_account
-        .get_extension::<InterestBearingConfig>()
-        .unwrap();
-    assert_eq!(account.owner, spl_token_2022::id());
-    assert_eq!(i16::from(extension.current_rate), rate_bps);
-    assert_eq!(
-        Option::<Pubkey>::from(extension.rate_authority),
-        Some(payer.pubkey())
-    );
-}
-
-async fn set_interest_rate(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-    let initial_rate: i16 = 100;
-    let new_rate: i16 = 300;
-    let token = create_interest_bearing_token(&config, payer, initial_rate).await;
-    let account = config.rpc_client.get_account(&token).await.unwrap();
-    let mint_account = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_account
-        .get_extension::<InterestBearingConfig>()
-        .unwrap();
-    assert_eq!(account.owner, spl_token_2022::id());
-    assert_eq!(i16::from(extension.current_rate), initial_rate);
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::SetInterestRate.into(),
-            &token.to_string(),
-            &new_rate.to_string(),
-        ],
-    )
-    .await;
-    let _value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&token).await.unwrap();
-    let mint_account = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_account
-        .get_extension::<InterestBearingConfig>()
-        .unwrap();
-    assert_eq!(i16::from(extension.current_rate), new_rate);
-}
-
-async fn supply(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::Supply.into(), &token.to_string()],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(value["amount"], "0");
-        assert_eq!(value["uiAmountString"], "0");
-    }
-}
-
-async fn create_account_default(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::CreateAccount.into(),
-                &token.to_string(),
-            ],
-        )
-        .await;
-        result.unwrap();
-    }
-}
-
-async fn account_info(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let _account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::AccountInfo.into(),
-                &token.to_string(),
-            ],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let account = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &token,
-            &config.program_id,
-        );
-        assert_eq!(value["address"], account.to_string());
-        assert_eq!(value["mint"], token.to_string());
-        assert_eq!(value["isAssociated"], true);
-        assert_eq!(value["isNative"], false);
-        assert_eq!(value["owner"], payer.pubkey().to_string());
-        assert_eq!(value["state"], "initialized");
-    }
-}
-
-async fn balance(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let _account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::Balance.into(), &token.to_string()],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(value["amount"], "0");
-        assert_eq!(value["uiAmountString"], "0");
-    }
-}
-
-async fn mint(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let mut amount = 0;
-
-        // mint via implicit owner
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Mint.into(),
-                &token.to_string(),
-                "1",
-            ],
-        )
-        .await
-        .unwrap();
-        amount += spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS);
-
-        let account_data = config.rpc_client.get_account(&account).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account_data.data).unwrap();
-        assert_eq!(token_account.base.amount, amount);
-        assert_eq!(token_account.base.mint, token);
-        assert_eq!(token_account.base.owner, payer.pubkey());
-
-        // mint via explicit recipient
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Mint.into(),
-                &token.to_string(),
-                "1",
-                &account.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-        amount += spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS);
-
-        let account_data = config.rpc_client.get_account(&account).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account_data.data).unwrap();
-        assert_eq!(token_account.base.amount, amount);
-        assert_eq!(token_account.base.mint, token);
-        assert_eq!(token_account.base.owner, payer.pubkey());
-
-        // mint via explicit owner
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Mint.into(),
-                &token.to_string(),
-                "1",
-                "--recipient-owner",
-                &payer.pubkey().to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-        amount += spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS);
-
-        let account_data = config.rpc_client.get_account(&account).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account_data.data).unwrap();
-        assert_eq!(token_account.base.amount, amount);
-        assert_eq!(token_account.base.mint, token);
-        assert_eq!(token_account.base.owner, payer.pubkey());
-    }
-}
-
-async fn balance_after_mint(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, account)
-            .await
-            .unwrap();
-        let result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::Balance.into(), &token.to_string()],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let amount = spl_token::ui_amount_to_amount(ui_amount, TEST_DECIMALS);
-        assert_eq!(value["amount"], format!("{}", amount));
-        assert_eq!(value["uiAmountString"], format!("{}", ui_amount));
-    }
-}
-
-async fn balance_after_mint_with_owner(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, account)
-            .await
-            .unwrap();
-        let config = test_config_without_default_signer(test_validator, program_id);
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Balance.into(),
-                &token.to_string(),
-                "--owner",
-                &payer.pubkey().to_string(),
-            ],
-        )
-        .await;
-        let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let amount = spl_token::ui_amount_to_amount(ui_amount, TEST_DECIMALS);
-        assert_eq!(value["amount"], format!("{}", amount));
-        assert_eq!(value["uiAmountString"], format!("{}", ui_amount));
-    }
-}
-
-async fn accounts(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token1 = create_token(&config, payer).await;
-        let _account1 = create_associated_account(&config, payer, &token1, &payer.pubkey()).await;
-        let token2 = create_token(&config, payer).await;
-        let _account2 = create_associated_account(&config, payer, &token2, &payer.pubkey()).await;
-        let token3 = create_token(&config, payer).await;
-        let result =
-            process_test_command(&config, payer, &["spl-token", CommandName::Accounts.into()])
-                .await
-                .unwrap();
-        assert!(result.contains(&token1.to_string()));
-        assert!(result.contains(&token2.to_string()));
-        assert!(!result.contains(&token3.to_string()));
-    }
-}
-
-async fn accounts_with_owner(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token1 = create_token(&config, payer).await;
-        let _account1 = create_associated_account(&config, payer, &token1, &payer.pubkey()).await;
-        let token2 = create_token(&config, payer).await;
-        let _account2 = create_associated_account(&config, payer, &token2, &payer.pubkey()).await;
-        let token3 = create_token(&config, payer).await;
-        let config = test_config_without_default_signer(test_validator, program_id);
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Accounts.into(),
-                "--owner",
-                &payer.pubkey().to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-        assert!(result.contains(&token1.to_string()));
-        assert!(result.contains(&token2.to_string()));
-        assert!(!result.contains(&token3.to_string()));
-    }
-}
-
-async fn wrapped_sol(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let native_mint = *Token::new_native(
-            config.program_client.clone(),
-            program_id,
-            config.fee_payer().unwrap().clone(),
-        )
-        .get_address();
-        let _result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::Wrap.into(), "0.5"],
-        )
-        .await
-        .unwrap();
-        let wrapped_address = get_associated_token_address_with_program_id(
-            &payer.pubkey(),
-            &native_mint,
-            &config.program_id,
-        );
-        let account = config
-            .rpc_client
-            .get_account(&wrapped_address)
-            .await
-            .unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        assert_eq!(token_account.base.mint, native_mint);
-        assert_eq!(token_account.base.owner, payer.pubkey());
-        assert!(token_account.base.is_native());
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Unwrap.into(),
-                &wrapped_address.to_string(),
-            ],
-        )
-        .await;
-        result.unwrap();
-        config
-            .rpc_client
-            .get_account(&wrapped_address)
-            .await
-            .unwrap_err();
-
-        // now use `close` to close it
-        let token = create_token(&config, payer).await;
-        let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let _result = process_test_command(
-            &config,
-            payer,
-            &["spl-token", CommandName::Wrap.into(), "10.0"],
-        )
-        .await
-        .unwrap();
-
-        let recipient =
-            get_associated_token_address_with_program_id(&payer.pubkey(), &native_mint, program_id);
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Close.into(),
-                "--address",
-                &source.to_string(),
-                "--recipient",
-                &recipient.to_string(),
-            ],
-        )
-        .await;
-        result.unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&recipient)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(ui_account.token_amount.amount, "10000000000");
-    }
-}
-
-async fn transfer(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        run_transfer_test(&config, payer).await;
-    }
-}
-
-async fn transfer_fund_recipient(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let recipient = Keypair::new().pubkey().to_string();
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Transfer.into(),
-                "--fund-recipient",
-                "--allow-unfunded-recipient",
-                &token.to_string(),
-                "10",
-                &recipient,
-            ],
-        )
-        .await;
-        result.unwrap();
-
-        let account = config.rpc_client.get_account(&source).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        assert_eq!(
-            token_account.base.amount,
-            spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS)
-        );
-    }
-}
-
-async fn transfer_non_standard_recipient(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        for other_program_id in VALID_TOKEN_PROGRAM_IDS
-            .iter()
-            .filter(|id| *id != program_id)
-        {
-            let mut config =
-                test_config_with_default_signer(test_validator, payer, other_program_id);
-            let wrong_program_token = create_token(&config, payer).await;
-            let wrong_program_account =
-                create_associated_account(&config, payer, &wrong_program_token, &payer.pubkey())
-                    .await;
-            config.program_id = *program_id;
-            let config = config;
-
-            let token = create_token(&config, payer).await;
-            let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-            let recipient = Keypair::new().pubkey();
-            let recipient_token_account = get_associated_token_address_with_program_id(
-                &recipient,
-                &token,
-                &config.program_id,
-            );
-            let system_token_account = get_associated_token_address_with_program_id(
-                &system_program::id(),
-                &token,
-                &config.program_id,
-            );
-            let amount = 100;
-            mint_tokens(&config, payer, token, amount as f64, source)
-                .await
-                .unwrap();
-
-            // transfer fails to unfunded recipient without flag
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    &token.to_string(),
-                    "1",
-                    &recipient.to_string(),
-                ],
-            )
-            .await
-            .unwrap_err();
-
-            // with unfunded flag, transfer goes through
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    "--allow-unfunded-recipient",
-                    &token.to_string(),
-                    "1",
-                    &recipient.to_string(),
-                ],
-            )
-            .await
-            .unwrap();
-            let account = config
-                .rpc_client
-                .get_account(&recipient_token_account)
-                .await
-                .unwrap();
-            let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-            assert_eq!(
-                token_account.base.amount,
-                spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS)
-            );
-
-            // transfer fails to non-system recipient without flag
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    &token.to_string(),
-                    "1",
-                    &system_program::id().to_string(),
-                ],
-            )
-            .await
-            .unwrap_err();
-
-            // with non-system flag, transfer goes through
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    "--allow-non-system-account-recipient",
-                    &token.to_string(),
-                    "1",
-                    &system_program::id().to_string(),
-                ],
-            )
-            .await
-            .unwrap();
-            let account = config
-                .rpc_client
-                .get_account(&system_token_account)
-                .await
-                .unwrap();
-            let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-            assert_eq!(
-                token_account.base.amount,
-                spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS)
-            );
-
-            // transfer to same-program non-account fails
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    "--allow-non-system-account-recipient",
-                    "--allow-unfunded-recipient",
-                    &token.to_string(),
-                    "1",
-                    &token.to_string(),
-                ],
-            )
-            .await
-            .unwrap_err();
-
-            // transfer to other-program account fails
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Transfer.into(),
-                    "--fund-recipient",
-                    "--allow-non-system-account-recipient",
-                    "--allow-unfunded-recipient",
-                    &token.to_string(),
-                    "1",
-                    &wrong_program_account.to_string(),
-                ],
-            )
-            .await
-            .unwrap_err();
-        }
-    }
-}
-
-async fn allow_non_system_account_recipient(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token::id());
-
-    let token = create_token(&config, payer).await;
-    let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-    let recipient = Keypair::new().pubkey().to_string();
-    let ui_amount = 100.0;
-    mint_tokens(&config, payer, token, ui_amount, source)
-        .await
-        .unwrap();
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--fund-recipient",
-            "--allow-non-system-account-recipient",
-            "--allow-unfunded-recipient",
-            &token.to_string(),
-            "10",
-            &recipient,
-        ],
-    )
-    .await;
-    result.unwrap();
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&source)
-        .await
-        .unwrap()
-        .unwrap();
-    let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-}
-
-async fn close_account(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-
-        let native_mint = Token::new_native(
-            config.program_client.clone(),
-            program_id,
-            config.fee_payer().unwrap().clone(),
-        );
-        let recipient_owner = Pubkey::new_unique();
-        native_mint
-            .get_or_create_associated_account_info(&recipient_owner)
-            .await
-            .unwrap();
-
-        let token = create_token(&config, payer).await;
-
-        let system_recipient = Keypair::new().pubkey();
-        let wsol_recipient = native_mint.get_associated_token_address(&recipient_owner);
-
-        for recipient in [system_recipient, wsol_recipient] {
-            let base_balance = config
-                .rpc_client
-                .get_account(&recipient)
-                .await
-                .map(|account| account.lamports)
-                .unwrap_or(0);
-
-            let source = create_auxiliary_account(&config, payer, token).await;
-            let token_rent_amount = config
-                .rpc_client
-                .get_account(&source)
-                .await
-                .unwrap()
-                .lamports;
-
-            process_test_command(
-                &config,
-                payer,
-                &[
-                    "spl-token",
-                    CommandName::Close.into(),
-                    "--address",
-                    &source.to_string(),
-                    "--recipient",
-                    &recipient.to_string(),
-                ],
-            )
-            .await
-            .unwrap();
-
-            let recipient_data = config.rpc_client.get_account(&recipient).await.unwrap();
-
-            assert_eq!(recipient_data.lamports, base_balance + token_rent_amount);
-            if recipient == wsol_recipient {
-                let recipient_account =
-                    StateWithExtensionsOwned::<Account>::unpack(recipient_data.data).unwrap();
-                assert_eq!(recipient_account.base.amount, token_rent_amount);
-            }
-        }
-    }
-}
-
-async fn disable_mint_authority(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Authorize.into(),
-                &token.to_string(),
-                "mint",
-                "--disable",
-            ],
-        )
-        .await;
-        result.unwrap();
-
-        let account = config.rpc_client.get_account(&token).await.unwrap();
-        let mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-        assert_eq!(mint.base.mint_authority, COption::None);
-    }
-}
-
-async fn gc(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let mut config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let _account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let _aux1 = create_auxiliary_account(&config, payer, token).await;
-        let _aux2 = create_auxiliary_account(&config, payer, token).await;
-        let _aux3 = create_auxiliary_account(&config, payer, token).await;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Accounts.into(),
-                &token.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-        let value: serde_json::Value = serde_json::from_str(&result).unwrap();
-        assert_eq!(
-            value["accounts"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .filter(|x| x["mint"] == token.to_string())
-                .count(),
-            4
-        );
-        config.output_format = OutputFormat::Display; // fixup eventually?
-        let _result = process_test_command(&config, payer, &["spl-token", CommandName::Gc.into()])
-            .await
-            .unwrap();
-        config.output_format = OutputFormat::JsonCompact;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Accounts.into(),
-                &token.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-        let value: serde_json::Value = serde_json::from_str(&result).unwrap();
-        assert_eq!(
-            value["accounts"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .filter(|x| x["mint"] == token.to_string())
-                .count(),
-            1
-        );
-
-        config.output_format = OutputFormat::Display;
-
-        // test implicit transfer
-        let token = create_token(&config, payer).await;
-        let ata = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let aux = create_auxiliary_account(&config, payer, token).await;
-        mint_tokens(&config, payer, token, 1.0, ata).await.unwrap();
-        mint_tokens(&config, payer, token, 1.0, aux).await.unwrap();
-
-        process_test_command(&config, payer, &["spl-token", CommandName::Gc.into()])
-            .await
-            .unwrap();
-
-        let ui_ata = config
-            .rpc_client
-            .get_token_account(&ata)
-            .await
-            .unwrap()
-            .unwrap();
-
-        // aux is gone and its tokens are in ata
-        let amount = spl_token::ui_amount_to_amount(2.0, TEST_DECIMALS);
-        assert_eq!(ui_ata.token_amount.amount, format!("{amount}"));
-        config.rpc_client.get_account(&aux).await.unwrap_err();
-
-        // test ata closure
-        let token = create_token(&config, payer).await;
-        let ata = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Gc.into(),
-                "--close-empty-associated-accounts",
-            ],
-        )
-        .await
-        .unwrap();
-
-        // ata is gone
-        config.rpc_client.get_account(&ata).await.unwrap_err();
-
-        // test a tricky corner case of both
-        let token = create_token(&config, payer).await;
-        let ata = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let aux = create_auxiliary_account(&config, payer, token).await;
-        mint_tokens(&config, payer, token, 1.0, aux).await.unwrap();
-
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Gc.into(),
-                "--close-empty-associated-accounts",
-            ],
-        )
-        .await
-        .unwrap();
-
-        let ui_ata = config
-            .rpc_client
-            .get_token_account(&ata)
-            .await
-            .unwrap()
-            .unwrap();
-
-        // aux is gone and its tokens are in ata, and ata has not been closed
-        let amount = spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS);
-        assert_eq!(ui_ata.token_amount.amount, format!("{amount}"));
-        config.rpc_client.get_account(&aux).await.unwrap_err();
-
-        // test that balance moves off an uncloseable account
-        let token = create_token(&config, payer).await;
-        let ata = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let aux = create_auxiliary_account(&config, payer, token).await;
-        let close_authority = Keypair::new().pubkey();
-        mint_tokens(&config, payer, token, 1.0, aux).await.unwrap();
-
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Authorize.into(),
-                &aux.to_string(),
-                "close",
-                &close_authority.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-
-        process_test_command(&config, payer, &["spl-token", CommandName::Gc.into()])
-            .await
-            .unwrap();
-
-        let ui_ata = config
-            .rpc_client
-            .get_token_account(&ata)
-            .await
-            .unwrap()
-            .unwrap();
-
-        // aux tokens are now in ata
-        let amount = spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS);
-        assert_eq!(ui_ata.token_amount.amount, format!("{amount}"));
-    }
-}
-
-async fn set_owner(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let aux = create_auxiliary_account(&config, payer, token).await;
-        let aux_string = aux.to_string();
-        let _result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Authorize.into(),
-                &aux_string,
-                "owner",
-                &aux_string,
-            ],
-        )
-        .await
-        .unwrap();
-        let account = config.rpc_client.get_account(&aux).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        assert_eq!(token_account.base.mint, token);
-        assert_eq!(token_account.base.owner, aux);
-    }
-}
-
-async fn transfer_with_account_delegate(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-
-        let token = create_token(&config, payer).await;
-        let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let destination = create_auxiliary_account(&config, payer, token).await;
-        let delegate = Keypair::new();
-
-        let delegate_keypair_file = NamedTempFile::new().unwrap();
-        write_keypair_file(&delegate, &delegate_keypair_file).unwrap();
-        let fee_payer_keypair_file = NamedTempFile::new().unwrap();
-        write_keypair_file(payer, &fee_payer_keypair_file).unwrap();
-
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        let amount = spl_token::ui_amount_to_amount(100.0, TEST_DECIMALS);
-        assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-        assert_eq!(ui_account.delegate, None);
-        assert_eq!(ui_account.delegated_amount, None);
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&destination)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(ui_account.token_amount.amount, "0");
-
-        exec_test_cmd(
-            &config,
-            &[
-                "spl-token",
-                CommandName::Approve.into(),
-                &source.to_string(),
-                "10",
-                &delegate.pubkey().to_string(),
-                "--owner",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--fee-payer",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(ui_account.delegate.unwrap(), delegate.pubkey().to_string());
-        let amount = spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS);
-        assert_eq!(
-            ui_account.delegated_amount.unwrap().amount,
-            format!("{amount}")
-        );
-
-        let result = exec_test_cmd(
-            &config,
-            &[
-                "spl-token",
-                CommandName::Transfer.into(),
-                &token.to_string(),
-                "10",
-                &destination.to_string(),
-                "--from",
-                &source.to_string(),
-                "--owner",
-                delegate_keypair_file.path().to_str().unwrap(),
-                "--fee-payer",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-            ],
-        )
-        .await;
-        result.unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-        assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-        assert_eq!(ui_account.delegate, None);
-        assert_eq!(ui_account.delegated_amount, None);
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&destination)
-            .await
-            .unwrap()
-            .unwrap();
-        let amount = spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS);
-        assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-    }
-}
-
-async fn burn(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let mut config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Burn.into(),
-                &source.to_string(),
-                "10",
-            ],
-        )
-        .await
-        .unwrap();
-
-        let account = config.rpc_client.get_account(&source).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-        assert_eq!(token_account.base.amount, amount);
-
-        process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Burn.into(),
-                &source.to_string(),
-                "ALL",
-            ],
-        )
-        .await
-        .unwrap();
-
-        let account = config.rpc_client.get_account(&source).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        let amount = spl_token::ui_amount_to_amount(0.0, TEST_DECIMALS);
-        assert_eq!(token_account.base.amount, amount);
-
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Burn.into(),
-                &source.to_string(),
-                "10",
-            ],
-        )
-        .await;
-        assert!(result.is_err());
-
-        // Use of the ALL keyword not supported with offline signing
-        config.sign_only = true;
-        let result = process_test_command(
-            &config,
-            payer,
-            &[
-                "spl-token",
-                CommandName::Burn.into(),
-                &source.to_string(),
-                "ALL",
-            ],
-        )
-        .await;
-        assert!(result.is_err_and(|err| err.to_string().contains("ALL")));
-    }
-}
-
-async fn burn_with_account_delegate(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-
-        let token = create_token(&config, payer).await;
-        let source = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-        let delegate = Keypair::new();
-
-        let delegate_keypair_file = NamedTempFile::new().unwrap();
-        write_keypair_file(&delegate, &delegate_keypair_file).unwrap();
-        let fee_payer_keypair_file = NamedTempFile::new().unwrap();
-        write_keypair_file(payer, &fee_payer_keypair_file).unwrap();
-
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        let amount = spl_token::ui_amount_to_amount(100.0, TEST_DECIMALS);
-        assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-        assert_eq!(ui_account.delegate, None);
-        assert_eq!(ui_account.delegated_amount, None);
-
-        exec_test_cmd(
-            &config,
-            &[
-                "spl-token",
-                CommandName::Approve.into(),
-                &source.to_string(),
-                "10",
-                &delegate.pubkey().to_string(),
-                "--owner",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--fee-payer",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-            ],
-        )
-        .await
-        .unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(ui_account.delegate.unwrap(), delegate.pubkey().to_string());
-        let amount = spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS);
-        assert_eq!(
-            ui_account.delegated_amount.unwrap().amount,
-            format!("{amount}")
-        );
-
-        let result = exec_test_cmd(
-            &config,
-            &[
-                "spl-token",
-                CommandName::Burn.into(),
-                &source.to_string(),
-                "10",
-                "--owner",
-                delegate_keypair_file.path().to_str().unwrap(),
-                "--fee-payer",
-                fee_payer_keypair_file.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-            ],
-        )
-        .await;
-        result.unwrap();
-
-        let ui_account = config
-            .rpc_client
-            .get_token_account(&source)
-            .await
-            .unwrap()
-            .unwrap();
-        let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-        assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-        assert_eq!(ui_account.delegate, None);
-        assert_eq!(ui_account.delegated_amount, None);
-    }
-}
-
-async fn burn_with_permanent_delegate(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-permanent-delegate",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let permanent_delegate_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &permanent_delegate_keypair_file).unwrap();
-
-    let unknown_owner = Keypair::new();
-    let source =
-        create_associated_account(&config, &unknown_owner, &token, &unknown_owner.pubkey()).await;
-    let ui_amount = 100.0;
-
-    mint_tokens(&config, payer, token, ui_amount, source)
-        .await
-        .unwrap();
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&source)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let amount = spl_token::ui_amount_to_amount(100.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-
-    exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::Burn.into(),
-            &source.to_string(),
-            "10",
-            "--owner",
-            permanent_delegate_keypair_file.path().to_str().unwrap(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&source)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-}
-
-async fn transfer_with_permanent_delegate(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-permanent-delegate",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let unknown_owner = Keypair::new();
-    let source =
-        create_associated_account(&config, &unknown_owner, &token, &unknown_owner.pubkey()).await;
-    let destination = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-
-    let permanent_delegate_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &permanent_delegate_keypair_file).unwrap();
-
-    let ui_amount = 100.0;
-    mint_tokens(&config, payer, token, ui_amount, source)
-        .await
-        .unwrap();
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&source)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let amount = spl_token::ui_amount_to_amount(100.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&destination)
-        .await
-        .unwrap()
-        .unwrap();
-
-    assert_eq!(ui_account.token_amount.amount, "0");
-
-    exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            &token.to_string(),
-            "50",
-            &destination.to_string(),
-            "--from",
-            &source.to_string(),
-            "--owner",
-            permanent_delegate_keypair_file.path().to_str().unwrap(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&destination)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let amount = spl_token::ui_amount_to_amount(50.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-
-    let ui_account = config
-        .rpc_client
-        .get_token_account(&source)
-        .await
-        .unwrap()
-        .unwrap();
-
-    let amount = spl_token::ui_amount_to_amount(50.0, TEST_DECIMALS);
-    assert_eq!(ui_account.token_amount.amount, format!("{amount}"));
-}
-
-async fn close_mint(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    let token = Keypair::new();
-    let token_pubkey = token.pubkey();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-close",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data);
-    assert!(test_mint.is_ok());
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CloseMint.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await;
-    assert!(account.is_err());
-}
-
-async fn required_transfer_memos(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let token = create_token(&config, payer).await;
-    let destination_account = create_auxiliary_account(&config, payer, token).await;
-    let token_account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-
-    mint_tokens(&config, payer, token, 100.0, token_account)
-        .await
-        .unwrap();
-
-    // enable works
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::EnableRequiredTransferMemos.into(),
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let extensions = StateWithExtensionsOwned::<Account>::unpack(
-        config
-            .rpc_client
-            .get_account(&destination_account)
-            .await
-            .unwrap()
-            .data,
-    )
-    .unwrap();
-    let memo_transfer = extensions.get_extension::<MemoTransfer>().unwrap();
-    let enabled: bool = memo_transfer.require_incoming_transfer_memos.into();
-    assert!(enabled);
-
-    // transfer requires a memo
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--from",
-            &token_account.to_string(),
-            &token.to_string(),
-            "1",
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap_err();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--from",
-            &token_account.to_string(),
-            // malicious compliance
-            "--with-memo",
-            "memo",
-            &token.to_string(),
-            "1",
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    let account_data = config
-        .rpc_client
-        .get_account(&destination_account)
-        .await
-        .unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account_data.data).unwrap();
-    assert_eq!(
-        account_state.base.amount,
-        spl_token::ui_amount_to_amount(1.0, TEST_DECIMALS)
-    );
-
-    // disable works
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::DisableRequiredTransferMemos.into(),
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    let extensions = StateWithExtensionsOwned::<Account>::unpack(
-        config
-            .rpc_client
-            .get_account(&destination_account)
-            .await
-            .unwrap()
-            .data,
-    )
-    .unwrap();
-    let memo_transfer = extensions.get_extension::<MemoTransfer>().unwrap();
-    let enabled: bool = memo_transfer.require_incoming_transfer_memos.into();
-    assert!(!enabled);
-}
-
-async fn cpi_guard(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let token = create_token(&config, payer).await;
-    let token_account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-
-    // enable works
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::EnableCpiGuard.into(),
-            &token_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    let extensions = StateWithExtensionsOwned::<Account>::unpack(
-        config
-            .rpc_client
-            .get_account(&token_account)
-            .await
-            .unwrap()
-            .data,
-    )
-    .unwrap();
-    let cpi_guard = extensions.get_extension::<CpiGuard>().unwrap();
-    let enabled: bool = cpi_guard.lock_cpi.into();
-    assert!(enabled);
-
-    // disable works
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::DisableCpiGuard.into(),
-            &token_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-    let extensions = StateWithExtensionsOwned::<Account>::unpack(
-        config
-            .rpc_client
-            .get_account(&token_account)
-            .await
-            .unwrap()
-            .data,
-    )
-    .unwrap();
-    let cpi_guard = extensions.get_extension::<CpiGuard>().unwrap();
-    let enabled: bool = cpi_guard.lock_cpi.into();
-    assert!(!enabled);
-}
-
-async fn immutable_accounts(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let token = create_token(&config, payer).await;
-    let new_owner = Keypair::new().pubkey();
-    let native_mint = *Token::new_native(
-        config.program_client.clone(),
-        &program_id,
-        config.fee_payer().unwrap().clone(),
-    )
-    .get_address();
-
-    // cannot reassign an ata
-    let account = create_associated_account(&config, payer, &token, &payer.pubkey()).await;
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &account.to_string(),
-            "owner",
-            &new_owner.to_string(),
-        ],
-    )
-    .await;
-    result.unwrap_err();
-
-    // immutable works for create-account
-    let aux_account = Keypair::new();
-    let aux_pubkey = aux_account.pubkey();
-    let aux_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&aux_account, &aux_keypair_file).unwrap();
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateAccount.into(),
-            &token.to_string(),
-            aux_keypair_file.path().to_str().unwrap(),
-            "--immutable",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &aux_pubkey.to_string(),
-            "owner",
-            &new_owner.to_string(),
-        ],
-    )
-    .await;
-    result.unwrap_err();
-
-    // immutable works for wrap
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Wrap.into(),
-            "--create-aux-account",
-            "--immutable",
-            "0.5",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let accounts = config
-        .rpc_client
-        .get_token_accounts_by_owner(&payer.pubkey(), TokenAccountsFilter::Mint(native_mint))
-        .await
-        .unwrap();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &accounts[0].pubkey,
-            "owner",
-            &new_owner.to_string(),
-        ],
-    )
-    .await;
-    result.unwrap_err();
-}
-
-async fn non_transferable(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token_pubkey = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-non-transferable",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    assert!(test_mint.get_extension::<NonTransferable>().is_ok());
-
-    let associated_account =
-        create_associated_account(&config, payer, &token_pubkey, &payer.pubkey()).await;
-    let aux_account = create_auxiliary_account(&config, payer, token_pubkey).await;
-    mint_tokens(&config, payer, token_pubkey, 100.0, associated_account)
-        .await
-        .unwrap();
-
-    // transfer not allowed
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--from",
-            &associated_account.to_string(),
-            &token_pubkey.to_string(),
-            "1",
-            &aux_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap_err();
-}
-
-async fn default_account_state(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token_pubkey = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-freeze",
-            "--default-account-state",
-            "frozen",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint_account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint = StateWithExtensionsOwned::<Mint>::unpack(mint_account.data).unwrap();
-    let extension = mint.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(extension.state, u8::from(AccountState::Frozen));
-
-    let frozen_account =
-        create_associated_account(&config, payer, &token_pubkey, &payer.pubkey()).await;
-    let token_account = config
-        .rpc_client
-        .get_account(&frozen_account)
-        .await
-        .unwrap();
-    let account = StateWithExtensionsOwned::<Account>::unpack(token_account.data).unwrap();
-    assert_eq!(account.base.state, AccountState::Frozen);
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateDefaultAccountState.into(),
-            &token_pubkey.to_string(),
-            "initialized",
-        ],
-    )
-    .await
-    .unwrap();
-    let unfrozen_account = create_auxiliary_account(&config, payer, token_pubkey).await;
-    let token_account = config
-        .rpc_client
-        .get_account(&unfrozen_account)
-        .await
-        .unwrap();
-    let account = StateWithExtensionsOwned::<Account>::unpack(token_account.data).unwrap();
-    assert_eq!(account.base.state, AccountState::Initialized);
-}
-
-async fn transfer_fee(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    let transfer_fee_basis_points = 100;
-    let maximum_fee = 10_000_000_000;
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token_pubkey = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--transfer-fee",
-            &transfer_fee_basis_points.to_string(),
-            &maximum_fee.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = test_mint.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        u16::from(extension.older_transfer_fee.transfer_fee_basis_points),
-        transfer_fee_basis_points
-    );
-    assert_eq!(
-        u64::from(extension.older_transfer_fee.maximum_fee),
-        maximum_fee
-    );
-    assert_eq!(
-        u16::from(extension.newer_transfer_fee.transfer_fee_basis_points),
-        transfer_fee_basis_points
-    );
-    assert_eq!(
-        u64::from(extension.newer_transfer_fee.maximum_fee),
-        maximum_fee
-    );
-
-    let total_amount = 1000.0;
-    let transfer_amount = 100.0;
-    let token_account =
-        create_associated_account(&config, payer, &token_pubkey, &payer.pubkey()).await;
-    let source_account = create_auxiliary_account(&config, payer, token_pubkey).await;
-    mint_tokens(&config, payer, token_pubkey, total_amount, source_account)
-        .await
-        .unwrap();
-
-    // withdraw from account directly
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--from",
-            &source_account.to_string(),
-            &token_pubkey.to_string(),
-            &transfer_amount.to_string(),
-            &token_account.to_string(),
-            "--expected-fee",
-            "1",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state.get_extension::<TransferFeeAmount>().unwrap();
-    let withheld_amount =
-        spl_token::amount_to_ui_amount(u64::from(extension.withheld_amount), TEST_DECIMALS);
-    assert_eq!(withheld_amount, 1.0);
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::WithdrawWithheldTokens.into(),
-            &token_account.to_string(),
-            &token_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(u64::from(extension.withheld_amount), 0);
-
-    // withdraw from mint after account closure
-    // gather fees
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            "--from",
-            &source_account.to_string(),
-            &token_pubkey.to_string(),
-            &(total_amount - transfer_amount).to_string(),
-            &token_account.to_string(),
-            "--expected-fee",
-            "9",
-        ],
-    )
-    .await
-    .unwrap();
-
-    // burn tokens
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let burn_amount = spl_token::amount_to_ui_amount(account_state.base.amount, TEST_DECIMALS);
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Burn.into(),
-            &token_account.to_string(),
-            &burn_amount.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state.get_extension::<TransferFeeAmount>().unwrap();
-    let withheld_amount =
-        spl_token::amount_to_ui_amount(u64::from(extension.withheld_amount), TEST_DECIMALS);
-    assert_eq!(withheld_amount, 9.0);
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Close.into(),
-            "--address",
-            &token_account.to_string(),
-            "--recipient",
-            &payer.pubkey().to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint.data).unwrap();
-    let extension = mint_state.get_extension::<TransferFeeConfig>().unwrap();
-    let withheld_amount =
-        spl_token::amount_to_ui_amount(u64::from(extension.withheld_amount), TEST_DECIMALS);
-    assert_eq!(withheld_amount, 9.0);
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::WithdrawWithheldTokens.into(),
-            &source_account.to_string(),
-            "--include-mint",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint.data).unwrap();
-    let extension = mint_state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(u64::from(extension.withheld_amount), 0);
-
-    // set the transfer fee
-    let new_transfer_fee_basis_points = 800;
-    let new_maximum_fee = 5_000_000.0;
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::SetTransferFee.into(),
-            &token_pubkey.to_string(),
-            &new_transfer_fee_basis_points.to_string(),
-            &new_maximum_fee.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint.data).unwrap();
-    let extension = mint_state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        u16::from(extension.newer_transfer_fee.transfer_fee_basis_points),
-        new_transfer_fee_basis_points
-    );
-    let new_maximum_fee = spl_token::ui_amount_to_amount(new_maximum_fee, TEST_DECIMALS);
-    assert_eq!(
-        u64::from(extension.newer_transfer_fee.maximum_fee),
-        new_maximum_fee
-    );
-
-    // disable transfer fee authority
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            "--disable",
-            &token_pubkey.to_string(),
-            "transfer-fee-config",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint.data).unwrap();
-    let extension = mint_state.get_extension::<TransferFeeConfig>().unwrap();
-
-    assert_eq!(
-        Option::<Pubkey>::try_from(extension.transfer_fee_config_authority).unwrap(),
-        None,
-    );
-
-    // disable withdraw withheld authority
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            "--disable",
-            &token_pubkey.to_string(),
-            "withheld-withdraw",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let mint = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(mint.data).unwrap();
-    let extension = mint_state.get_extension::<TransferFeeConfig>().unwrap();
-
-    assert_eq!(
-        Option::<Pubkey>::try_from(extension.withdraw_withheld_authority).unwrap(),
-        None,
-    );
-}
-
-async fn confidential_transfer(test_validator: &TestValidator, payer: &Keypair) {
-    use spl_token_2022::solana_zk_token_sdk::encryption::elgamal::ElGamalKeypair;
-
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    // create token with confidential transfers enabled
-    let auto_approve = false;
-    let confidential_transfer_mint_authority = payer.pubkey();
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token_pubkey = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-confidential-transfers",
-            "manual",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = test_mint
-        .get_extension::<ConfidentialTransferMint>()
-        .unwrap();
-
-    assert_eq!(
-        Option::<Pubkey>::from(extension.authority),
-        Some(confidential_transfer_mint_authority),
-    );
-    assert_eq!(
-        bool::from(extension.auto_approve_new_accounts),
-        auto_approve,
-    );
-    assert_eq!(
-        Option::<ElGamalPubkey>::from(extension.auditor_elgamal_pubkey),
-        None,
-    );
-
-    // update confidential transfer mint settings
-    let auditor_keypair = ElGamalKeypair::new_rand();
-    let auditor_pubkey: ElGamalPubkey = (*auditor_keypair.pubkey()).into();
-    let new_auto_approve = true;
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateConfidentialTransferSettings.into(),
-            &token_pubkey.to_string(),
-            "--auditor-pubkey",
-            &auditor_pubkey.to_string(),
-            "--approve-policy",
-            "auto",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = test_mint
-        .get_extension::<ConfidentialTransferMint>()
-        .unwrap();
-
-    assert_eq!(
-        bool::from(extension.auto_approve_new_accounts),
-        new_auto_approve,
-    );
-    assert_eq!(
-        Option::<ElGamalPubkey>::from(extension.auditor_elgamal_pubkey),
-        Some(auditor_pubkey),
-    );
-
-    // create a confidential transfer account
-    let token_account =
-        create_associated_account(&config, payer, &token_pubkey, &payer.pubkey()).await;
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::ConfigureConfidentialTransferAccount.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(extension.approved));
-    assert!(bool::from(extension.allow_confidential_credits));
-    assert!(bool::from(extension.allow_non_confidential_credits));
-
-    // disable and enable confidential transfers for an account
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::DisableConfidentialCredits.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(extension.allow_confidential_credits));
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::EnableConfidentialCredits.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(extension.allow_confidential_credits));
-
-    // disable and enable non-confidential transfers for an account
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::DisableNonConfidentialCredits.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(extension.allow_non_confidential_credits));
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::EnableNonConfidentialCredits.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_account).await.unwrap();
-    let account_state = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-    let extension = account_state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(extension.allow_non_confidential_credits));
-
-    // deposit confidential tokens
-    let deposit_amount = 100.0;
-    mint_tokens(&config, payer, token_pubkey, deposit_amount, token_account)
-        .await
-        .unwrap();
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::DepositConfidentialTokens.into(),
-            &token_pubkey.to_string(),
-            &deposit_amount.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    // apply pending balance
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::ApplyPendingBalance.into(),
-            &token_pubkey.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    // confidential transfer
-    let destination_account = create_auxiliary_account(&config, payer, token_pubkey).await;
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::ConfigureConfidentialTransferAccount.into(),
-            "--address",
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap(); // configure destination account for confidential transfers first
-
-    let transfer_amount = 100.0;
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            &token_pubkey.to_string(),
-            &transfer_amount.to_string(),
-            &destination_account.to_string(),
-            "--confidential",
-        ],
-    )
-    .await
-    .unwrap();
-
-    // withdraw confidential tokens
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::ApplyPendingBalance.into(),
-            "--address",
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap(); // apply pending balance first
-
-    let withdraw_amount = 100.0;
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::WithdrawConfidentialTokens.into(),
-            &token_pubkey.to_string(),
-            &withdraw_amount.to_string(),
-            "--address",
-            &destination_account.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    // disable confidential transfers for mint
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &token_pubkey.to_string(),
-            "confidential-transfer-mint",
-            "--disable",
-        ],
-    )
-    .await
-    .unwrap();
-}
-
-async fn confidential_transfer_with_fee(test_validator: &TestValidator, payer: &Keypair) {
-    let config = test_config_with_default_signer(test_validator, payer, &spl_token_2022::id());
-
-    // create token with confidential transfers enabled
-    let auto_approve = true;
-    let confidential_transfer_mint_authority = payer.pubkey();
-
-    let token = Keypair::new();
-    let token_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(&token, &token_keypair_file).unwrap();
-    let token_pubkey = token.pubkey();
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_keypair_file.path().to_str().unwrap(),
-            "--enable-confidential-transfers",
-            "auto",
-            "--transfer-fee",
-            "100",
-            "1000000000",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&token_pubkey).await.unwrap();
-    let test_mint = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = test_mint
-        .get_extension::<ConfidentialTransferMint>()
-        .unwrap();
-
-    assert_eq!(
-        Option::<Pubkey>::from(extension.authority),
-        Some(confidential_transfer_mint_authority),
-    );
-    assert_eq!(
-        bool::from(extension.auto_approve_new_accounts),
-        auto_approve,
-    );
-    assert_eq!(
-        Option::<ElGamalPubkey>::from(extension.auditor_elgamal_pubkey),
-        None,
-    );
-
-    let extension = test_mint
-        .get_extension::<ConfidentialTransferFeeConfig>()
-        .unwrap();
-    assert_eq!(
-        Option::<Pubkey>::from(extension.authority),
-        Some(confidential_transfer_mint_authority),
-    );
-}
-
-async fn multisig_transfer(test_validator: &TestValidator, payer: &Keypair) {
-    let m = 3;
-    let n = 5u8;
-    // need to add "payer" to make the config provide the right signer
-    let (multisig_members, multisig_paths): (Vec<_>, Vec<_>) =
-        std::iter::once(clone_keypair(payer))
-            .chain(std::iter::repeat_with(Keypair::new).take((n - 2) as usize))
-            .map(|s| {
-                let keypair_file = NamedTempFile::new().unwrap();
-                write_keypair_file(&s, &keypair_file).unwrap();
-                (s.pubkey(), keypair_file)
-            })
-            .unzip();
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let config = test_config_with_default_signer(test_validator, payer, program_id);
-        let token = create_token(&config, payer).await;
-        let multisig = Arc::new(Keypair::new());
-        let multisig_pubkey = multisig.pubkey();
-
-        // add the multisig as a member to itself, make it self-owned
-        let multisig_members = std::iter::once(multisig_pubkey)
-            .chain(multisig_members.iter().cloned())
-            .collect::<Vec<_>>();
-        let multisig_path = NamedTempFile::new().unwrap();
-        write_keypair_file(&multisig, &multisig_path).unwrap();
-        let multisig_paths = std::iter::once(&multisig_path)
-            .chain(multisig_paths.iter())
-            .collect::<Vec<_>>();
-
-        let multisig_strings = multisig_members
-            .iter()
-            .map(|p| p.to_string())
-            .collect::<Vec<_>>();
-        process_test_command(
-            &config,
-            payer,
-            [
-                "spl-token",
-                CommandName::CreateMultisig.into(),
-                "--address-keypair",
-                multisig_path.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-                &m.to_string(),
-            ]
-            .into_iter()
-            .chain(multisig_strings.iter().map(|p| p.as_str())),
-        )
-        .await
-        .unwrap();
-
-        let account = config
-            .rpc_client
-            .get_account(&multisig_pubkey)
-            .await
-            .unwrap();
-        let multisig = Multisig::unpack(&account.data).unwrap();
-        assert_eq!(multisig.m, m);
-        assert_eq!(multisig.n, n);
-
-        let source = create_associated_account(&config, payer, &token, &multisig_pubkey).await;
-        let destination = create_auxiliary_account(&config, payer, token).await;
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-
-        exec_test_cmd(
-            &config,
-            &[
-                "spl-token",
-                CommandName::Transfer.into(),
-                &token.to_string(),
-                "10",
-                &destination.to_string(),
-                "--multisig-signer",
-                multisig_paths[0].path().to_str().unwrap(),
-                "--multisig-signer",
-                multisig_paths[1].path().to_str().unwrap(),
-                "--multisig-signer",
-                multisig_paths[2].path().to_str().unwrap(),
-                "--from",
-                &source.to_string(),
-                "--owner",
-                &multisig_pubkey.to_string(),
-                "--fee-payer",
-                multisig_paths[1].path().to_str().unwrap(),
-            ],
-        )
-        .await
-        .unwrap();
-
-        let account = config.rpc_client.get_account(&source).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        assert_eq!(
-            token_account.base.amount,
-            spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS)
-        );
-        let account = config.rpc_client.get_account(&destination).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        assert_eq!(
-            token_account.base.amount,
-            spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS)
-        );
-    }
-}
-
-async fn do_offline_multisig_transfer(
-    test_validator: &TestValidator,
-    payer: &Keypair,
-    compute_unit_price: Option<u64>,
-) {
-    let m = 2;
-    let n = 3u8;
-
-    let fee_payer_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &fee_payer_keypair_file).unwrap();
-
-    let (multisig_members, multisig_paths): (Vec<_>, Vec<_>) = std::iter::repeat_with(Keypair::new)
-        .take(n as usize)
-        .map(|s| {
-            let keypair_file = NamedTempFile::new().unwrap();
-            write_keypair_file(&s, &keypair_file).unwrap();
-            (s.pubkey(), keypair_file)
-        })
-        .unzip();
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let mut config = test_config_with_default_signer(test_validator, payer, program_id);
-        config.compute_unit_limit = ComputeUnitLimit::Default;
-        let token = create_token(&config, payer).await;
-        let nonce = create_nonce(&config, payer).await;
-
-        let nonce_account = config.rpc_client.get_account(&nonce).await.unwrap();
-        let start_hash_index = 4 + 4 + 32;
-        let blockhash = Hash::new(&nonce_account.data[start_hash_index..start_hash_index + 32]);
-
-        let multisig = Arc::new(Keypair::new());
-        let multisig_pubkey = multisig.pubkey();
-        let multisig_path = NamedTempFile::new().unwrap();
-        write_keypair_file(&multisig, &multisig_path).unwrap();
-
-        let multisig_strings = multisig_members
-            .iter()
-            .map(|p| p.to_string())
-            .collect::<Vec<_>>();
-        process_test_command(
-            &config,
-            payer,
-            [
-                "spl-token",
-                CommandName::CreateMultisig.into(),
-                "--address-keypair",
-                multisig_path.path().to_str().unwrap(),
-                "--program-id",
-                &program_id.to_string(),
-                &m.to_string(),
-            ]
-            .into_iter()
-            .chain(multisig_strings.iter().map(|p| p.as_str())),
-        )
-        .await
-        .unwrap();
-
-        let source = create_associated_account(&config, payer, &token, &multisig_pubkey).await;
-        let destination = create_auxiliary_account(&config, payer, token).await;
-        let ui_amount = 100.0;
-        mint_tokens(&config, payer, token, ui_amount, source)
-            .await
-            .unwrap();
-
-        let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-            ProgramOfflineClient::new(blockhash, ProgramRpcClientSendTransaction),
-        );
-        let mut args = vec![
-            "spl-token".to_string(),
-            CommandName::Transfer.as_ref().to_string(),
-            token.to_string(),
-            "10".to_string(),
-            destination.to_string(),
-            "--blockhash".to_string(),
-            blockhash.to_string(),
-            "--nonce".to_string(),
-            nonce.to_string(),
-            "--nonce-authority".to_string(),
-            payer.pubkey().to_string(),
-            "--sign-only".to_string(),
-            "--mint-decimals".to_string(),
-            format!("{}", TEST_DECIMALS),
-            "--multisig-signer".to_string(),
-            multisig_paths[1].path().to_str().unwrap().to_string(),
-            "--multisig-signer".to_string(),
-            multisig_members[2].to_string(),
-            "--from".to_string(),
-            source.to_string(),
-            "--owner".to_string(),
-            multisig_pubkey.to_string(),
-            "--fee-payer".to_string(),
-            payer.pubkey().to_string(),
-            "--program-id".to_string(),
-            program_id.to_string(),
-        ];
-        if let Some(compute_unit_price) = compute_unit_price {
-            args.push("--with-compute-unit-price".to_string());
-            args.push(compute_unit_price.to_string());
-            args.push("--with-compute-unit-limit".to_string());
-            args.push(10_000.to_string());
-        }
-        config.program_client = program_client;
-        let result = exec_test_cmd(&config, &args).await.unwrap();
-        // the provided signer has a signature, denoted by the pubkey followed
-        // by "=" and the signature
-        let member_prefix = format!("{}=", multisig_members[1]);
-        let signature_position = result.find(&member_prefix).unwrap();
-        let end_position = result[signature_position..].find('\n').unwrap();
-        let signer = result[signature_position..].get(..end_position).unwrap();
-
-        // other three expected signers are absent
-        let absent_signers_position = result.find("Absent Signers").unwrap();
-        let absent_signers = result.get(absent_signers_position..).unwrap();
-        assert!(absent_signers.contains(&multisig_members[2].to_string()));
-        assert!(absent_signers.contains(&payer.pubkey().to_string()));
-
-        // and nothing else is marked a signer
-        assert!(!absent_signers.contains(&multisig_members[0].to_string()));
-        assert!(!absent_signers.contains(&multisig_pubkey.to_string()));
-        assert!(!absent_signers.contains(&nonce.to_string()));
-        assert!(!absent_signers.contains(&source.to_string()));
-        assert!(!absent_signers.contains(&destination.to_string()));
-        assert!(!absent_signers.contains(&token.to_string()));
-
-        // now send the transaction
-        let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-            ProgramRpcClient::new(config.rpc_client.clone(), ProgramRpcClientSendTransaction),
-        );
-        config.program_client = program_client;
-        let mut args = vec![
-            "spl-token".to_string(),
-            CommandName::Transfer.as_ref().to_string(),
-            token.to_string(),
-            "10".to_string(),
-            destination.to_string(),
-            "--blockhash".to_string(),
-            blockhash.to_string(),
-            "--nonce".to_string(),
-            nonce.to_string(),
-            "--nonce-authority".to_string(),
-            fee_payer_keypair_file.path().to_str().unwrap().to_string(),
-            "--mint-decimals".to_string(),
-            format!("{}", TEST_DECIMALS),
-            "--multisig-signer".to_string(),
-            multisig_members[1].to_string(),
-            "--multisig-signer".to_string(),
-            multisig_paths[2].path().to_str().unwrap().to_string(),
-            "--from".to_string(),
-            source.to_string(),
-            "--owner".to_string(),
-            multisig_pubkey.to_string(),
-            "--fee-payer".to_string(),
-            fee_payer_keypair_file.path().to_str().unwrap().to_string(),
-            "--program-id".to_string(),
-            program_id.to_string(),
-            "--signer".to_string(),
-            signer.to_string(),
-        ];
-        if let Some(compute_unit_price) = compute_unit_price {
-            args.push("--with-compute-unit-price".to_string());
-            args.push(compute_unit_price.to_string());
-            args.push("--with-compute-unit-limit".to_string());
-            args.push(10_000.to_string());
-        }
-        exec_test_cmd(&config, &args).await.unwrap();
-
-        let account = config.rpc_client.get_account(&source).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        let amount = spl_token::ui_amount_to_amount(90.0, TEST_DECIMALS);
-        assert_eq!(token_account.base.amount, amount);
-        let account = config.rpc_client.get_account(&destination).await.unwrap();
-        let token_account = StateWithExtensionsOwned::<Account>::unpack(account.data).unwrap();
-        let amount = spl_token::ui_amount_to_amount(10.0, TEST_DECIMALS);
-        assert_eq!(token_account.base.amount, amount);
-    }
-}
-
-async fn offline_multisig_transfer_with_nonce(test_validator: &TestValidator, payer: &Keypair) {
-    do_offline_multisig_transfer(test_validator, payer, None).await;
-    do_offline_multisig_transfer(test_validator, payer, Some(10)).await;
-}
-
-async fn withdraw_excess_lamports_from_multisig(test_validator: &TestValidator, payer: &Keypair) {
-    let m = 3;
-    let n = 5u8;
-    // need to add "payer" to make the config provide the right signer
-    let (multisig_members, multisig_paths): (Vec<_>, Vec<_>) =
-        std::iter::once(clone_keypair(payer))
-            .chain(std::iter::repeat_with(Keypair::new).take((n - 2) as usize))
-            .map(|s| {
-                let keypair_file = NamedTempFile::new().unwrap();
-                write_keypair_file(&s, &keypair_file).unwrap();
-                (s.pubkey(), keypair_file)
-            })
-            .unzip();
-
-    let fee_payer_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &fee_payer_keypair_file).unwrap();
-
-    let owner_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &owner_keypair_file).unwrap();
-
-    let program_id = &spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, program_id);
-
-    let multisig = Arc::new(Keypair::new());
-    let multisig_pubkey = multisig.pubkey();
-
-    // add the multisig as a member to itself, make it self-owned
-    let multisig_members = std::iter::once(multisig_pubkey)
-        .chain(multisig_members.iter().cloned())
-        .collect::<Vec<_>>();
-    let multisig_path = NamedTempFile::new().unwrap();
-    write_keypair_file(&multisig, &multisig_path).unwrap();
-    let multisig_paths = std::iter::once(&multisig_path)
-        .chain(multisig_paths.iter())
-        .collect::<Vec<_>>();
-
-    let multisig_strings = multisig_members
-        .iter()
-        .map(|p| p.to_string())
-        .collect::<Vec<_>>();
-    process_test_command(
-        &config,
-        payer,
-        [
-            "spl-token",
-            CommandName::CreateMultisig.into(),
-            "--address-keypair",
-            multisig_path.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-            &m.to_string(),
-        ]
-        .into_iter()
-        .chain(multisig_strings.iter().map(|p| p.as_str())),
-    )
-    .await
-    .unwrap();
-
-    let account = config
-        .rpc_client
-        .get_account(&multisig_pubkey)
-        .await
-        .unwrap();
-    let multisig = Multisig::unpack(&account.data).unwrap();
-    assert_eq!(multisig.m, m);
-    assert_eq!(multisig.n, n);
-
-    let receiver = Keypair::new();
-    let excess_lamports = 4000 * 1_000_000_000;
-
-    config
-        .rpc_client
-        .send_and_confirm_transaction(&Transaction::new_signed_with_payer(
-            &[system_instruction::transfer(
-                &payer.pubkey(),
-                &multisig_pubkey,
-                excess_lamports,
-            )],
-            Some(&payer.pubkey()),
-            &[&payer],
-            config.rpc_client.get_latest_blockhash().await.unwrap(),
-        ))
-        .await
-        .unwrap();
-
-    exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::WithdrawExcessLamports.into(),
-            &multisig_pubkey.to_string(),
-            &receiver.pubkey().to_string(),
-            "--owner",
-            &multisig_pubkey.to_string(),
-            "--multisig-signer",
-            multisig_paths[0].path().to_str().unwrap(),
-            "--multisig-signer",
-            multisig_paths[1].path().to_str().unwrap(),
-            "--multisig-signer",
-            multisig_paths[2].path().to_str().unwrap(),
-            "--fee-payer",
-            fee_payer_keypair_file.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    assert_eq!(
-        excess_lamports,
-        config
-            .rpc_client
-            .get_balance(&receiver.pubkey())
-            .await
-            .unwrap()
-    );
-}
-
-async fn withdraw_excess_lamports_from_mint(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = &spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, program_id);
-    let owner_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &owner_keypair_file).unwrap();
-
-    let receiver = Keypair::new();
-
-    let token_keypair = Keypair::new();
-    let token_path = NamedTempFile::new().unwrap();
-    write_keypair_file(&token_keypair, &token_path).unwrap();
-    let token_pubkey = token_keypair.pubkey();
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_path.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let excess_lamports = 4000 * 1_000_000_000;
-    config
-        .rpc_client
-        .send_and_confirm_transaction(&Transaction::new_signed_with_payer(
-            &[system_instruction::transfer(
-                &payer.pubkey(),
-                &token_pubkey,
-                excess_lamports,
-            )],
-            Some(&payer.pubkey()),
-            &[&payer],
-            config.rpc_client.get_latest_blockhash().await.unwrap(),
-        ))
-        .await
-        .unwrap();
-
-    exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::WithdrawExcessLamports.into(),
-            &token_pubkey.to_string(),
-            &receiver.pubkey().to_string(),
-            "--owner",
-            owner_keypair_file.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    assert_eq!(
-        excess_lamports,
-        config
-            .rpc_client
-            .get_balance(&receiver.pubkey())
-            .await
-            .unwrap()
-    );
-}
-
-async fn withdraw_excess_lamports_from_account(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = &spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, program_id);
-    let owner_keypair_file = NamedTempFile::new().unwrap();
-    write_keypair_file(payer, &owner_keypair_file).unwrap();
-
-    let receiver = Keypair::new();
-
-    let token_keypair = Keypair::new();
-    let token_path = NamedTempFile::new().unwrap();
-    write_keypair_file(&token_keypair, &token_path).unwrap();
-    let token_pubkey = token_keypair.pubkey();
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            token_path.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let excess_lamports = 4000 * 1_000_000_000;
-    let token_account =
-        create_associated_account(&config, payer, &token_pubkey, &payer.pubkey()).await;
-
-    config
-        .rpc_client
-        .send_and_confirm_transaction(&Transaction::new_signed_with_payer(
-            &[system_instruction::transfer(
-                &payer.pubkey(),
-                &token_account,
-                excess_lamports,
-            )],
-            Some(&payer.pubkey()),
-            &[&payer],
-            config.rpc_client.get_latest_blockhash().await.unwrap(),
-        ))
-        .await
-        .unwrap();
-
-    exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::WithdrawExcessLamports.into(),
-            &token_account.to_string(),
-            &receiver.pubkey().to_string(),
-            "--owner",
-            owner_keypair_file.path().to_str().unwrap(),
-            "--program-id",
-            &program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    assert_eq!(
-        excess_lamports,
-        config
-            .rpc_client
-            .get_balance(&receiver.pubkey())
-            .await
-            .unwrap()
-    );
-}
-
-async fn metadata_pointer(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let metadata_address = Pubkey::new_unique();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--metadata-address",
-            &metadata_address.to_string(),
-        ],
-    )
-    .await;
-
-    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let extension = mint_state.get_extension::<MetadataPointer>().unwrap();
-
-    assert_eq!(
-        extension.metadata_address,
-        Some(metadata_address).try_into().unwrap()
-    );
-
-    let new_metadata_address = Pubkey::new_unique();
-
-    let _new_result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadataAddress.into(),
-            &mint.to_string(),
-            &new_metadata_address.to_string(),
-        ],
-    )
-    .await;
-
-    let new_account = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state = StateWithExtensionsOwned::<Mint>::unpack(new_account.data).unwrap();
-
-    let new_extension = new_mint_state.get_extension::<MetadataPointer>().unwrap();
-
-    assert_eq!(
-        new_extension.metadata_address,
-        Some(new_metadata_address).try_into().unwrap()
-    );
-
-    let _result_with_disable = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadataAddress.into(),
-            &mint.to_string(),
-            "--disable",
-        ],
-    )
-    .await;
-
-    let new_account_disable = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state_disable =
-        StateWithExtensionsOwned::<Mint>::unpack(new_account_disable.data).unwrap();
-
-    let new_extension_disable = new_mint_state_disable
-        .get_extension::<MetadataPointer>()
-        .unwrap();
-
-    assert_eq!(
-        new_extension_disable.metadata_address,
-        None.try_into().unwrap()
-    );
-}
-
-async fn group_pointer(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let group_address = Pubkey::new_unique();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--group-address",
-            &group_address.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let value: serde_json::Value = serde_json::from_str(&result).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let extension = mint_state.get_extension::<GroupPointer>().unwrap();
-
-    assert_eq!(
-        extension.group_address,
-        Some(group_address).try_into().unwrap()
-    );
-
-    let new_group_address = Pubkey::new_unique();
-
-    let _new_result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateGroupAddress.into(),
-            &mint.to_string(),
-            &new_group_address.to_string(),
-        ],
-    )
-    .await;
-
-    let new_account = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state = StateWithExtensionsOwned::<Mint>::unpack(new_account.data).unwrap();
-
-    let new_extension = new_mint_state.get_extension::<GroupPointer>().unwrap();
-
-    assert_eq!(
-        new_extension.group_address,
-        Some(new_group_address).try_into().unwrap()
-    );
-
-    let _result_with_disable = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateGroupAddress.into(),
-            &mint.to_string(),
-            "--disable",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let new_account_disable = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state_disable =
-        StateWithExtensionsOwned::<Mint>::unpack(new_account_disable.data).unwrap();
-
-    let new_extension_disable = new_mint_state_disable
-        .get_extension::<GroupPointer>()
-        .unwrap();
-
-    assert_eq!(
-        new_extension_disable.group_address,
-        None.try_into().unwrap()
-    );
-}
-
-async fn group_member_pointer(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let member_address = Pubkey::new_unique();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--member-address",
-            &member_address.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let value: serde_json::Value = serde_json::from_str(&result).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let extension = mint_state.get_extension::<GroupMemberPointer>().unwrap();
-
-    assert_eq!(
-        extension.member_address,
-        Some(member_address).try_into().unwrap()
-    );
-
-    let new_member_address = Pubkey::new_unique();
-
-    let _new_result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMemberAddress.into(),
-            &mint.to_string(),
-            &new_member_address.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let new_account = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state = StateWithExtensionsOwned::<Mint>::unpack(new_account.data).unwrap();
-
-    let new_extension = new_mint_state
-        .get_extension::<GroupMemberPointer>()
-        .unwrap();
-
-    assert_eq!(
-        new_extension.member_address,
-        Some(new_member_address).try_into().unwrap()
-    );
-
-    let _result_with_disable = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMemberAddress.into(),
-            &mint.to_string(),
-            "--disable",
-        ],
-    )
-    .await;
-
-    let new_account_disable = config.rpc_client.get_account(&mint).await.unwrap();
-    let new_mint_state_disable =
-        StateWithExtensionsOwned::<Mint>::unpack(new_account_disable.data).unwrap();
-
-    let new_extension_disable = new_mint_state_disable
-        .get_extension::<GroupMemberPointer>()
-        .unwrap();
-
-    assert_eq!(
-        new_extension_disable.member_address,
-        None.try_into().unwrap()
-    );
-}
-
-async fn transfer_hook(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let mut config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let transfer_hook_program_id = Pubkey::new_unique();
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--transfer-hook",
-            &transfer_hook_program_id.to_string(),
-        ],
-    )
-    .await;
-
-    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_state.get_extension::<TransferHook>().unwrap();
-
-    assert_eq!(
-        extension.program_id,
-        Some(transfer_hook_program_id).try_into().unwrap()
-    );
-
-    let new_transfer_hook_program_id = Pubkey::new_unique();
-
-    let _new_result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::SetTransferHook.into(),
-            &mint.to_string(),
-            &new_transfer_hook_program_id.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_state.get_extension::<TransferHook>().unwrap();
-
-    assert_eq!(
-        extension.program_id,
-        Some(new_transfer_hook_program_id).try_into().unwrap()
-    );
-
-    // Make sure that parsing transfer hook accounts works
-    let real_program_client = config.program_client;
-    let blockhash = Hash::default();
-    let program_client: Arc<dyn ProgramClient<ProgramRpcClientSendTransaction>> = Arc::new(
-        ProgramOfflineClient::new(blockhash, ProgramRpcClientSendTransaction),
-    );
-    config.program_client = program_client;
-    let _result = exec_test_cmd(
-        &config,
-        &[
-            "spl-token",
-            CommandName::Transfer.into(),
-            &mint.to_string(),
-            "10",
-            &Pubkey::new_unique().to_string(),
-            "--blockhash",
-            &blockhash.to_string(),
-            "--nonce",
-            &Pubkey::new_unique().to_string(),
-            "--nonce-authority",
-            &Pubkey::new_unique().to_string(),
-            "--sign-only",
-            "--mint-decimals",
-            &format!("{}", TEST_DECIMALS),
-            "--from",
-            &Pubkey::new_unique().to_string(),
-            "--owner",
-            &Pubkey::new_unique().to_string(),
-            "--transfer-hook-account",
-            &format!("{}:readonly", Pubkey::new_unique()),
-            "--transfer-hook-account",
-            &format!("{}:writable", Pubkey::new_unique()),
-            "--transfer-hook-account",
-            &format!("{}:readonly-signer", Pubkey::new_unique()),
-            "--transfer-hook-account",
-            &format!("{}:writable-signer", Pubkey::new_unique()),
-        ],
-    )
-    .await
-    .unwrap();
-
-    config.program_client = real_program_client;
-    let _result_with_disable = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::SetTransferHook.into(),
-            &mint.to_string(),
-            "--disable",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_state.get_extension::<TransferHook>().unwrap();
-
-    assert_eq!(extension.program_id, None.try_into().unwrap());
-}
-
-async fn metadata(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let name = "this";
-    let symbol = "is";
-    let uri = "METADATA!";
-
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--enable-metadata",
-        ],
-    )
-    .await;
-
-    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let extension = mint_state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(extension.metadata_address, Some(mint).try_into().unwrap());
-
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::InitializeMetadata.into(),
-            &mint.to_string(),
-            name,
-            symbol,
-            uri,
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let fetched_metadata = mint_state
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata.name, name);
-    assert_eq!(fetched_metadata.symbol, symbol);
-    assert_eq!(fetched_metadata.uri, uri);
-    assert_eq!(fetched_metadata.mint, mint);
-    assert_eq!(
-        fetched_metadata.update_authority,
-        Some(payer.pubkey()).try_into().unwrap()
-    );
-    assert_eq!(fetched_metadata.additional_metadata, []);
-
-    // update canonical field
-    let new_value = "THIS!";
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadata.into(),
-            &mint.to_string(),
-            "NAME",
-            new_value,
-        ],
-    )
-    .await
-    .unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let fetched_metadata = mint_state
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata.name, new_value);
-
-    // add new field
-    let field = "My field!";
-    let value = "Try and stop me";
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadata.into(),
-            &mint.to_string(),
-            field,
-            value,
-        ],
-    )
-    .await
-    .unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let fetched_metadata = mint_state
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata.additional_metadata,
-        [(field.to_string(), value.to_string())]
-    );
-
-    // remove it
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadata.into(),
-            &mint.to_string(),
-            field,
-            "--remove",
-        ],
-    )
-    .await
-    .unwrap();
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let fetched_metadata = mint_state
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata.additional_metadata, []);
-
-    // fail to remove name
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateMetadata.into(),
-            &mint.to_string(),
-            "name",
-            "--remove",
-        ],
-    )
-    .await
-    .unwrap_err();
-
-    // update authority
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &mint.to_string(),
-            "metadata",
-            &mint.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let fetched_metadata = mint_state
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(
-        fetched_metadata.update_authority,
-        Some(mint).try_into().unwrap()
-    );
-}
-
-async fn group(test_validator: &TestValidator, payer: &Keypair) {
-    let program_id = spl_token_2022::id();
-    let config = test_config_with_default_signer(test_validator, payer, &program_id);
-    let max_size = 10;
-
-    // Create token
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--enable-group",
-        ],
-    )
-    .await;
-
-    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-
-    // Initialize the group
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::InitializeGroup.into(),
-            &mint.to_string(),
-            &max_size.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let extension = mint_state.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(
-        extension.update_authority,
-        Some(payer.pubkey()).try_into().unwrap()
-    );
-    assert_eq!(extension.max_size, max_size.into());
-
-    let extension_pointer = mint_state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(
-        extension_pointer.group_address,
-        Some(mint).try_into().unwrap()
-    );
-
-    let new_max_size = 12;
-
-    // Update token-group max-size
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::UpdateGroupMaxSize.into(),
-            &mint.to_string(),
-            &new_max_size.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-
-    let updated_mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-
-    let updated_extension = updated_mint_state.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(updated_extension.max_size, new_max_size.into());
-
-    // Create member token
-    let result = process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::CreateToken.into(),
-            "--program-id",
-            &program_id.to_string(),
-            "--enable-member",
-        ],
-    )
-    .await
-    .unwrap();
-
-    let value: serde_json::Value = serde_json::from_str(&result).unwrap();
-    let member_mint =
-        Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
-
-    // Initialize it as a member of the group
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::InitializeMember.into(),
-            &member_mint.to_string(),
-            &mint.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let group_mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = group_mint_state.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(u32::from(extension.size), 1);
-
-    let account = config.rpc_client.get_account(&member_mint).await.unwrap();
-    let member_mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = member_mint_state
-        .get_extension::<TokenGroupMember>()
-        .unwrap();
-    assert_eq!(extension.group, mint);
-    assert_eq!(extension.mint, member_mint);
-    assert_eq!(u32::from(extension.member_number), 1);
-
-    // update authority
-    process_test_command(
-        &config,
-        payer,
-        &[
-            "spl-token",
-            CommandName::Authorize.into(),
-            &mint.to_string(),
-            "group",
-            &mint.to_string(),
-        ],
-    )
-    .await
-    .unwrap();
-
-    let account = config.rpc_client.get_account(&mint).await.unwrap();
-    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
-    let extension = mint_state.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(extension.update_authority, Some(mint).try_into().unwrap());
-}
-
-async fn compute_budget(test_validator: &TestValidator, payer: &Keypair) {
-    for program_id in VALID_TOKEN_PROGRAM_IDS.iter() {
-        let mut config = test_config_with_default_signer(test_validator, payer, program_id);
-        config.compute_unit_price = Some(42);
-        config.compute_unit_limit = ComputeUnitLimit::Static(40_000);
-        run_transfer_test(&config, payer).await;
-    }
-}
diff --git a/token/cli/tests/config.rs b/token/cli/tests/config.rs
deleted file mode 100644
index ff0bfad9dfb..00000000000
--- a/token/cli/tests/config.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use assert_cmd::cmd::Command;
-
-#[test]
-fn invalid_config_will_cause_commands_to_fail() {
-    let mut cmd = Command::cargo_bin("spl-token").unwrap();
-    let args = &["address", "--config", "~/nonexistent/config.yml"];
-    cmd.args(args)
-        .assert()
-        .stderr("error: Could not find config file `~/nonexistent/config.yml`\n");
-    cmd.args(args).assert().code(1).failure();
-}
diff --git a/token/client/Cargo.toml b/token/client/Cargo.toml
deleted file mode 100644
index 2d58adb0013..00000000000
--- a/token/client/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL-Token Rust Client"
-edition = "2021"
-license = "Apache-2.0"
-name = "spl-token-client"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "0.10.0"
-
-[dependencies]
-async-trait = "0.1"
-curve25519-dalek = "3.2.1"
-futures = "0.3.30"
-futures-util = "0.3"
-solana-banks-interface = ">=1.18.11,<=2"
-solana-cli-output = { version = ">=1.18.11,<=2", optional = true }
-solana-program-test = ">=1.18.11,<=2"
-solana-rpc-client = ">=1.18.11,<=2"
-solana-rpc-client-api = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-# We never want the entrypoint for ATA, but we want the entrypoint for token when
-# testing token
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program", features = [
-  "no-entrypoint",
-] }
-spl-memo = { version = "4.0", path = "../../memo/program", features = [
-  "no-entrypoint",
-] }
-spl-token = { version = "4.0", path = "../program", features = [
-  "no-entrypoint",
-] }
-spl-token-2022 = { version = "3.0.2", path = "../program-2022" }
-spl-token-group-interface = { version = "0.2.3", path = "../../token-group/interface" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-spl-transfer-hook-interface = { version = "0.6.3", path = "../transfer-hook/interface" }
-thiserror = "1.0"
-
-[features]
-default = ["display"]
-display = ["dep:solana-cli-output"]
diff --git a/token/client/src/client.rs b/token/client/src/client.rs
deleted file mode 100644
index 12f3faf17a4..00000000000
--- a/token/client/src/client.rs
+++ /dev/null
@@ -1,426 +0,0 @@
-use {
-    async_trait::async_trait,
-    solana_banks_interface::BanksTransactionResultWithSimulation,
-    solana_program_test::{tokio::sync::Mutex, BanksClient, ProgramTestContext},
-    solana_rpc_client::nonblocking::rpc_client::RpcClient,
-    solana_rpc_client_api::response::RpcSimulateTransactionResult,
-    solana_sdk::{
-        account::Account, hash::Hash, pubkey::Pubkey, signature::Signature,
-        transaction::Transaction,
-    },
-    std::{fmt, future::Future, pin::Pin, sync::Arc},
-};
-
-type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
-
-/// Basic trait for sending transactions to validator.
-pub trait SendTransaction {
-    type Output;
-}
-
-/// Basic trait for simulating transactions in a validator.
-pub trait SimulateTransaction {
-    type SimulationOutput: SimulationResult;
-}
-
-/// Trait for the output of a simulation
-pub trait SimulationResult {
-    fn get_compute_units_consumed(&self) -> ProgramClientResult<u64>;
-}
-
-/// Extends basic `SendTransaction` trait with function `send` where client is
-/// `&mut BanksClient`. Required for `ProgramBanksClient`.
-pub trait SendTransactionBanksClient: SendTransaction {
-    fn send<'a>(
-        &self,
-        client: &'a mut BanksClient,
-        transaction: Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>>;
-}
-
-/// Extends basic `SimulateTransaction` trait with function `simulation` where
-/// client is `&mut BanksClient`. Required for `ProgramBanksClient`.
-pub trait SimulateTransactionBanksClient: SimulateTransaction {
-    fn simulate<'a>(
-        &self,
-        client: &'a mut BanksClient,
-        transaction: Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::SimulationOutput>>;
-}
-
-/// Send transaction to validator using `BanksClient::process_transaction`.
-#[derive(Debug, Clone, Copy, Default)]
-pub struct ProgramBanksClientProcessTransaction;
-
-impl SendTransaction for ProgramBanksClientProcessTransaction {
-    type Output = ();
-}
-
-impl SendTransactionBanksClient for ProgramBanksClientProcessTransaction {
-    fn send<'a>(
-        &self,
-        client: &'a mut BanksClient,
-        transaction: Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>> {
-        Box::pin(async move {
-            client
-                .process_transaction(transaction)
-                .await
-                .map_err(Into::into)
-        })
-    }
-}
-
-impl SimulationResult for BanksTransactionResultWithSimulation {
-    fn get_compute_units_consumed(&self) -> ProgramClientResult<u64> {
-        self.simulation_details
-            .as_ref()
-            .map(|x| x.units_consumed)
-            .ok_or("No simulation results found".into())
-    }
-}
-
-impl SimulateTransaction for ProgramBanksClientProcessTransaction {
-    type SimulationOutput = BanksTransactionResultWithSimulation;
-}
-
-impl SimulateTransactionBanksClient for ProgramBanksClientProcessTransaction {
-    fn simulate<'a>(
-        &self,
-        client: &'a mut BanksClient,
-        transaction: Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::SimulationOutput>> {
-        Box::pin(async move {
-            client
-                .simulate_transaction(transaction)
-                .await
-                .map_err(Into::into)
-        })
-    }
-}
-
-/// Extends basic `SendTransaction` trait with function `send` where client is
-/// `&RpcClient`. Required for `ProgramRpcClient`.
-pub trait SendTransactionRpc: SendTransaction {
-    fn send<'a>(
-        &self,
-        client: &'a RpcClient,
-        transaction: &'a Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>>;
-}
-
-/// Extends basic `SimulateTransaction` trait with function `simulate` where
-/// client is `&RpcClient`. Required for `ProgramRpcClient`.
-pub trait SimulateTransactionRpc: SimulateTransaction {
-    fn simulate<'a>(
-        &self,
-        client: &'a RpcClient,
-        transaction: &'a Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::SimulationOutput>>;
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub struct ProgramRpcClientSendTransaction;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum RpcClientResponse {
-    Signature(Signature),
-    Transaction(Transaction),
-    Simulation(RpcSimulateTransactionResult),
-}
-
-impl SendTransaction for ProgramRpcClientSendTransaction {
-    type Output = RpcClientResponse;
-}
-
-impl SendTransactionRpc for ProgramRpcClientSendTransaction {
-    fn send<'a>(
-        &self,
-        client: &'a RpcClient,
-        transaction: &'a Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::Output>> {
-        Box::pin(async move {
-            if !transaction.is_signed() {
-                return Err("Cannot send transaction: not fully signed".into());
-            }
-
-            client
-                .send_and_confirm_transaction(transaction)
-                .await
-                .map(RpcClientResponse::Signature)
-                .map_err(Into::into)
-        })
-    }
-}
-
-impl SimulationResult for RpcClientResponse {
-    fn get_compute_units_consumed(&self) -> ProgramClientResult<u64> {
-        match self {
-            // `Transaction` is the result of an offline simulation. The error
-            // should be properly handled by a caller that supports offline
-            // signing
-            Self::Signature(_) | Self::Transaction(_) => Err("Not a simulation result".into()),
-            Self::Simulation(simulation_result) => simulation_result
-                .units_consumed
-                .ok_or("No simulation results found".into()),
-        }
-    }
-}
-
-impl SimulateTransaction for ProgramRpcClientSendTransaction {
-    type SimulationOutput = RpcClientResponse;
-}
-
-impl SimulateTransactionRpc for ProgramRpcClientSendTransaction {
-    fn simulate<'a>(
-        &self,
-        client: &'a RpcClient,
-        transaction: &'a Transaction,
-    ) -> BoxFuture<'a, ProgramClientResult<Self::SimulationOutput>> {
-        Box::pin(async move {
-            client
-                .simulate_transaction(transaction)
-                .await
-                .map(|r| RpcClientResponse::Simulation(r.value))
-                .map_err(Into::into)
-        })
-    }
-}
-
-pub type ProgramClientError = Box<dyn std::error::Error + Send + Sync>;
-pub type ProgramClientResult<T> = Result<T, ProgramClientError>;
-
-/// Generic client interface for programs.
-#[async_trait]
-pub trait ProgramClient<ST>
-where
-    ST: SendTransaction + SimulateTransaction,
-{
-    async fn get_minimum_balance_for_rent_exemption(
-        &self,
-        data_len: usize,
-    ) -> ProgramClientResult<u64>;
-
-    async fn get_latest_blockhash(&self) -> ProgramClientResult<Hash>;
-
-    async fn send_transaction(&self, transaction: &Transaction) -> ProgramClientResult<ST::Output>;
-
-    async fn get_account(&self, address: Pubkey) -> ProgramClientResult<Option<Account>>;
-
-    async fn simulate_transaction(
-        &self,
-        transaction: &Transaction,
-    ) -> ProgramClientResult<ST::SimulationOutput>;
-}
-
-enum ProgramBanksClientContext {
-    Client(Arc<Mutex<BanksClient>>),
-    Context(Arc<Mutex<ProgramTestContext>>),
-}
-
-/// Program client for `BanksClient` from crate `solana-program-test`.
-pub struct ProgramBanksClient<ST> {
-    context: ProgramBanksClientContext,
-    send: ST,
-}
-
-impl<ST> fmt::Debug for ProgramBanksClient<ST> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ProgramBanksClient").finish()
-    }
-}
-
-impl<ST> ProgramBanksClient<ST> {
-    fn new(context: ProgramBanksClientContext, send: ST) -> Self {
-        Self { context, send }
-    }
-
-    pub fn new_from_client(client: Arc<Mutex<BanksClient>>, send: ST) -> Self {
-        Self::new(ProgramBanksClientContext::Client(client), send)
-    }
-
-    pub fn new_from_context(context: Arc<Mutex<ProgramTestContext>>, send: ST) -> Self {
-        Self::new(ProgramBanksClientContext::Context(context), send)
-    }
-
-    async fn run_in_lock<F, O>(&self, f: F) -> O
-    where
-        for<'a> F: Fn(&'a mut BanksClient) -> BoxFuture<'a, O>,
-    {
-        match &self.context {
-            ProgramBanksClientContext::Client(client) => {
-                let mut lock = client.lock().await;
-                f(&mut lock).await
-            }
-            ProgramBanksClientContext::Context(context) => {
-                let mut lock = context.lock().await;
-                f(&mut lock.banks_client).await
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl<ST> ProgramClient<ST> for ProgramBanksClient<ST>
-where
-    ST: SendTransactionBanksClient + SimulateTransactionBanksClient + Send + Sync,
-{
-    async fn get_minimum_balance_for_rent_exemption(
-        &self,
-        data_len: usize,
-    ) -> ProgramClientResult<u64> {
-        self.run_in_lock(|client| {
-            Box::pin(async move {
-                let rent = client.get_rent().await?;
-                Ok(rent.minimum_balance(data_len))
-            })
-        })
-        .await
-    }
-
-    async fn get_latest_blockhash(&self) -> ProgramClientResult<Hash> {
-        self.run_in_lock(|client| {
-            Box::pin(async move { client.get_latest_blockhash().await.map_err(Into::into) })
-        })
-        .await
-    }
-
-    async fn send_transaction(&self, transaction: &Transaction) -> ProgramClientResult<ST::Output> {
-        self.run_in_lock(|client| {
-            let transaction = transaction.clone();
-            self.send.send(client, transaction)
-        })
-        .await
-    }
-
-    async fn simulate_transaction(
-        &self,
-        transaction: &Transaction,
-    ) -> ProgramClientResult<ST::SimulationOutput> {
-        self.run_in_lock(|client| {
-            let transaction = transaction.clone();
-            self.send.simulate(client, transaction)
-        })
-        .await
-    }
-
-    async fn get_account(&self, address: Pubkey) -> ProgramClientResult<Option<Account>> {
-        self.run_in_lock(|client| {
-            Box::pin(async move { client.get_account(address).await.map_err(Into::into) })
-        })
-        .await
-    }
-}
-
-/// Program client for `RpcClient` from crate `solana-client`.
-pub struct ProgramRpcClient<ST> {
-    client: Arc<RpcClient>,
-    send: ST,
-}
-
-impl<ST> fmt::Debug for ProgramRpcClient<ST> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ProgramRpcClient").finish()
-    }
-}
-
-impl<ST> ProgramRpcClient<ST> {
-    pub fn new(client: Arc<RpcClient>, send: ST) -> Self {
-        Self { client, send }
-    }
-}
-
-#[async_trait]
-impl<ST> ProgramClient<ST> for ProgramRpcClient<ST>
-where
-    ST: SendTransactionRpc + SimulateTransactionRpc + Send + Sync,
-{
-    async fn get_minimum_balance_for_rent_exemption(
-        &self,
-        data_len: usize,
-    ) -> ProgramClientResult<u64> {
-        self.client
-            .get_minimum_balance_for_rent_exemption(data_len)
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn get_latest_blockhash(&self) -> ProgramClientResult<Hash> {
-        self.client.get_latest_blockhash().await.map_err(Into::into)
-    }
-
-    async fn send_transaction(&self, transaction: &Transaction) -> ProgramClientResult<ST::Output> {
-        self.send.send(&self.client, transaction).await
-    }
-
-    async fn simulate_transaction(
-        &self,
-        transaction: &Transaction,
-    ) -> ProgramClientResult<ST::SimulationOutput> {
-        self.send.simulate(&self.client, transaction).await
-    }
-
-    async fn get_account(&self, address: Pubkey) -> ProgramClientResult<Option<Account>> {
-        Ok(self
-            .client
-            .get_account_with_commitment(&address, self.client.commitment())
-            .await?
-            .value)
-    }
-}
-
-/// Program client for offline signing.
-pub struct ProgramOfflineClient<ST> {
-    blockhash: Hash,
-    _send: ST,
-}
-
-impl<ST> fmt::Debug for ProgramOfflineClient<ST> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ProgramOfflineClient").finish()
-    }
-}
-
-impl<ST> ProgramOfflineClient<ST> {
-    pub fn new(blockhash: Hash, send: ST) -> Self {
-        Self {
-            blockhash,
-            _send: send,
-        }
-    }
-}
-
-#[async_trait]
-impl<ST> ProgramClient<ST> for ProgramOfflineClient<ST>
-where
-    ST: SendTransaction<Output = RpcClientResponse>
-        + SimulateTransaction<SimulationOutput = RpcClientResponse>
-        + Send
-        + Sync,
-{
-    async fn get_minimum_balance_for_rent_exemption(
-        &self,
-        _data_len: usize,
-    ) -> ProgramClientResult<u64> {
-        Err("Unable to fetch minimum balance for rent exemption in offline mode".into())
-    }
-
-    async fn get_latest_blockhash(&self) -> ProgramClientResult<Hash> {
-        Ok(self.blockhash)
-    }
-
-    async fn send_transaction(&self, transaction: &Transaction) -> ProgramClientResult<ST::Output> {
-        Ok(RpcClientResponse::Transaction(transaction.clone()))
-    }
-
-    async fn simulate_transaction(
-        &self,
-        transaction: &Transaction,
-    ) -> ProgramClientResult<ST::SimulationOutput> {
-        Ok(RpcClientResponse::Transaction(transaction.clone()))
-    }
-
-    async fn get_account(&self, _address: Pubkey) -> ProgramClientResult<Option<Account>> {
-        Err("Unable to fetch account in offline mode".into())
-    }
-}
diff --git a/token/client/src/lib.rs b/token/client/src/lib.rs
deleted file mode 100644
index b0d017870bc..00000000000
--- a/token/client/src/lib.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-pub mod client;
-pub mod output;
-pub mod token;
-
-/// Helper functions to generate split zero-knowledge proofs for confidential
-/// transfers.
-///
-/// The logic in this submodule should belong to the `solana-zk-token-sdk` and
-/// will be removed with an upgrade to the Solana program in the future.
-pub mod proof_generation;
-
-pub use spl_token_2022;
diff --git a/token/client/src/output.rs b/token/client/src/output.rs
deleted file mode 100644
index e3436ca435d..00000000000
--- a/token/client/src/output.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![cfg(feature = "display")]
-
-use {crate::client::RpcClientResponse, solana_cli_output::display::writeln_transaction, std::fmt};
-
-impl fmt::Display for RpcClientResponse {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            RpcClientResponse::Signature(signature) => writeln!(f, "Signature: {}", signature),
-            RpcClientResponse::Transaction(transaction) => {
-                writeln!(f, "Transaction:")?;
-                writeln_transaction(f, &transaction.clone().into(), None, "  ", None, None)
-            }
-            RpcClientResponse::Simulation(result) => {
-                writeln!(f, "Simulation:")?;
-                // maybe implement another formatter on simulation result?
-                writeln!(f, "{result:?}")
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        solana_sdk::{
-            hash::Hash,
-            pubkey::Pubkey,
-            signature::{Signature, Signer, SIGNATURE_BYTES},
-            signer::keypair::Keypair,
-            system_instruction,
-            transaction::Transaction,
-        },
-    };
-
-    #[test]
-    fn display_signature() {
-        let signature_bytes = [202u8; SIGNATURE_BYTES];
-        let signature = RpcClientResponse::Signature(Signature::from(signature_bytes));
-        println!("{}", signature);
-    }
-
-    #[test]
-    fn display_transaction() {
-        let payer = Keypair::new();
-        let transaction = Transaction::new_signed_with_payer(
-            &[system_instruction::transfer(
-                &payer.pubkey(),
-                &Pubkey::new_unique(),
-                10,
-            )],
-            Some(&payer.pubkey()),
-            &[&payer],
-            Hash::default(),
-        );
-        let transaction = RpcClientResponse::Transaction(transaction);
-        println!("{}", transaction);
-    }
-}
diff --git a/token/client/src/proof_generation.rs b/token/client/src/proof_generation.rs
deleted file mode 100644
index 6fff0fae3bf..00000000000
--- a/token/client/src/proof_generation.rs
+++ /dev/null
@@ -1,381 +0,0 @@
-//! Helper functions to generate split zero-knowledge proofs for confidential
-//! transfers in the Confidential Transfer Extension.
-//!
-//! The logic in this submodule should belong to the `solana-zk-token-sdk` and
-//! will be removed with an upgrade to the Solana program.
-
-use {
-    curve25519_dalek::scalar::Scalar,
-    spl_token_2022::{
-        error::TokenError,
-        extension::confidential_transfer::{
-            ciphertext_extraction::{transfer_amount_source_ciphertext, SourceDecryptHandles},
-            processor::verify_and_split_deposit_amount,
-        },
-        solana_zk_token_sdk::{
-            encryption::{
-                auth_encryption::{AeCiphertext, AeKey},
-                elgamal::{DecryptHandle, ElGamalCiphertext, ElGamalKeypair, ElGamalPubkey},
-                grouped_elgamal::GroupedElGamal,
-                pedersen::{Pedersen, PedersenCommitment, PedersenOpening},
-            },
-            instruction::{
-                transfer::{
-                    combine_lo_hi_commitments, combine_lo_hi_openings, FeeEncryption,
-                    FeeParameters, TransferAmountCiphertext,
-                },
-                BatchedGroupedCiphertext2HandlesValidityProofData, BatchedRangeProofU256Data,
-                CiphertextCommitmentEqualityProofData, FeeSigmaProofData,
-            },
-            zk_token_elgamal::ops::subtract_with_lo_hi,
-        },
-    },
-};
-
-/// The main logic to create the five split proof data for a transfer with fee.
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_with_fee_split_proof_data(
-    current_available_balance: &ElGamalCiphertext,
-    current_decryptable_available_balance: &AeCiphertext,
-    transfer_amount: u64,
-    source_elgamal_keypair: &ElGamalKeypair,
-    aes_key: &AeKey,
-    destination_elgamal_pubkey: &ElGamalPubkey,
-    auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-    withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-    transfer_fee_parameters: &FeeParameters,
-) -> Result<
-    (
-        CiphertextCommitmentEqualityProofData,
-        BatchedGroupedCiphertext2HandlesValidityProofData,
-        FeeSigmaProofData,
-        BatchedGroupedCiphertext2HandlesValidityProofData,
-        BatchedRangeProofU256Data,
-        SourceDecryptHandles,
-    ),
-    TokenError,
-> {
-    let default_auditor_pubkey = ElGamalPubkey::default();
-    let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-    // Split the transfer amount into the low and high bit components.
-    let (transfer_amount_lo, transfer_amount_hi) =
-        verify_and_split_deposit_amount(transfer_amount)?;
-
-    // Encrypt the `lo` and `hi` transfer amounts.
-    let (transfer_amount_grouped_ciphertext_lo, transfer_amount_opening_lo) =
-        TransferAmountCiphertext::new(
-            transfer_amount_lo,
-            source_elgamal_keypair.pubkey(),
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-        );
-
-    let (transfer_amount_grouped_ciphertext_hi, transfer_amount_opening_hi) =
-        TransferAmountCiphertext::new(
-            transfer_amount_hi,
-            source_elgamal_keypair.pubkey(),
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-        );
-
-    // Decrypt the current available balance at the source
-    let current_decrypted_available_balance = current_decryptable_available_balance
-        .decrypt(aes_key)
-        .ok_or(TokenError::AccountDecryption)?;
-
-    // Compute the remaining balance at the source
-    let new_decrypted_available_balance = current_decrypted_available_balance
-        .checked_sub(transfer_amount)
-        .ok_or(TokenError::InsufficientFunds)?;
-
-    // Create a new Pedersen commitment for the remaining balance at the source
-    let (new_available_balance_commitment, new_source_opening) =
-        Pedersen::new(new_decrypted_available_balance);
-
-    // Compute the remaining balance at the source as ElGamal ciphertexts
-    let transfer_amount_source_ciphertext_lo =
-        transfer_amount_source_ciphertext(&transfer_amount_grouped_ciphertext_lo.into());
-    let transfer_amount_source_ciphertext_hi =
-        transfer_amount_source_ciphertext(&transfer_amount_grouped_ciphertext_hi.into());
-
-    let current_available_balance = (*current_available_balance).into();
-    let new_available_balance_ciphertext = subtract_with_lo_hi(
-        &current_available_balance,
-        &transfer_amount_source_ciphertext_lo,
-        &transfer_amount_source_ciphertext_hi,
-    )
-    .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    let new_available_balance_ciphertext: ElGamalCiphertext = new_available_balance_ciphertext
-        .try_into()
-        .map_err(|_| TokenError::MalformedCiphertext)?;
-
-    // generate equality proof data
-    let equality_proof_data = CiphertextCommitmentEqualityProofData::new(
-        source_elgamal_keypair,
-        &new_available_balance_ciphertext,
-        &new_available_balance_commitment,
-        &new_source_opening,
-        new_decrypted_available_balance,
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    // create source decrypt handle
-    let source_decrypt_handle_lo =
-        DecryptHandle::new(source_elgamal_keypair.pubkey(), &transfer_amount_opening_lo);
-    let source_decrypt_handle_hi =
-        DecryptHandle::new(source_elgamal_keypair.pubkey(), &transfer_amount_opening_hi);
-
-    let source_decrypt_handles = SourceDecryptHandles {
-        lo: source_decrypt_handle_lo.into(),
-        hi: source_decrypt_handle_hi.into(),
-    };
-
-    // encrypt the transfer amount under the destination and auditor ElGamal public
-    // key
-    let transfer_amount_destination_auditor_ciphertext_lo = GroupedElGamal::encrypt_with(
-        [destination_elgamal_pubkey, auditor_elgamal_pubkey],
-        transfer_amount_lo,
-        &transfer_amount_opening_lo,
-    );
-    let transfer_amount_destination_auditor_ciphertext_hi = GroupedElGamal::encrypt_with(
-        [destination_elgamal_pubkey, auditor_elgamal_pubkey],
-        transfer_amount_hi,
-        &transfer_amount_opening_hi,
-    );
-
-    // generate transfer amount ciphertext validity data
-    let transfer_amount_ciphertext_validity_proof_data =
-        BatchedGroupedCiphertext2HandlesValidityProofData::new(
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-            &transfer_amount_destination_auditor_ciphertext_lo,
-            &transfer_amount_destination_auditor_ciphertext_hi,
-            transfer_amount_lo,
-            transfer_amount_hi,
-            &transfer_amount_opening_lo,
-            &transfer_amount_opening_hi,
-        )
-        .map_err(|_| TokenError::ProofGeneration)?;
-
-    // calculate fee
-    let transfer_fee_basis_points = transfer_fee_parameters.fee_rate_basis_points;
-    let transfer_fee_maximum_fee = transfer_fee_parameters.maximum_fee;
-    let (raw_fee_amount, delta_fee) =
-        calculate_raw_fee_and_delta(transfer_amount, transfer_fee_basis_points)
-            .ok_or(TokenError::Overflow)?;
-
-    // if raw fee is greater than the maximum fee, then use the maximum fee for the
-    // fee amount
-    let fee_amount = std::cmp::min(transfer_fee_maximum_fee, raw_fee_amount);
-
-    // split and encrypt fee
-    let (fee_amount_lo, fee_amount_hi) = verify_and_split_deposit_amount(fee_amount)?;
-    let (fee_ciphertext_lo, fee_opening_lo) = FeeEncryption::new(
-        fee_amount_lo,
-        destination_elgamal_pubkey,
-        withdraw_withheld_authority_elgamal_pubkey,
-    );
-    let (fee_ciphertext_hi, fee_opening_hi) = FeeEncryption::new(
-        fee_amount_hi,
-        destination_elgamal_pubkey,
-        withdraw_withheld_authority_elgamal_pubkey,
-    );
-
-    // create combined commitments and openings to be used to generate proofs
-    const TRANSFER_AMOUNT_LO_BIT_LENGTH: usize = 16;
-    let combined_transfer_amount_commitment = combine_lo_hi_commitments(
-        transfer_amount_grouped_ciphertext_lo.get_commitment(),
-        transfer_amount_grouped_ciphertext_hi.get_commitment(),
-        TRANSFER_AMOUNT_LO_BIT_LENGTH,
-    );
-    let combined_transfer_amount_opening = combine_lo_hi_openings(
-        &transfer_amount_opening_lo,
-        &transfer_amount_opening_hi,
-        TRANSFER_AMOUNT_LO_BIT_LENGTH,
-    );
-
-    const FEE_AMOUNT_LO_BIT_LENGTH: usize = 16;
-    let combined_fee_commitment = combine_lo_hi_commitments(
-        fee_ciphertext_lo.get_commitment(),
-        fee_ciphertext_hi.get_commitment(),
-        FEE_AMOUNT_LO_BIT_LENGTH,
-    );
-    let combined_fee_opening =
-        combine_lo_hi_openings(&fee_opening_lo, &fee_opening_hi, FEE_AMOUNT_LO_BIT_LENGTH);
-
-    // compute claimed and real delta commitment
-    let (claimed_commitment, claimed_opening) = Pedersen::new(delta_fee);
-    let (delta_commitment, delta_opening) = compute_delta_commitment_and_opening(
-        (
-            &combined_transfer_amount_commitment,
-            &combined_transfer_amount_opening,
-        ),
-        (&combined_fee_commitment, &combined_fee_opening),
-        transfer_fee_basis_points,
-    );
-
-    // generate fee sigma proof
-    let fee_sigma_proof_data = FeeSigmaProofData::new(
-        &combined_fee_commitment,
-        &delta_commitment,
-        &claimed_commitment,
-        &combined_fee_opening,
-        &delta_opening,
-        &claimed_opening,
-        fee_amount,
-        delta_fee,
-        transfer_fee_maximum_fee,
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    // encrypt the fee amount under the destination and withdraw withheld authority
-    // ElGamal public key
-    let fee_destination_withdraw_withheld_authority_ciphertext_lo = GroupedElGamal::encrypt_with(
-        [
-            destination_elgamal_pubkey,
-            withdraw_withheld_authority_elgamal_pubkey,
-        ],
-        fee_amount_lo,
-        &fee_opening_lo,
-    );
-    let fee_destination_withdraw_withheld_authority_ciphertext_hi = GroupedElGamal::encrypt_with(
-        [
-            destination_elgamal_pubkey,
-            withdraw_withheld_authority_elgamal_pubkey,
-        ],
-        fee_amount_hi,
-        &fee_opening_hi,
-    );
-
-    // generate fee ciphertext validity data
-    let fee_ciphertext_validity_proof_data =
-        BatchedGroupedCiphertext2HandlesValidityProofData::new(
-            destination_elgamal_pubkey,
-            withdraw_withheld_authority_elgamal_pubkey,
-            &fee_destination_withdraw_withheld_authority_ciphertext_lo,
-            &fee_destination_withdraw_withheld_authority_ciphertext_hi,
-            fee_amount_lo,
-            fee_amount_hi,
-            &fee_opening_lo,
-            &fee_opening_hi,
-        )
-        .map_err(|_| TokenError::ProofGeneration)?;
-
-    // generate range proof data
-    const REMAINING_BALANCE_BIT_LENGTH: usize = 64;
-    const TRANSFER_AMOUNT_HI_BIT_LENGTH: usize = 32;
-    const DELTA_BIT_LENGTH: usize = 48;
-    const FEE_AMOUNT_HI_BIT_LENGTH: usize = 32;
-    const MAX_FEE_BASIS_POINTS: u64 = 10_000;
-
-    let delta_fee_complement = MAX_FEE_BASIS_POINTS - delta_fee;
-
-    let max_fee_basis_points_commitment =
-        Pedersen::with(MAX_FEE_BASIS_POINTS, &PedersenOpening::default());
-    let claimed_complement_commitment = max_fee_basis_points_commitment - claimed_commitment;
-    let claimed_complement_opening = PedersenOpening::default() - &claimed_opening;
-
-    let range_proof_data = BatchedRangeProofU256Data::new(
-        vec![
-            &new_available_balance_commitment,
-            transfer_amount_grouped_ciphertext_lo.get_commitment(),
-            transfer_amount_grouped_ciphertext_hi.get_commitment(),
-            &claimed_commitment,
-            &claimed_complement_commitment,
-            fee_ciphertext_lo.get_commitment(),
-            fee_ciphertext_hi.get_commitment(),
-        ],
-        vec![
-            new_decrypted_available_balance,
-            transfer_amount_lo,
-            transfer_amount_hi,
-            delta_fee,
-            delta_fee_complement,
-            fee_amount_lo,
-            fee_amount_hi,
-        ],
-        vec![
-            REMAINING_BALANCE_BIT_LENGTH,
-            TRANSFER_AMOUNT_LO_BIT_LENGTH,
-            TRANSFER_AMOUNT_HI_BIT_LENGTH,
-            DELTA_BIT_LENGTH,
-            DELTA_BIT_LENGTH,
-            FEE_AMOUNT_LO_BIT_LENGTH,
-            FEE_AMOUNT_HI_BIT_LENGTH,
-        ],
-        vec![
-            &new_source_opening,
-            &transfer_amount_opening_lo,
-            &transfer_amount_opening_hi,
-            &claimed_opening,
-            &claimed_complement_opening,
-            &fee_opening_lo,
-            &fee_opening_hi,
-        ],
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    Ok((
-        equality_proof_data,
-        transfer_amount_ciphertext_validity_proof_data,
-        fee_sigma_proof_data,
-        fee_ciphertext_validity_proof_data,
-        range_proof_data,
-        source_decrypt_handles,
-    ))
-}
-
-/// Calculate transfer fee and the "delta" value. The function returns the raw
-/// fee, which could be greater than the maximum fee amount of a fee parameter.
-///
-/// The "delta" value is a number that captures the round-off value when the fee
-/// is computed. The fee is computed according to the formula `fee =
-/// transfer_amount * fee_rate_basis_points / 10_000`. If no rounding occurred,
-/// then we must have `fee * 10_000 - transfer_amount * fee_rate_basis_points =
-/// 0`. If there is rounding involved (`10_000` does not divide cleanly),
-/// then the difference `fee * 10_000 - transfer_amount * fee_rate_basis_points`
-/// can be a non-zero number between `0` and `9_999` inclusively. We call this
-/// number the "delta" value.
-fn calculate_raw_fee_and_delta(
-    transfer_amount: u64,
-    fee_rate_basis_points: u16,
-) -> Option<(u64, u64)> {
-    const ONE_IN_BASIS_POINTS: u128 = 10_000_u128;
-
-    // compute `transfer_amount * fee_rate_basis_points`
-    let numerator = (transfer_amount as u128).checked_mul(fee_rate_basis_points as u128)?;
-
-    // compute fee as `transfer_amount * fee_rate_basis_points / 10_000 `
-    let fee = numerator
-        .checked_add(ONE_IN_BASIS_POINTS)?
-        .checked_sub(1)?
-        .checked_div(ONE_IN_BASIS_POINTS)?;
-
-    // compute the delta fee as `fee * 10_000 - fee_rate_basis_points`
-    let delta_fee = fee
-        .checked_mul(ONE_IN_BASIS_POINTS)?
-        .checked_sub(numerator)?;
-
-    Some((fee as u64, delta_fee as u64))
-}
-
-/// Calculate the "delta" commitment-opening pair from a transfer amount and fee
-/// commitment-opening pairs.
-fn compute_delta_commitment_and_opening(
-    (transfer_amount_commitment, transfer_amount_opening): (&PedersenCommitment, &PedersenOpening),
-    (fee_commitment, fee_opening): (&PedersenCommitment, &PedersenOpening),
-    fee_rate_basis_points: u16,
-) -> (PedersenCommitment, PedersenOpening) {
-    const ONE_IN_BASIS_POINTS: u128 = 10_000_u128;
-
-    let one_in_basis_points_scalar = Scalar::from(ONE_IN_BASIS_POINTS);
-    let fee_rate_scalar = Scalar::from(fee_rate_basis_points);
-
-    let delta_commitment =
-        fee_commitment * one_in_basis_points_scalar - transfer_amount_commitment * fee_rate_scalar;
-    let delta_opening =
-        fee_opening * one_in_basis_points_scalar - transfer_amount_opening * fee_rate_scalar;
-
-    (delta_commitment, delta_opening)
-}
diff --git a/token/client/src/token.rs b/token/client/src/token.rs
deleted file mode 100644
index a9fefc21f70..00000000000
--- a/token/client/src/token.rs
+++ /dev/null
@@ -1,4082 +0,0 @@
-use {
-    crate::{
-        client::{
-            ProgramClient, ProgramClientError, SendTransaction, SimulateTransaction,
-            SimulationResult,
-        },
-        proof_generation::transfer_with_fee_split_proof_data,
-    },
-    futures::{future::join_all, try_join},
-    futures_util::TryFutureExt,
-    solana_program_test::tokio::time,
-    solana_sdk::{
-        account::Account as BaseAccount,
-        compute_budget::ComputeBudgetInstruction,
-        hash::Hash,
-        instruction::{AccountMeta, Instruction},
-        message::Message,
-        program_error::ProgramError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signer::{signers::Signers, Signer, SignerError},
-        system_instruction,
-        transaction::Transaction,
-    },
-    spl_associated_token_account::{
-        get_associated_token_address_with_program_id,
-        instruction::{
-            create_associated_token_account, create_associated_token_account_idempotent,
-        },
-    },
-    spl_token_2022::{
-        extension::{
-            confidential_transfer::{
-                self,
-                account_info::{
-                    ApplyPendingBalanceAccountInfo, EmptyAccountAccountInfo, TransferAccountInfo,
-                    WithdrawAccountInfo,
-                },
-                ciphertext_extraction::SourceDecryptHandles,
-                instruction::{
-                    TransferSplitContextStateAccounts, TransferWithFeeSplitContextStateAccounts,
-                },
-                ConfidentialTransferAccount, DecryptableBalance,
-            },
-            confidential_transfer_fee::{
-                self, account_info::WithheldTokensInfo, ConfidentialTransferFeeAmount,
-                ConfidentialTransferFeeConfig,
-            },
-            cpi_guard, default_account_state, group_member_pointer, group_pointer,
-            interest_bearing_mint, memo_transfer, metadata_pointer, transfer_fee, transfer_hook,
-            BaseStateWithExtensions, Extension, ExtensionType, StateWithExtensionsOwned,
-        },
-        instruction, offchain,
-        proof::ProofLocation,
-        solana_zk_token_sdk::{
-            encryption::{
-                auth_encryption::AeKey,
-                elgamal::{ElGamalCiphertext, ElGamalKeypair, ElGamalPubkey, ElGamalSecretKey},
-            },
-            instruction::*,
-            zk_token_elgamal::pod::ElGamalPubkey as PodElGamalPubkey,
-            zk_token_proof_instruction::{self, ContextStateInfo, ProofInstruction},
-            zk_token_proof_program,
-            zk_token_proof_state::ProofContextState,
-        },
-        state::{Account, AccountState, Mint, Multisig},
-    },
-    spl_token_group_interface::state::{TokenGroup, TokenGroupMember},
-    spl_token_metadata_interface::state::{Field, TokenMetadata},
-    std::{
-        fmt, io,
-        mem::size_of,
-        sync::{Arc, RwLock},
-        time::{Duration, Instant},
-    },
-    thiserror::Error,
-};
-
-#[derive(Error, Debug)]
-pub enum TokenError {
-    #[error("client error: {0}")]
-    Client(ProgramClientError),
-    #[error("program error: {0}")]
-    Program(#[from] ProgramError),
-    #[error("account not found")]
-    AccountNotFound,
-    #[error("invalid account owner")]
-    AccountInvalidOwner,
-    #[error("invalid account mint")]
-    AccountInvalidMint,
-    #[error("invalid associated account address")]
-    AccountInvalidAssociatedAddress,
-    #[error("invalid auxiliary account address")]
-    AccountInvalidAuxiliaryAddress,
-    #[error("proof generation")]
-    ProofGeneration,
-    #[error("maximum deposit transfer amount exceeded")]
-    MaximumDepositTransferAmountExceeded,
-    #[error("encryption key error")]
-    Key(SignerError),
-    #[error("account decryption failed")]
-    AccountDecryption,
-    #[error("not enough funds in account")]
-    NotEnoughFunds,
-    #[error("missing memo signer")]
-    MissingMemoSigner,
-    #[error("decimals required, but missing")]
-    MissingDecimals,
-    #[error("decimals specified, but incorrect")]
-    InvalidDecimals,
-}
-impl PartialEq for TokenError {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            // TODO not great, but workable for tests
-            // currently missing: proof error, signer error
-            (Self::Client(ref a), Self::Client(ref b)) => a.to_string() == b.to_string(),
-            (Self::Program(ref a), Self::Program(ref b)) => a == b,
-            (Self::AccountNotFound, Self::AccountNotFound) => true,
-            (Self::AccountInvalidOwner, Self::AccountInvalidOwner) => true,
-            (Self::AccountInvalidMint, Self::AccountInvalidMint) => true,
-            (Self::AccountInvalidAssociatedAddress, Self::AccountInvalidAssociatedAddress) => true,
-            (Self::AccountInvalidAuxiliaryAddress, Self::AccountInvalidAuxiliaryAddress) => true,
-            (Self::ProofGeneration, Self::ProofGeneration) => true,
-            (
-                Self::MaximumDepositTransferAmountExceeded,
-                Self::MaximumDepositTransferAmountExceeded,
-            ) => true,
-            (Self::AccountDecryption, Self::AccountDecryption) => true,
-            (Self::NotEnoughFunds, Self::NotEnoughFunds) => true,
-            (Self::MissingMemoSigner, Self::MissingMemoSigner) => true,
-            (Self::MissingDecimals, Self::MissingDecimals) => true,
-            (Self::InvalidDecimals, Self::InvalidDecimals) => true,
-            _ => false,
-        }
-    }
-}
-
-/// Encapsulates initializing an extension
-#[derive(Clone, Debug, PartialEq)]
-pub enum ExtensionInitializationParams {
-    ConfidentialTransferMint {
-        authority: Option<Pubkey>,
-        auto_approve_new_accounts: bool,
-        auditor_elgamal_pubkey: Option<PodElGamalPubkey>,
-    },
-    DefaultAccountState {
-        state: AccountState,
-    },
-    MintCloseAuthority {
-        close_authority: Option<Pubkey>,
-    },
-    TransferFeeConfig {
-        transfer_fee_config_authority: Option<Pubkey>,
-        withdraw_withheld_authority: Option<Pubkey>,
-        transfer_fee_basis_points: u16,
-        maximum_fee: u64,
-    },
-    InterestBearingConfig {
-        rate_authority: Option<Pubkey>,
-        rate: i16,
-    },
-    NonTransferable,
-    PermanentDelegate {
-        delegate: Pubkey,
-    },
-    TransferHook {
-        authority: Option<Pubkey>,
-        program_id: Option<Pubkey>,
-    },
-    MetadataPointer {
-        authority: Option<Pubkey>,
-        metadata_address: Option<Pubkey>,
-    },
-    ConfidentialTransferFeeConfig {
-        authority: Option<Pubkey>,
-        withdraw_withheld_authority_elgamal_pubkey: PodElGamalPubkey,
-    },
-    GroupPointer {
-        authority: Option<Pubkey>,
-        group_address: Option<Pubkey>,
-    },
-    GroupMemberPointer {
-        authority: Option<Pubkey>,
-        member_address: Option<Pubkey>,
-    },
-}
-impl ExtensionInitializationParams {
-    /// Get the extension type associated with the init params
-    pub fn extension(&self) -> ExtensionType {
-        match self {
-            Self::ConfidentialTransferMint { .. } => ExtensionType::ConfidentialTransferMint,
-            Self::DefaultAccountState { .. } => ExtensionType::DefaultAccountState,
-            Self::MintCloseAuthority { .. } => ExtensionType::MintCloseAuthority,
-            Self::TransferFeeConfig { .. } => ExtensionType::TransferFeeConfig,
-            Self::InterestBearingConfig { .. } => ExtensionType::InterestBearingConfig,
-            Self::NonTransferable => ExtensionType::NonTransferable,
-            Self::PermanentDelegate { .. } => ExtensionType::PermanentDelegate,
-            Self::TransferHook { .. } => ExtensionType::TransferHook,
-            Self::MetadataPointer { .. } => ExtensionType::MetadataPointer,
-            Self::ConfidentialTransferFeeConfig { .. } => {
-                ExtensionType::ConfidentialTransferFeeConfig
-            }
-            Self::GroupPointer { .. } => ExtensionType::GroupPointer,
-            Self::GroupMemberPointer { .. } => ExtensionType::GroupMemberPointer,
-        }
-    }
-    /// Generate an appropriate initialization instruction for the given mint
-    pub fn instruction(
-        self,
-        token_program_id: &Pubkey,
-        mint: &Pubkey,
-    ) -> Result<Instruction, ProgramError> {
-        match self {
-            Self::ConfidentialTransferMint {
-                authority,
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey,
-            } => confidential_transfer::instruction::initialize_mint(
-                token_program_id,
-                mint,
-                authority,
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey,
-            ),
-            Self::DefaultAccountState { state } => {
-                default_account_state::instruction::initialize_default_account_state(
-                    token_program_id,
-                    mint,
-                    &state,
-                )
-            }
-            Self::MintCloseAuthority { close_authority } => {
-                instruction::initialize_mint_close_authority(
-                    token_program_id,
-                    mint,
-                    close_authority.as_ref(),
-                )
-            }
-            Self::TransferFeeConfig {
-                transfer_fee_config_authority,
-                withdraw_withheld_authority,
-                transfer_fee_basis_points,
-                maximum_fee,
-            } => transfer_fee::instruction::initialize_transfer_fee_config(
-                token_program_id,
-                mint,
-                transfer_fee_config_authority.as_ref(),
-                withdraw_withheld_authority.as_ref(),
-                transfer_fee_basis_points,
-                maximum_fee,
-            ),
-            Self::InterestBearingConfig {
-                rate_authority,
-                rate,
-            } => interest_bearing_mint::instruction::initialize(
-                token_program_id,
-                mint,
-                rate_authority,
-                rate,
-            ),
-            Self::NonTransferable => {
-                instruction::initialize_non_transferable_mint(token_program_id, mint)
-            }
-            Self::PermanentDelegate { delegate } => {
-                instruction::initialize_permanent_delegate(token_program_id, mint, &delegate)
-            }
-            Self::TransferHook {
-                authority,
-                program_id,
-            } => transfer_hook::instruction::initialize(
-                token_program_id,
-                mint,
-                authority,
-                program_id,
-            ),
-            Self::MetadataPointer {
-                authority,
-                metadata_address,
-            } => metadata_pointer::instruction::initialize(
-                token_program_id,
-                mint,
-                authority,
-                metadata_address,
-            ),
-            Self::ConfidentialTransferFeeConfig {
-                authority,
-                withdraw_withheld_authority_elgamal_pubkey,
-            } => {
-                confidential_transfer_fee::instruction::initialize_confidential_transfer_fee_config(
-                    token_program_id,
-                    mint,
-                    authority,
-                    withdraw_withheld_authority_elgamal_pubkey,
-                )
-            }
-            Self::GroupPointer {
-                authority,
-                group_address,
-            } => group_pointer::instruction::initialize(
-                token_program_id,
-                mint,
-                authority,
-                group_address,
-            ),
-            Self::GroupMemberPointer {
-                authority,
-                member_address,
-            } => group_member_pointer::instruction::initialize(
-                token_program_id,
-                mint,
-                authority,
-                member_address,
-            ),
-        }
-    }
-}
-
-pub type TokenResult<T> = Result<T, TokenError>;
-
-#[derive(Debug)]
-struct TokenMemo {
-    text: String,
-    signers: Vec<Pubkey>,
-}
-impl TokenMemo {
-    pub fn to_instruction(&self) -> Instruction {
-        spl_memo::build_memo(
-            self.text.as_bytes(),
-            &self.signers.iter().collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum ComputeUnitLimit {
-    Default,
-    Simulated,
-    Static(u32),
-}
-
-pub struct Token<T> {
-    client: Arc<dyn ProgramClient<T>>,
-    pubkey: Pubkey, /* token mint */
-    decimals: Option<u8>,
-    payer: Arc<dyn Signer>,
-    program_id: Pubkey,
-    nonce_account: Option<Pubkey>,
-    nonce_authority: Option<Arc<dyn Signer>>,
-    nonce_blockhash: Option<Hash>,
-    memo: Arc<RwLock<Option<TokenMemo>>>,
-    transfer_hook_accounts: Option<Vec<AccountMeta>>,
-    compute_unit_price: Option<u64>,
-    compute_unit_limit: ComputeUnitLimit,
-}
-
-impl<T> fmt::Debug for Token<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Token")
-            .field("pubkey", &self.pubkey)
-            .field("decimals", &self.decimals)
-            .field("payer", &self.payer.pubkey())
-            .field("program_id", &self.program_id)
-            .field("nonce_account", &self.nonce_account)
-            .field(
-                "nonce_authority",
-                &self.nonce_authority.as_ref().map(|s| s.pubkey()),
-            )
-            .field("nonce_blockhash", &self.nonce_blockhash)
-            .field("memo", &self.memo.read().unwrap())
-            .field("transfer_hook_accounts", &self.transfer_hook_accounts)
-            .field("compute_unit_price", &self.compute_unit_price)
-            .field("compute_unit_limit", &self.compute_unit_limit)
-            .finish()
-    }
-}
-
-fn native_mint(program_id: &Pubkey) -> Pubkey {
-    if program_id == &spl_token_2022::id() {
-        spl_token_2022::native_mint::id()
-    } else if program_id == &spl_token::id() {
-        spl_token::native_mint::id()
-    } else {
-        panic!("Unrecognized token program id: {}", program_id);
-    }
-}
-
-fn native_mint_decimals(program_id: &Pubkey) -> u8 {
-    if program_id == &spl_token_2022::id() {
-        spl_token_2022::native_mint::DECIMALS
-    } else if program_id == &spl_token::id() {
-        spl_token::native_mint::DECIMALS
-    } else {
-        panic!("Unrecognized token program id: {}", program_id);
-    }
-}
-
-impl<T> Token<T>
-where
-    T: SendTransaction + SimulateTransaction,
-{
-    pub fn new(
-        client: Arc<dyn ProgramClient<T>>,
-        program_id: &Pubkey,
-        address: &Pubkey,
-        decimals: Option<u8>,
-        payer: Arc<dyn Signer>,
-    ) -> Self {
-        Token {
-            client,
-            pubkey: *address,
-            decimals,
-            payer,
-            program_id: *program_id,
-            nonce_account: None,
-            nonce_authority: None,
-            nonce_blockhash: None,
-            memo: Arc::new(RwLock::new(None)),
-            transfer_hook_accounts: None,
-            compute_unit_price: None,
-            compute_unit_limit: ComputeUnitLimit::Default,
-        }
-    }
-
-    pub fn new_native(
-        client: Arc<dyn ProgramClient<T>>,
-        program_id: &Pubkey,
-        payer: Arc<dyn Signer>,
-    ) -> Self {
-        Self::new(
-            client,
-            program_id,
-            &native_mint(program_id),
-            Some(native_mint_decimals(program_id)),
-            payer,
-        )
-    }
-
-    pub fn is_native(&self) -> bool {
-        self.pubkey == native_mint(&self.program_id)
-    }
-
-    /// Get token address.
-    pub fn get_address(&self) -> &Pubkey {
-        &self.pubkey
-    }
-
-    pub fn with_payer(mut self, payer: Arc<dyn Signer>) -> Self {
-        self.payer = payer;
-        self
-    }
-
-    pub fn with_nonce(
-        mut self,
-        nonce_account: &Pubkey,
-        nonce_authority: Arc<dyn Signer>,
-        nonce_blockhash: &Hash,
-    ) -> Self {
-        self.nonce_account = Some(*nonce_account);
-        self.nonce_authority = Some(nonce_authority);
-        self.nonce_blockhash = Some(*nonce_blockhash);
-        self.transfer_hook_accounts = Some(vec![]);
-        self
-    }
-
-    pub fn with_transfer_hook_accounts(mut self, transfer_hook_accounts: Vec<AccountMeta>) -> Self {
-        self.transfer_hook_accounts = Some(transfer_hook_accounts);
-        self
-    }
-
-    pub fn with_compute_unit_price(mut self, compute_unit_price: u64) -> Self {
-        self.compute_unit_price = Some(compute_unit_price);
-        self
-    }
-
-    pub fn with_compute_unit_limit(mut self, compute_unit_limit: ComputeUnitLimit) -> Self {
-        self.compute_unit_limit = compute_unit_limit;
-        self
-    }
-
-    pub fn with_memo<M: AsRef<str>>(&self, memo: M, signers: Vec<Pubkey>) -> &Self {
-        let mut w_memo = self.memo.write().unwrap();
-        *w_memo = Some(TokenMemo {
-            text: memo.as_ref().to_string(),
-            signers,
-        });
-        self
-    }
-
-    pub async fn get_new_latest_blockhash(&self) -> TokenResult<Hash> {
-        let blockhash = self
-            .client
-            .get_latest_blockhash()
-            .await
-            .map_err(TokenError::Client)?;
-        let start = Instant::now();
-        let mut num_retries = 0;
-        while start.elapsed().as_secs() < 5 {
-            let new_blockhash = self
-                .client
-                .get_latest_blockhash()
-                .await
-                .map_err(TokenError::Client)?;
-            if new_blockhash != blockhash {
-                return Ok(new_blockhash);
-            }
-
-            time::sleep(Duration::from_millis(200)).await;
-            num_retries += 1;
-        }
-
-        Err(TokenError::Client(Box::new(io::Error::new(
-            io::ErrorKind::Other,
-            format!(
-                "Unable to get new blockhash after {}ms (retried {} times), stuck at {}",
-                start.elapsed().as_millis(),
-                num_retries,
-                blockhash
-            ),
-        ))))
-    }
-
-    fn get_multisig_signers<'a>(
-        &self,
-        authority: &Pubkey,
-        signing_pubkeys: &'a [Pubkey],
-    ) -> Vec<&'a Pubkey> {
-        if signing_pubkeys == [*authority] {
-            vec![]
-        } else {
-            signing_pubkeys.iter().collect::<Vec<_>>()
-        }
-    }
-
-    /// Helper function to add a compute unit limit instruction to a given set
-    /// of instructions
-    async fn add_compute_unit_limit_from_simulation(
-        &self,
-        instructions: &mut Vec<Instruction>,
-        blockhash: &Hash,
-    ) -> TokenResult<()> {
-        // add a max compute unit limit instruction for the simulation
-        const MAX_COMPUTE_UNIT_LIMIT: u32 = 1_400_000;
-        instructions.push(ComputeBudgetInstruction::set_compute_unit_limit(
-            MAX_COMPUTE_UNIT_LIMIT,
-        ));
-
-        let transaction = Transaction::new_unsigned(Message::new_with_blockhash(
-            instructions,
-            Some(&self.payer.pubkey()),
-            blockhash,
-        ));
-        let simulation_result = self
-            .client
-            .simulate_transaction(&transaction)
-            .await
-            .map_err(TokenError::Client)?;
-        let units_consumed = simulation_result
-            .get_compute_units_consumed()
-            .map_err(TokenError::Client)?;
-        // Overwrite the compute unit limit instruction with the actual units consumed
-        let compute_unit_limit =
-            u32::try_from(units_consumed).map_err(|x| TokenError::Client(x.into()))?;
-        instructions
-            .last_mut()
-            .expect("Compute budget instruction was added earlier")
-            .data = ComputeBudgetInstruction::set_compute_unit_limit(compute_unit_limit).data;
-        Ok(())
-    }
-
-    async fn construct_tx<S: Signers>(
-        &self,
-        token_instructions: &[Instruction],
-        signing_keypairs: &S,
-    ) -> TokenResult<Transaction> {
-        let mut instructions = vec![];
-        let payer_key = self.payer.pubkey();
-        let fee_payer = Some(&payer_key);
-
-        {
-            let mut w_memo = self.memo.write().unwrap();
-            if let Some(memo) = w_memo.take() {
-                let signing_pubkeys = signing_keypairs.pubkeys();
-                if !memo
-                    .signers
-                    .iter()
-                    .all(|signer| signing_pubkeys.contains(signer))
-                {
-                    return Err(TokenError::MissingMemoSigner);
-                }
-
-                instructions.push(memo.to_instruction());
-            }
-        }
-
-        instructions.extend_from_slice(token_instructions);
-
-        let blockhash = if let (Some(nonce_account), Some(nonce_authority), Some(nonce_blockhash)) = (
-            self.nonce_account,
-            &self.nonce_authority,
-            self.nonce_blockhash,
-        ) {
-            let nonce_instruction = system_instruction::advance_nonce_account(
-                &nonce_account,
-                &nonce_authority.pubkey(),
-            );
-            instructions.insert(0, nonce_instruction);
-            nonce_blockhash
-        } else {
-            self.client
-                .get_latest_blockhash()
-                .await
-                .map_err(TokenError::Client)?
-        };
-
-        if let Some(compute_unit_price) = self.compute_unit_price {
-            instructions.push(ComputeBudgetInstruction::set_compute_unit_price(
-                compute_unit_price,
-            ));
-        }
-
-        // The simulation to find out the compute unit usage must be run after
-        // all instructions have been added to the transaction, so be sure to
-        // keep this instruction as the last one before creating and sending the
-        // transaction.
-        match self.compute_unit_limit {
-            ComputeUnitLimit::Default => {}
-            ComputeUnitLimit::Simulated => {
-                self.add_compute_unit_limit_from_simulation(&mut instructions, &blockhash)
-                    .await?;
-            }
-            ComputeUnitLimit::Static(compute_unit_limit) => {
-                instructions.push(ComputeBudgetInstruction::set_compute_unit_limit(
-                    compute_unit_limit,
-                ));
-            }
-        }
-
-        let message = Message::new_with_blockhash(&instructions, fee_payer, &blockhash);
-        let mut transaction = Transaction::new_unsigned(message);
-        let signing_pubkeys = signing_keypairs.pubkeys();
-
-        if !signing_pubkeys.contains(&self.payer.pubkey()) {
-            transaction
-                .try_partial_sign(&vec![self.payer.clone()], blockhash)
-                .map_err(|error| TokenError::Client(error.into()))?;
-        }
-        if let Some(nonce_authority) = &self.nonce_authority {
-            let nonce_authority_pubkey = nonce_authority.pubkey();
-            if nonce_authority_pubkey != self.payer.pubkey()
-                && !signing_pubkeys.contains(&nonce_authority_pubkey)
-            {
-                transaction
-                    .try_partial_sign(&vec![nonce_authority.clone()], blockhash)
-                    .map_err(|error| TokenError::Client(error.into()))?;
-            }
-        }
-        transaction
-            .try_partial_sign(signing_keypairs, blockhash)
-            .map_err(|error| TokenError::Client(error.into()))?;
-
-        Ok(transaction)
-    }
-
-    pub async fn simulate_ixs<S: Signers>(
-        &self,
-        token_instructions: &[Instruction],
-        signing_keypairs: &S,
-    ) -> TokenResult<T::SimulationOutput> {
-        let transaction = self
-            .construct_tx(token_instructions, signing_keypairs)
-            .await?;
-
-        self.client
-            .simulate_transaction(&transaction)
-            .await
-            .map_err(TokenError::Client)
-    }
-
-    pub async fn process_ixs<S: Signers>(
-        &self,
-        token_instructions: &[Instruction],
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let transaction = self
-            .construct_tx(token_instructions, signing_keypairs)
-            .await?;
-
-        self.client
-            .send_transaction(&transaction)
-            .await
-            .map_err(TokenError::Client)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_mint<'a, S: Signers>(
-        &self,
-        mint_authority: &'a Pubkey,
-        freeze_authority: Option<&'a Pubkey>,
-        extension_initialization_params: Vec<ExtensionInitializationParams>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let decimals = self.decimals.ok_or(TokenError::MissingDecimals)?;
-
-        let extension_types = extension_initialization_params
-            .iter()
-            .map(|e| e.extension())
-            .collect::<Vec<_>>();
-        let space = ExtensionType::try_calculate_account_len::<Mint>(&extension_types)?;
-
-        let mut instructions = vec![system_instruction::create_account(
-            &self.payer.pubkey(),
-            &self.pubkey,
-            self.client
-                .get_minimum_balance_for_rent_exemption(space)
-                .await
-                .map_err(TokenError::Client)?,
-            space as u64,
-            &self.program_id,
-        )];
-
-        for params in extension_initialization_params {
-            instructions.push(params.instruction(&self.program_id, &self.pubkey)?);
-        }
-
-        instructions.push(instruction::initialize_mint(
-            &self.program_id,
-            &self.pubkey,
-            mint_authority,
-            freeze_authority,
-            decimals,
-        )?);
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Create native mint
-    pub async fn create_native_mint(
-        client: Arc<dyn ProgramClient<T>>,
-        program_id: &Pubkey,
-        payer: Arc<dyn Signer>,
-    ) -> TokenResult<Self> {
-        let token = Self::new_native(client, program_id, payer);
-        token
-            .process_ixs::<[&dyn Signer; 0]>(
-                &[instruction::create_native_mint(
-                    program_id,
-                    &token.payer.pubkey(),
-                )?],
-                &[],
-            )
-            .await?;
-
-        Ok(token)
-    }
-
-    /// Create multisig
-    pub async fn create_multisig(
-        &self,
-        account: &dyn Signer,
-        multisig_members: &[&Pubkey],
-        minimum_signers: u8,
-    ) -> TokenResult<T::Output> {
-        let instructions = vec![
-            system_instruction::create_account(
-                &self.payer.pubkey(),
-                &account.pubkey(),
-                self.client
-                    .get_minimum_balance_for_rent_exemption(Multisig::LEN)
-                    .await
-                    .map_err(TokenError::Client)?,
-                Multisig::LEN as u64,
-                &self.program_id,
-            ),
-            instruction::initialize_multisig(
-                &self.program_id,
-                &account.pubkey(),
-                multisig_members,
-                minimum_signers,
-            )?,
-        ];
-
-        self.process_ixs(&instructions, &[account]).await
-    }
-
-    /// Get the address for the associated token account.
-    pub fn get_associated_token_address(&self, owner: &Pubkey) -> Pubkey {
-        get_associated_token_address_with_program_id(owner, &self.pubkey, &self.program_id)
-    }
-
-    /// Create and initialize the associated account.
-    pub async fn create_associated_token_account(&self, owner: &Pubkey) -> TokenResult<T::Output> {
-        self.process_ixs::<[&dyn Signer; 0]>(
-            &[create_associated_token_account(
-                &self.payer.pubkey(),
-                owner,
-                &self.pubkey,
-                &self.program_id,
-            )],
-            &[],
-        )
-        .await
-    }
-
-    /// Create and initialize a new token account.
-    pub async fn create_auxiliary_token_account(
-        &self,
-        account: &dyn Signer,
-        owner: &Pubkey,
-    ) -> TokenResult<T::Output> {
-        self.create_auxiliary_token_account_with_extension_space(account, owner, vec![])
-            .await
-    }
-
-    /// Create and initialize a new token account.
-    pub async fn create_auxiliary_token_account_with_extension_space(
-        &self,
-        account: &dyn Signer,
-        owner: &Pubkey,
-        extensions: Vec<ExtensionType>,
-    ) -> TokenResult<T::Output> {
-        let state = self.get_mint_info().await?;
-        let mint_extensions: Vec<ExtensionType> = state.get_extension_types()?;
-        let mut required_extensions =
-            ExtensionType::get_required_init_account_extensions(&mint_extensions);
-        for extension_type in extensions.into_iter() {
-            if !required_extensions.contains(&extension_type) {
-                required_extensions.push(extension_type);
-            }
-        }
-        let space = ExtensionType::try_calculate_account_len::<Account>(&required_extensions)?;
-        let mut instructions = vec![system_instruction::create_account(
-            &self.payer.pubkey(),
-            &account.pubkey(),
-            self.client
-                .get_minimum_balance_for_rent_exemption(space)
-                .await
-                .map_err(TokenError::Client)?,
-            space as u64,
-            &self.program_id,
-        )];
-
-        if required_extensions.contains(&ExtensionType::ImmutableOwner) {
-            instructions.push(instruction::initialize_immutable_owner(
-                &self.program_id,
-                &account.pubkey(),
-            )?)
-        }
-
-        instructions.push(instruction::initialize_account(
-            &self.program_id,
-            &account.pubkey(),
-            &self.pubkey,
-            owner,
-        )?);
-
-        self.process_ixs(&instructions, &[account]).await
-    }
-
-    /// Retrieve a raw account
-    pub async fn get_account(&self, account: Pubkey) -> TokenResult<BaseAccount> {
-        self.client
-            .get_account(account)
-            .await
-            .map_err(TokenError::Client)?
-            .ok_or(TokenError::AccountNotFound)
-    }
-
-    fn unpack_mint_info(
-        &self,
-        account: BaseAccount,
-    ) -> TokenResult<StateWithExtensionsOwned<Mint>> {
-        if account.owner != self.program_id {
-            return Err(TokenError::AccountInvalidOwner);
-        }
-
-        let mint_result =
-            StateWithExtensionsOwned::<Mint>::unpack(account.data).map_err(Into::into);
-
-        if let (Ok(mint), Some(decimals)) = (&mint_result, self.decimals) {
-            if decimals != mint.base.decimals {
-                return Err(TokenError::InvalidDecimals);
-            }
-        }
-
-        mint_result
-    }
-
-    /// Retrive mint information.
-    pub async fn get_mint_info(&self) -> TokenResult<StateWithExtensionsOwned<Mint>> {
-        let account = self.get_account(self.pubkey).await?;
-        self.unpack_mint_info(account)
-    }
-
-    /// Retrieve account information.
-    pub async fn get_account_info(
-        &self,
-        account: &Pubkey,
-    ) -> TokenResult<StateWithExtensionsOwned<Account>> {
-        let account = self.get_account(*account).await?;
-        if account.owner != self.program_id {
-            return Err(TokenError::AccountInvalidOwner);
-        }
-        let account = StateWithExtensionsOwned::<Account>::unpack(account.data)?;
-        if account.base.mint != *self.get_address() {
-            return Err(TokenError::AccountInvalidMint);
-        }
-
-        Ok(account)
-    }
-
-    /// Retrieve the associated account or create one if not found.
-    pub async fn get_or_create_associated_account_info(
-        &self,
-        owner: &Pubkey,
-    ) -> TokenResult<StateWithExtensionsOwned<Account>> {
-        let account = self.get_associated_token_address(owner);
-        match self.get_account_info(&account).await {
-            Ok(account) => Ok(account),
-            // AccountInvalidOwner is possible if account already received some lamports.
-            Err(TokenError::AccountNotFound) | Err(TokenError::AccountInvalidOwner) => {
-                self.create_associated_token_account(owner).await?;
-                self.get_account_info(&account).await
-            }
-            Err(error) => Err(error),
-        }
-    }
-
-    /// Assign a new authority to the account.
-    pub async fn set_authority<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        new_authority: Option<&Pubkey>,
-        authority_type: instruction::AuthorityType,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[instruction::set_authority(
-                &self.program_id,
-                account,
-                new_authority,
-                authority_type,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Mint new tokens
-    pub async fn mint_to<S: Signers>(
-        &self,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let instructions = if let Some(decimals) = self.decimals {
-            [instruction::mint_to_checked(
-                &self.program_id,
-                &self.pubkey,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-                decimals,
-            )?]
-        } else {
-            [instruction::mint_to(
-                &self.program_id,
-                &self.pubkey,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-            )?]
-        };
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Transfer tokens to another account
-    #[allow(clippy::too_many_arguments)]
-    pub async fn transfer<S: Signers>(
-        &self,
-        source: &Pubkey,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let fetch_account_data_fn = |address| {
-            self.client
-                .get_account(address)
-                .map_ok(|opt| opt.map(|acc| acc.data))
-        };
-
-        let instruction = if let Some(decimals) = self.decimals {
-            if let Some(transfer_hook_accounts) = &self.transfer_hook_accounts {
-                let mut instruction = instruction::transfer_checked(
-                    &self.program_id,
-                    source,
-                    self.get_address(),
-                    destination,
-                    authority,
-                    &multisig_signers,
-                    amount,
-                    decimals,
-                )?;
-                instruction.accounts.extend(transfer_hook_accounts.clone());
-                instruction
-            } else {
-                offchain::create_transfer_checked_instruction_with_extra_metas(
-                    &self.program_id,
-                    source,
-                    self.get_address(),
-                    destination,
-                    authority,
-                    &multisig_signers,
-                    amount,
-                    decimals,
-                    fetch_account_data_fn,
-                )
-                .await
-                .map_err(|_| TokenError::AccountNotFound)?
-            }
-        } else {
-            #[allow(deprecated)]
-            instruction::transfer(
-                &self.program_id,
-                source,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-            )?
-        };
-
-        self.process_ixs(&[instruction], signing_keypairs).await
-    }
-
-    /// Transfer tokens to an associated account, creating it if it does not
-    /// exist
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_recipient_associated_account_and_transfer<S: Signers>(
-        &self,
-        source: &Pubkey,
-        destination: &Pubkey,
-        destination_owner: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        fee: Option<u64>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let fetch_account_data_fn = |address| {
-            self.client
-                .get_account(address)
-                .map_ok(|opt| opt.map(|acc| acc.data))
-        };
-
-        if *destination != self.get_associated_token_address(destination_owner) {
-            return Err(TokenError::AccountInvalidAssociatedAddress);
-        }
-
-        let mut instructions = vec![
-            (create_associated_token_account_idempotent(
-                &self.payer.pubkey(),
-                destination_owner,
-                &self.pubkey,
-                &self.program_id,
-            )),
-        ];
-
-        if let Some(fee) = fee {
-            let decimals = self.decimals.ok_or(TokenError::MissingDecimals)?;
-            instructions.push(transfer_fee::instruction::transfer_checked_with_fee(
-                &self.program_id,
-                source,
-                &self.pubkey,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-                decimals,
-                fee,
-            )?);
-        } else if let Some(decimals) = self.decimals {
-            instructions.push(
-                if let Some(transfer_hook_accounts) = &self.transfer_hook_accounts {
-                    let mut instruction = instruction::transfer_checked(
-                        &self.program_id,
-                        source,
-                        self.get_address(),
-                        destination,
-                        authority,
-                        &multisig_signers,
-                        amount,
-                        decimals,
-                    )?;
-                    instruction.accounts.extend(transfer_hook_accounts.clone());
-                    instruction
-                } else {
-                    offchain::create_transfer_checked_instruction_with_extra_metas(
-                        &self.program_id,
-                        source,
-                        self.get_address(),
-                        destination,
-                        authority,
-                        &multisig_signers,
-                        amount,
-                        decimals,
-                        fetch_account_data_fn,
-                    )
-                    .await
-                    .map_err(|_| TokenError::AccountNotFound)?
-                },
-            );
-        } else {
-            #[allow(deprecated)]
-            instructions.push(instruction::transfer(
-                &self.program_id,
-                source,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-            )?);
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Transfer tokens to another account, given an expected fee
-    #[allow(clippy::too_many_arguments)]
-    pub async fn transfer_with_fee<S: Signers>(
-        &self,
-        source: &Pubkey,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        fee: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-        let decimals = self.decimals.ok_or(TokenError::MissingDecimals)?;
-
-        self.process_ixs(
-            &[transfer_fee::instruction::transfer_checked_with_fee(
-                &self.program_id,
-                source,
-                &self.pubkey,
-                destination,
-                authority,
-                &multisig_signers,
-                amount,
-                decimals,
-                fee,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Burn tokens from account
-    pub async fn burn<S: Signers>(
-        &self,
-        source: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let instructions = if let Some(decimals) = self.decimals {
-            [instruction::burn_checked(
-                &self.program_id,
-                source,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-                amount,
-                decimals,
-            )?]
-        } else {
-            [instruction::burn(
-                &self.program_id,
-                source,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-                amount,
-            )?]
-        };
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Approve a delegate to spend tokens
-    pub async fn approve<S: Signers>(
-        &self,
-        source: &Pubkey,
-        delegate: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let instructions = if let Some(decimals) = self.decimals {
-            [instruction::approve_checked(
-                &self.program_id,
-                source,
-                &self.pubkey,
-                delegate,
-                authority,
-                &multisig_signers,
-                amount,
-                decimals,
-            )?]
-        } else {
-            [instruction::approve(
-                &self.program_id,
-                source,
-                delegate,
-                authority,
-                &multisig_signers,
-                amount,
-            )?]
-        };
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Revoke a delegate
-    pub async fn revoke<S: Signers>(
-        &self,
-        source: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[instruction::revoke(
-                &self.program_id,
-                source,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Close an empty account and reclaim its lamports
-    pub async fn close_account<S: Signers>(
-        &self,
-        account: &Pubkey,
-        lamports_destination: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let mut instructions = vec![instruction::close_account(
-            &self.program_id,
-            account,
-            lamports_destination,
-            authority,
-            &multisig_signers,
-        )?];
-
-        if let Ok(Some(destination_account)) = self.client.get_account(*lamports_destination).await
-        {
-            if let Ok(destination_obj) =
-                StateWithExtensionsOwned::<Account>::unpack(destination_account.data)
-            {
-                if destination_obj.base.is_native() {
-                    instructions.push(instruction::sync_native(
-                        &self.program_id,
-                        lamports_destination,
-                    )?);
-                }
-            }
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Close an account, reclaiming its lamports and tokens
-    pub async fn empty_and_close_account<S: Signers>(
-        &self,
-        account_to_close: &Pubkey,
-        lamports_destination: &Pubkey,
-        tokens_destination: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        // this implicitly validates that the mint on self is correct
-        let account_state = self.get_account_info(account_to_close).await?;
-
-        let mut instructions = vec![];
-
-        if !self.is_native() && account_state.base.amount > 0 {
-            // if a separate close authority is being used, it must be a delegate also
-            if let Some(decimals) = self.decimals {
-                instructions.push(instruction::transfer_checked(
-                    &self.program_id,
-                    account_to_close,
-                    &self.pubkey,
-                    tokens_destination,
-                    authority,
-                    &multisig_signers,
-                    account_state.base.amount,
-                    decimals,
-                )?);
-            } else {
-                #[allow(deprecated)]
-                instructions.push(instruction::transfer(
-                    &self.program_id,
-                    account_to_close,
-                    tokens_destination,
-                    authority,
-                    &multisig_signers,
-                    account_state.base.amount,
-                )?);
-            }
-        }
-
-        instructions.push(instruction::close_account(
-            &self.program_id,
-            account_to_close,
-            lamports_destination,
-            authority,
-            &multisig_signers,
-        )?);
-
-        if let Ok(Some(destination_account)) = self.client.get_account(*lamports_destination).await
-        {
-            if let Ok(destination_obj) =
-                StateWithExtensionsOwned::<Account>::unpack(destination_account.data)
-            {
-                if destination_obj.base.is_native() {
-                    instructions.push(instruction::sync_native(
-                        &self.program_id,
-                        lamports_destination,
-                    )?);
-                }
-            }
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Freeze a token account
-    pub async fn freeze<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[instruction::freeze_account(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Thaw / unfreeze a token account
-    pub async fn thaw<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[instruction::thaw_account(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Wrap lamports into native account
-    pub async fn wrap<S: Signers>(
-        &self,
-        account: &Pubkey,
-        owner: &Pubkey,
-        lamports: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        // mutable owner for Tokenkeg, immutable otherwise
-        let immutable_owner = self.program_id != spl_token::id();
-        let instructions = self.wrap_ixs(account, owner, lamports, immutable_owner)?;
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Wrap lamports into a native account that can always have its ownership
-    /// changed
-    pub async fn wrap_with_mutable_ownership<S: Signers>(
-        &self,
-        account: &Pubkey,
-        owner: &Pubkey,
-        lamports: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let instructions = self.wrap_ixs(account, owner, lamports, false)?;
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    fn wrap_ixs(
-        &self,
-        account: &Pubkey,
-        owner: &Pubkey,
-        lamports: u64,
-        immutable_owner: bool,
-    ) -> TokenResult<Vec<Instruction>> {
-        if !self.is_native() {
-            return Err(TokenError::AccountInvalidMint);
-        }
-
-        let mut instructions = vec![];
-        if *account == self.get_associated_token_address(owner) {
-            instructions.push(system_instruction::transfer(owner, account, lamports));
-            instructions.push(create_associated_token_account(
-                &self.payer.pubkey(),
-                owner,
-                &self.pubkey,
-                &self.program_id,
-            ));
-        } else {
-            let extensions = if immutable_owner {
-                vec![ExtensionType::ImmutableOwner]
-            } else {
-                vec![]
-            };
-            let space = ExtensionType::try_calculate_account_len::<Account>(&extensions)?;
-
-            instructions.push(system_instruction::create_account(
-                &self.payer.pubkey(),
-                account,
-                lamports,
-                space as u64,
-                &self.program_id,
-            ));
-
-            if immutable_owner {
-                instructions.push(instruction::initialize_immutable_owner(
-                    &self.program_id,
-                    account,
-                )?)
-            }
-
-            instructions.push(instruction::initialize_account(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                owner,
-            )?);
-        };
-
-        Ok(instructions)
-    }
-
-    /// Sync native account lamports
-    pub async fn sync_native(&self, account: &Pubkey) -> TokenResult<T::Output> {
-        self.process_ixs::<[&dyn Signer; 0]>(
-            &[instruction::sync_native(&self.program_id, account)?],
-            &[],
-        )
-        .await
-    }
-
-    /// Set transfer fee
-    pub async fn set_transfer_fee<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        transfer_fee_basis_points: u16,
-        maximum_fee: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[transfer_fee::instruction::set_transfer_fee(
-                &self.program_id,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-                transfer_fee_basis_points,
-                maximum_fee,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Set default account state on mint
-    pub async fn set_default_account_state<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        state: &AccountState,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                default_account_state::instruction::update_default_account_state(
-                    &self.program_id,
-                    &self.pubkey,
-                    authority,
-                    &multisig_signers,
-                    state,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Harvest withheld tokens to mint
-    pub async fn harvest_withheld_tokens_to_mint(
-        &self,
-        sources: &[&Pubkey],
-    ) -> TokenResult<T::Output> {
-        self.process_ixs::<[&dyn Signer; 0]>(
-            &[transfer_fee::instruction::harvest_withheld_tokens_to_mint(
-                &self.program_id,
-                &self.pubkey,
-                sources,
-            )?],
-            &[],
-        )
-        .await
-    }
-
-    /// Withdraw withheld tokens from mint
-    pub async fn withdraw_withheld_tokens_from_mint<S: Signers>(
-        &self,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                transfer_fee::instruction::withdraw_withheld_tokens_from_mint(
-                    &self.program_id,
-                    &self.pubkey,
-                    destination,
-                    authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Withdraw withheld tokens from accounts
-    pub async fn withdraw_withheld_tokens_from_accounts<S: Signers>(
-        &self,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        sources: &[&Pubkey],
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                transfer_fee::instruction::withdraw_withheld_tokens_from_accounts(
-                    &self.program_id,
-                    &self.pubkey,
-                    destination,
-                    authority,
-                    &multisig_signers,
-                    sources,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Reallocate a token account to be large enough for a set of
-    /// ExtensionTypes
-    pub async fn reallocate<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        extension_types: &[ExtensionType],
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[instruction::reallocate(
-                &self.program_id,
-                account,
-                &self.payer.pubkey(),
-                authority,
-                &multisig_signers,
-                extension_types,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Require memos on transfers into this account
-    pub async fn enable_required_transfer_memos<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[memo_transfer::instruction::enable_required_transfer_memos(
-                &self.program_id,
-                account,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Stop requiring memos on transfers into this account
-    pub async fn disable_required_transfer_memos<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[memo_transfer::instruction::disable_required_transfer_memos(
-                &self.program_id,
-                account,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Prevent unsafe usage of token account through CPI
-    pub async fn enable_cpi_guard<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[cpi_guard::instruction::enable_cpi_guard(
-                &self.program_id,
-                account,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Stop preventing unsafe usage of token account through CPI
-    pub async fn disable_cpi_guard<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[cpi_guard::instruction::disable_cpi_guard(
-                &self.program_id,
-                account,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update interest rate
-    pub async fn update_interest_rate<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        new_rate: i16,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[interest_bearing_mint::instruction::update_rate(
-                &self.program_id,
-                self.get_address(),
-                authority,
-                &multisig_signers,
-                new_rate,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update transfer hook program id
-    pub async fn update_transfer_hook_program_id<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        new_program_id: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[transfer_hook::instruction::update(
-                &self.program_id,
-                self.get_address(),
-                authority,
-                &multisig_signers,
-                new_program_id,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update metadata pointer address
-    pub async fn update_metadata_address<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        new_metadata_address: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[metadata_pointer::instruction::update(
-                &self.program_id,
-                self.get_address(),
-                authority,
-                &multisig_signers,
-                new_metadata_address,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update group pointer address
-    pub async fn update_group_address<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        new_group_address: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[group_pointer::instruction::update(
-                &self.program_id,
-                self.get_address(),
-                authority,
-                &multisig_signers,
-                new_group_address,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update group member pointer address
-    pub async fn update_group_member_address<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        new_member_address: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[group_member_pointer::instruction::update(
-                &self.program_id,
-                self.get_address(),
-                authority,
-                &multisig_signers,
-                new_member_address,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update confidential transfer mint
-    pub async fn confidential_transfer_update_mint<S: Signers>(
-        &self,
-        authority: &Pubkey,
-        auto_approve_new_account: bool,
-        auditor_elgamal_pubkey: Option<PodElGamalPubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[confidential_transfer::instruction::update_mint(
-                &self.program_id,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-                auto_approve_new_account,
-                auditor_elgamal_pubkey,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Configures confidential transfers for a token account. If the maximum
-    /// pending balance credit counter for the extension is not provided,
-    /// then it is set to be a default value of `2^16`.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_configure_token_account<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        maximum_pending_balance_credit_counter: Option<u64>,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        const DEFAULT_MAXIMUM_PENDING_BALANCE_CREDIT_COUNTER: u64 = 65536;
-
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let maximum_pending_balance_credit_counter = maximum_pending_balance_credit_counter
-            .unwrap_or(DEFAULT_MAXIMUM_PENDING_BALANCE_CREDIT_COUNTER);
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                confidential_transfer::instruction::PubkeyValidityData::new(elgamal_keypair)
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        let decryptable_balance = aes_key.encrypt(0);
-
-        self.process_ixs(
-            &confidential_transfer::instruction::configure_account(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                decryptable_balance,
-                maximum_pending_balance_credit_counter,
-                authority,
-                &multisig_signers,
-                proof_location,
-            )?,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Approves a token account for confidential transfers
-    pub async fn confidential_transfer_approve_account<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[confidential_transfer::instruction::approve_account(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Prepare a token account with the confidential transfer extension for
-    /// closing
-    pub async fn confidential_transfer_empty_account<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        account_info: Option<EmptyAccountAccountInfo>,
-        elgamal_keypair: &ElGamalKeypair,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            EmptyAccountAccountInfo::new(confidential_transfer_account)
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_proof_data(elgamal_keypair)
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        self.process_ixs(
-            &confidential_transfer::instruction::empty_account(
-                &self.program_id,
-                account,
-                authority,
-                &multisig_signers,
-                proof_location,
-            )?,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Deposit SPL Tokens into the pending balance of a confidential token
-    /// account
-    pub async fn confidential_transfer_deposit<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        amount: u64,
-        decimals: u8,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[confidential_transfer::instruction::deposit(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                amount,
-                decimals,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Withdraw SPL Tokens from the available balance of a confidential token
-    /// account
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_withdraw<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        withdraw_amount: u64,
-        decimals: u8,
-        account_info: Option<WithdrawAccountInfo>,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            WithdrawAccountInfo::new(confidential_transfer_account)
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_proof_data(withdraw_amount, elgamal_keypair, aes_key)
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(withdraw_amount, aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        self.process_ixs(
-            &confidential_transfer::instruction::withdraw(
-                &self.program_id,
-                account,
-                &self.pubkey,
-                withdraw_amount,
-                decimals,
-                new_decryptable_available_balance,
-                authority,
-                &multisig_signers,
-                proof_location,
-            )?,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create withdraw proof context state account for a confidential transfer
-    /// withdraw instruction.
-    pub async fn create_withdraw_proof_context_state<S: Signer>(
-        &self,
-        context_state_account: &Pubkey,
-        context_state_authority: &Pubkey,
-        withdraw_proof_data: &WithdrawData,
-        withdraw_proof_signer: &S,
-    ) -> TokenResult<T::Output> {
-        // create withdraw proof context state
-        let instruction_type = ProofInstruction::VerifyWithdraw;
-        let space = size_of::<ProofContextState<WithdrawProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-
-        let withdraw_proof_context_state_info = ContextStateInfo {
-            context_state_account,
-            context_state_authority,
-        };
-
-        self.process_ixs(
-            &[system_instruction::create_account(
-                &self.payer.pubkey(),
-                context_state_account,
-                rent,
-                space as u64,
-                &zk_token_proof_program::id(),
-            )],
-            &[withdraw_proof_signer],
-        )
-        .await?;
-
-        // This instruction is right at the transaction size limit, so we cannot
-        // add any other instructions to it
-        let blockhash = self
-            .client
-            .get_latest_blockhash()
-            .await
-            .map_err(TokenError::Client)?;
-
-        let transaction = Transaction::new_signed_with_payer(
-            &[instruction_type
-                .encode_verify_proof(Some(withdraw_proof_context_state_info), withdraw_proof_data)],
-            Some(&self.payer.pubkey()),
-            &[self.payer.as_ref()],
-            blockhash,
-        );
-
-        self.client
-            .send_transaction(&transaction)
-            .await
-            .map_err(TokenError::Client)
-    }
-
-    /// Transfer tokens confidentially
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer<S: Signers>(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_elgamal_keypair: &ElGamalKeypair,
-        source_aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(source_authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_transfer_proof_data(
-                        transfer_amount,
-                        source_elgamal_keypair,
-                        source_aes_key,
-                        destination_elgamal_pubkey,
-                        auditor_elgamal_pubkey,
-                    )
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut instructions = confidential_transfer::instruction::transfer(
-            &self.program_id,
-            source_account,
-            self.get_address(),
-            destination_account,
-            new_decryptable_available_balance,
-            source_authority,
-            &multisig_signers,
-            proof_location,
-        )?;
-        offchain::add_extra_account_metas(
-            &mut instructions[0],
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Transfer tokens confidentially using split proofs.
-    ///
-    /// This function assumes that proof context states have already been
-    /// created.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer_with_split_proofs<S: Signers>(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_aes_key: &AeKey,
-        source_decrypt_handles: &SourceDecryptHandles,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut instruction = confidential_transfer::instruction::transfer_with_split_proofs(
-            &self.program_id,
-            source_account,
-            self.get_address(),
-            destination_account,
-            new_decryptable_available_balance.into(),
-            source_authority,
-            context_state_accounts,
-            source_decrypt_handles,
-        )?;
-        offchain::add_extra_account_metas(
-            &mut instruction,
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-        self.process_ixs(&[instruction], signing_keypairs).await
-    }
-
-    /// Transfer tokens confidentially using split proofs in parallel
-    ///
-    /// This function internally generates the ZK Token proof instructions to
-    /// create the necessary proof context states.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer_with_split_proofs_in_parallel<S: Signers>(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_elgamal_keypair: &ElGamalKeypair,
-        source_aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        equality_and_ciphertext_validity_proof_signers: &S,
-        range_proof_signers: &S,
-    ) -> TokenResult<(T::Output, T::Output)> {
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let (
-            equality_proof_data,
-            ciphertext_validity_proof_data,
-            range_proof_data,
-            source_decrypt_handles,
-        ) = account_info
-            .generate_split_transfer_proof_data(
-                transfer_amount,
-                source_elgamal_keypair,
-                source_aes_key,
-                destination_elgamal_pubkey,
-                auditor_elgamal_pubkey,
-            )
-            .map_err(|_| TokenError::ProofGeneration)?;
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut transfer_instruction =
-            confidential_transfer::instruction::transfer_with_split_proofs(
-                &self.program_id,
-                source_account,
-                self.get_address(),
-                destination_account,
-                new_decryptable_available_balance.into(),
-                source_authority,
-                context_state_accounts,
-                &source_decrypt_handles,
-            )?;
-        offchain::add_extra_account_metas(
-            &mut transfer_instruction,
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-
-        let transfer_with_equality_and_ciphertext_validity = self
-            .create_equality_and_ciphertext_validity_proof_context_states_for_transfer_parallel(
-                context_state_accounts,
-                &equality_proof_data,
-                &ciphertext_validity_proof_data,
-                &transfer_instruction,
-                equality_and_ciphertext_validity_proof_signers,
-            );
-
-        let transfer_with_range_proof = self
-            .create_range_proof_context_state_for_transfer_parallel(
-                context_state_accounts,
-                &range_proof_data,
-                &transfer_instruction,
-                range_proof_signers,
-            );
-
-        try_join!(
-            transfer_with_equality_and_ciphertext_validity,
-            transfer_with_range_proof
-        )
-    }
-
-    /// Create equality proof context state account for a confidential transfer.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_equality_proof_context_state_for_transfer<S: Signer>(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        equality_proof_signer: &S,
-    ) -> TokenResult<T::Output> {
-        // create equality proof context state
-        let instruction_type = ProofInstruction::VerifyCiphertextCommitmentEquality;
-        let space = size_of::<ProofContextState<CiphertextCommitmentEqualityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-
-        let equality_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.equality_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-
-        self.process_ixs(
-            &[
-                system_instruction::create_account(
-                    &self.payer.pubkey(),
-                    context_state_accounts.equality_proof,
-                    rent,
-                    space as u64,
-                    &zk_token_proof_program::id(),
-                ),
-                instruction_type.encode_verify_proof(
-                    Some(equality_proof_context_state_info),
-                    equality_proof_data,
-                ),
-            ],
-            &[equality_proof_signer],
-        )
-        .await
-    }
-
-    /// Create ciphertext validity proof context state account for a
-    /// confidential transfer.
-    pub async fn create_ciphertext_validity_proof_context_state_for_transfer<S: Signer>(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        ciphertext_validity_proof_signer: &S,
-    ) -> TokenResult<T::Output> {
-        // create ciphertext validity proof context state
-        let instruction_type = ProofInstruction::VerifyBatchedGroupedCiphertext2HandlesValidity;
-        let space =
-            size_of::<ProofContextState<BatchedGroupedCiphertext2HandlesValidityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-
-        let ciphertext_validity_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.ciphertext_validity_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-
-        self.process_ixs(
-            &[
-                system_instruction::create_account(
-                    &self.payer.pubkey(),
-                    context_state_accounts.ciphertext_validity_proof,
-                    rent,
-                    space as u64,
-                    &zk_token_proof_program::id(),
-                ),
-                instruction_type.encode_verify_proof(
-                    Some(ciphertext_validity_proof_context_state_info),
-                    ciphertext_validity_proof_data,
-                ),
-            ],
-            &[ciphertext_validity_proof_signer],
-        )
-        .await
-    }
-
-    /// Create equality and ciphertext validity proof context state accounts for
-    /// a confidential transfer.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_equality_and_ciphertext_validity_proof_context_states_for_transfer<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_equality_and_ciphertext_validity_proof_context_state_with_optional_transfer(
-            context_state_accounts,
-            equality_proof_data,
-            ciphertext_validity_proof_data,
-            None,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create equality and ciphertext validity proof context state accounts
-    /// with a confidential transfer instruction.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_equality_and_ciphertext_validity_proof_context_states_for_transfer_parallel<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: &Instruction,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_equality_and_ciphertext_validity_proof_context_state_with_optional_transfer(
-            context_state_accounts,
-            equality_proof_data,
-            ciphertext_validity_proof_data,
-            Some(transfer_instruction),
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create equality and ciphertext validity proof context states for a
-    /// confidential transfer.
-    ///
-    /// If an optional transfer instruction is provided, then the transfer
-    /// instruction is attached to the same transaction.
-    #[allow(clippy::too_many_arguments)]
-    async fn create_equality_and_ciphertext_validity_proof_context_state_with_optional_transfer<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: Option<&Instruction>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let mut instructions = vec![];
-
-        // create equality proof context state
-        let instruction_type = ProofInstruction::VerifyCiphertextCommitmentEquality;
-        let space = size_of::<ProofContextState<CiphertextCommitmentEqualityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.equality_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let equality_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.equality_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(
-            instruction_type
-                .encode_verify_proof(Some(equality_proof_context_state_info), equality_proof_data),
-        );
-
-        // create ciphertext validity proof context state
-        let instruction_type = ProofInstruction::VerifyBatchedGroupedCiphertext2HandlesValidity;
-        let space =
-            size_of::<ProofContextState<BatchedGroupedCiphertext2HandlesValidityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.ciphertext_validity_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let ciphertext_validity_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.ciphertext_validity_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(instruction_type.encode_verify_proof(
-            Some(ciphertext_validity_proof_context_state_info),
-            ciphertext_validity_proof_data,
-        ));
-
-        // add transfer instruction
-        if let Some(transfer_instruction) = transfer_instruction {
-            instructions.push(transfer_instruction.clone());
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Create a range proof context state account for a confidential transfer.
-    pub async fn create_range_proof_context_state_for_transfer<S: Signer>(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU128Data,
-        range_proof_keypair: &S,
-    ) -> TokenResult<T::Output> {
-        let instruction_type = ProofInstruction::VerifyBatchedRangeProofU128;
-        let space = size_of::<ProofContextState<BatchedRangeProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        let range_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.range_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        self.process_ixs(
-            &[system_instruction::create_account(
-                &self.payer.pubkey(),
-                context_state_accounts.range_proof,
-                rent,
-                space as u64,
-                &zk_token_proof_program::id(),
-            )],
-            &[range_proof_keypair],
-        )
-        .await?;
-
-        // This instruction is right at the transaction size limit, but in the
-        // future it might be able to support the transfer too
-        let blockhash = self
-            .client
-            .get_latest_blockhash()
-            .await
-            .map_err(TokenError::Client)?;
-
-        let transaction = Transaction::new_signed_with_payer(
-            &[instruction_type
-                .encode_verify_proof(Some(range_proof_context_state_info), range_proof_data)],
-            Some(&self.payer.pubkey()),
-            &[self.payer.as_ref()],
-            blockhash,
-        );
-
-        self.client
-            .send_transaction(&transaction)
-            .await
-            .map_err(TokenError::Client)
-    }
-
-    /// Create a range proof context state account with a confidential transfer
-    /// instruction.
-    pub async fn create_range_proof_context_state_for_transfer_parallel<S: Signers>(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU128Data,
-        transfer_instruction: &Instruction,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_range_proof_context_state_with_optional_transfer(
-            context_state_accounts,
-            range_proof_data,
-            Some(transfer_instruction),
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create a range proof context state account and an optional confidential
-    /// transfer instruction.
-    async fn create_range_proof_context_state_with_optional_transfer<S: Signers>(
-        &self,
-        context_state_accounts: TransferSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU128Data,
-        transfer_instruction: Option<&Instruction>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let instruction_type = ProofInstruction::VerifyBatchedRangeProofU128;
-        let space = size_of::<ProofContextState<BatchedRangeProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        let range_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.range_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-
-        let mut instructions = vec![
-            system_instruction::create_account(
-                &self.payer.pubkey(),
-                context_state_accounts.range_proof,
-                rent,
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type
-                .encode_verify_proof(Some(range_proof_context_state_info), range_proof_data),
-        ];
-
-        if let Some(transfer_instruction) = transfer_instruction {
-            instructions.push(transfer_instruction.clone());
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Close a ZK Token proof program context state
-    pub async fn confidential_transfer_close_context_state<S: Signers>(
-        &self,
-        context_state_account: &Pubkey,
-        lamport_destination_account: &Pubkey,
-        context_state_authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let context_state_info = ContextStateInfo {
-            context_state_account,
-            context_state_authority,
-        };
-
-        self.process_ixs(
-            &[zk_token_proof_instruction::close_context_state(
-                context_state_info,
-                lamport_destination_account,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Transfer tokens confidentially with fee
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer_with_fee<S: Signers>(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_elgamal_keypair: &ElGamalKeypair,
-        source_aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-        fee_rate_basis_points: u16,
-        maximum_fee: u64,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(source_authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_transfer_with_fee_proof_data(
-                        transfer_amount,
-                        source_elgamal_keypair,
-                        source_aes_key,
-                        destination_elgamal_pubkey,
-                        auditor_elgamal_pubkey,
-                        withdraw_withheld_authority_elgamal_pubkey,
-                        fee_rate_basis_points,
-                        maximum_fee,
-                    )
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut instructions = confidential_transfer::instruction::transfer_with_fee(
-            &self.program_id,
-            source_account,
-            destination_account,
-            self.get_address(),
-            new_decryptable_available_balance,
-            source_authority,
-            &multisig_signers,
-            proof_location,
-        )?;
-        offchain::add_extra_account_metas(
-            &mut instructions[0],
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Transfer tokens confidentially with fee using split proofs.
-    ///
-    /// This function assumes that proof context states have already been
-    /// created.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer_with_fee_and_split_proofs<S: Signers>(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_aes_key: &AeKey,
-        source_decrypt_handles: &SourceDecryptHandles,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut instruction =
-            confidential_transfer::instruction::transfer_with_fee_and_split_proofs(
-                &self.program_id,
-                source_account,
-                self.get_address(),
-                destination_account,
-                new_decryptable_available_balance.into(),
-                source_authority,
-                context_state_accounts,
-                source_decrypt_handles,
-            )?;
-        offchain::add_extra_account_metas(
-            &mut instruction,
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-        self.process_ixs(&[instruction], signing_keypairs).await
-    }
-
-    /// Transfer tokens confidentially using split proofs in parallel
-    ///
-    /// This function internally generates the ZK Token proof instructions to
-    /// create the necessary proof context states.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_transfer_with_fee_and_split_proofs_in_parallel<
-        S: Signers,
-    >(
-        &self,
-        source_account: &Pubkey,
-        destination_account: &Pubkey,
-        source_authority: &Pubkey,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        transfer_amount: u64,
-        account_info: Option<TransferAccountInfo>,
-        source_elgamal_keypair: &ElGamalKeypair,
-        source_aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-        fee_rate_basis_points: u16,
-        maximum_fee: u64,
-        equality_and_ciphertext_validity_proof_signers: &S,
-        fee_sigma_proof_signers: &S,
-        range_proof_signers: &S,
-    ) -> TokenResult<(T::Output, T::Output, T::Output)> {
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(source_account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            TransferAccountInfo::new(confidential_transfer_account)
-        };
-
-        let current_source_available_balance = account_info
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::AccountDecryption)?;
-        let current_decryptable_available_balance = account_info
-            .decryptable_available_balance
-            .try_into()
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let fee_parameters = FeeParameters {
-            fee_rate_basis_points,
-            maximum_fee,
-        };
-
-        let (
-            equality_proof_data,
-            transfer_amount_ciphertext_validity_proof_data,
-            fee_sigma_proof_data,
-            fee_ciphertext_validity_proof_data,
-            range_proof_data,
-            source_decrypt_handles,
-        ) = transfer_with_fee_split_proof_data(
-            &current_source_available_balance,
-            &current_decryptable_available_balance,
-            transfer_amount,
-            source_elgamal_keypair,
-            source_aes_key,
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-            withdraw_withheld_authority_elgamal_pubkey,
-            &fee_parameters,
-        )
-        .map_err(|_| TokenError::ProofGeneration)?;
-
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(transfer_amount, source_aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let mut transfer_instruction =
-            confidential_transfer::instruction::transfer_with_fee_and_split_proofs(
-                &self.program_id,
-                source_account,
-                self.get_address(),
-                destination_account,
-                new_decryptable_available_balance.into(),
-                source_authority,
-                context_state_accounts,
-                &source_decrypt_handles,
-            )?;
-        offchain::add_extra_account_metas(
-            &mut transfer_instruction,
-            source_account,
-            self.get_address(),
-            destination_account,
-            source_authority,
-            u64::MAX,
-            |address| {
-                self.client
-                    .get_account(address)
-                    .map_ok(|opt| opt.map(|acc| acc.data))
-            },
-        )
-        .await
-        .map_err(|_| TokenError::AccountNotFound)?;
-
-        let transfer_with_equality_and_ciphertext_valdity = self
-            .create_equality_and_ciphertext_validity_proof_context_states_for_transfer_with_fee_parallel(
-                context_state_accounts,
-                &equality_proof_data,
-                &transfer_amount_ciphertext_validity_proof_data,
-                &transfer_instruction,
-                equality_and_ciphertext_validity_proof_signers
-            );
-
-        let transfer_with_fee_sigma_and_ciphertext_validity = self
-            .create_fee_sigma_and_ciphertext_validity_proof_context_states_for_transfer_with_fee_parallel(
-                context_state_accounts,
-                &fee_sigma_proof_data,
-                &fee_ciphertext_validity_proof_data,
-                &transfer_instruction,
-                fee_sigma_proof_signers,
-            );
-
-        let transfer_with_range_proof = self
-            .create_range_proof_context_state_for_transfer_with_fee_parallel(
-                context_state_accounts,
-                &range_proof_data,
-                &transfer_instruction,
-                range_proof_signers,
-            );
-
-        try_join!(
-            transfer_with_equality_and_ciphertext_valdity,
-            transfer_with_fee_sigma_and_ciphertext_validity,
-            transfer_with_range_proof,
-        )
-    }
-
-    /// Create equality and transfer amount ciphertext validity proof context
-    /// state accounts for a confidential transfer with fee.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_equality_and_ciphertext_validity_proof_context_states_for_transfer_with_fee<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_equality_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee(
-            context_state_accounts,
-            equality_proof_data,
-            ciphertext_validity_proof_data,
-            None,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create equality and transfer amount ciphertext validity proof context
-    /// state accounts with a confidential transfer instruction.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_equality_and_ciphertext_validity_proof_context_states_for_transfer_with_fee_parallel<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: &Instruction,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_equality_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee(
-            context_state_accounts,
-            equality_proof_data,
-            ciphertext_validity_proof_data,
-            Some(transfer_instruction),
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create equality and ciphertext validity proof context states for a
-    /// confidential transfer with fee.
-    ///
-    /// If an optional transfer instruction is provided, then the transfer
-    /// instruction is attached to the same transaction.
-    #[allow(clippy::too_many_arguments)]
-    async fn create_equality_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        equality_proof_data: &CiphertextCommitmentEqualityProofData,
-        transfer_amount_ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: Option<&Instruction>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let mut instructions = vec![];
-
-        // create equality proof context state
-        let instruction_type = ProofInstruction::VerifyCiphertextCommitmentEquality;
-        let space = size_of::<ProofContextState<CiphertextCommitmentEqualityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.equality_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let equality_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.equality_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(
-            instruction_type
-                .encode_verify_proof(Some(equality_proof_context_state_info), equality_proof_data),
-        );
-
-        // create transfer amount ciphertext validity proof context state
-        let instruction_type = ProofInstruction::VerifyBatchedGroupedCiphertext2HandlesValidity;
-        let space =
-            size_of::<ProofContextState<BatchedGroupedCiphertext2HandlesValidityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.transfer_amount_ciphertext_validity_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let transfer_amount_ciphertext_validity_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.transfer_amount_ciphertext_validity_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(instruction_type.encode_verify_proof(
-            Some(transfer_amount_ciphertext_validity_proof_context_state_info),
-            transfer_amount_ciphertext_validity_proof_data,
-        ));
-
-        // add transfer instruction
-        if let Some(transfer_instruction) = transfer_instruction {
-            instructions.push(transfer_instruction.clone());
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Create fee sigma and fee ciphertext validity proof context state
-    /// accounts for a confidential transfer with fee.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_fee_sigma_and_ciphertext_validity_proof_context_states_for_transfer_with_fee<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        fee_sigma_proof_data: &FeeSigmaProofData,
-        fee_ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_fee_sigma_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee(
-            context_state_accounts,
-            fee_sigma_proof_data,
-            fee_ciphertext_validity_proof_data,
-            None,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create fee sigma and fee ciphertext validity proof context state
-    /// accounts with a confidential transfer with fee.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_fee_sigma_and_ciphertext_validity_proof_context_states_for_transfer_with_fee_parallel<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        fee_sigma_proof_data: &FeeSigmaProofData,
-        fee_ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: &Instruction,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_fee_sigma_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee(
-            context_state_accounts,
-            fee_sigma_proof_data,
-            fee_ciphertext_validity_proof_data,
-            Some(transfer_instruction),
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create fee sigma and fee ciphertext validity proof context states for a
-    /// confidential transfer with fee.
-    ///
-    /// If an optional transfer instruction is provided, then the transfer
-    /// instruction is attached to the same transaction.
-    #[allow(clippy::too_many_arguments)]
-    async fn create_fee_sigma_and_ciphertext_validity_proof_context_states_with_optional_transfer_with_fee<
-        S: Signers,
-    >(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        fee_sigma_proof_data: &FeeSigmaProofData,
-        fee_ciphertext_validity_proof_data: &BatchedGroupedCiphertext2HandlesValidityProofData,
-        transfer_instruction: Option<&Instruction>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let mut instructions = vec![];
-
-        // create fee sigma proof context state
-        let instruction_type = ProofInstruction::VerifyFeeSigma;
-        let space = size_of::<ProofContextState<FeeSigmaProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.fee_sigma_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let fee_sigma_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.fee_sigma_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(instruction_type.encode_verify_proof(
-            Some(fee_sigma_proof_context_state_info),
-            fee_sigma_proof_data,
-        ));
-
-        // create fee ciphertext validity proof context state
-        let instruction_type = ProofInstruction::VerifyBatchedGroupedCiphertext2HandlesValidity;
-        let space =
-            size_of::<ProofContextState<BatchedGroupedCiphertext2HandlesValidityProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        instructions.push(system_instruction::create_account(
-            &self.payer.pubkey(),
-            context_state_accounts.fee_ciphertext_validity_proof,
-            rent,
-            space as u64,
-            &zk_token_proof_program::id(),
-        ));
-
-        let fee_ciphertext_validity_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.fee_ciphertext_validity_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-        instructions.push(instruction_type.encode_verify_proof(
-            Some(fee_ciphertext_validity_proof_context_state_info),
-            fee_ciphertext_validity_proof_data,
-        ));
-
-        // add transfer instruction
-        if let Some(transfer_instruction) = transfer_instruction {
-            instructions.push(transfer_instruction.clone());
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Create range proof context state account for a confidential transfer
-    /// with fee.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_range_proof_context_state_for_transfer_with_fee<S: Signers>(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU256Data,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_range_proof_context_state_with_optional_transfer_with_fee(
-            context_state_accounts,
-            range_proof_data,
-            None,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create range proof context state account for a confidential transfer
-    /// with fee.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn create_range_proof_context_state_for_transfer_with_fee_parallel<S: Signers>(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU256Data,
-        transfer_instruction: &Instruction,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.create_range_proof_context_state_with_optional_transfer_with_fee(
-            context_state_accounts,
-            range_proof_data,
-            Some(transfer_instruction),
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Create a range proof context state account and an optional confidential
-    /// transfer instruction.
-    async fn create_range_proof_context_state_with_optional_transfer_with_fee<S: Signers>(
-        &self,
-        context_state_accounts: TransferWithFeeSplitContextStateAccounts<'_>,
-        range_proof_data: &BatchedRangeProofU256Data,
-        transfer_instruction: Option<&Instruction>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let instruction_type = ProofInstruction::VerifyBatchedRangeProofU256;
-        let space = size_of::<ProofContextState<BatchedRangeProofContext>>();
-        let rent = self
-            .client
-            .get_minimum_balance_for_rent_exemption(space)
-            .await
-            .map_err(TokenError::Client)?;
-        let range_proof_context_state_info = ContextStateInfo {
-            context_state_account: context_state_accounts.range_proof,
-            context_state_authority: context_state_accounts.authority,
-        };
-
-        let mut instructions = vec![
-            system_instruction::create_account(
-                &self.payer.pubkey(),
-                context_state_accounts.range_proof,
-                rent,
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type
-                .encode_verify_proof(Some(range_proof_context_state_info), range_proof_data),
-        ];
-
-        if let Some(transfer_instruction) = transfer_instruction {
-            instructions.push(transfer_instruction.clone());
-        }
-
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Applies the confidential transfer pending balance to the available
-    /// balance
-    pub async fn confidential_transfer_apply_pending_balance<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        account_info: Option<ApplyPendingBalanceAccountInfo>,
-        elgamal_secret_key: &ElGamalSecretKey,
-        aes_key: &AeKey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = account_info {
-            account_info
-        } else {
-            let account = self.get_account_info(account).await?;
-            let confidential_transfer_account =
-                account.get_extension::<ConfidentialTransferAccount>()?;
-            ApplyPendingBalanceAccountInfo::new(confidential_transfer_account)
-        };
-
-        let expected_pending_balance_credit_counter = account_info.pending_balance_credit_counter();
-        let new_decryptable_available_balance = account_info
-            .new_decryptable_available_balance(elgamal_secret_key, aes_key)
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        self.process_ixs(
-            &[confidential_transfer::instruction::apply_pending_balance(
-                &self.program_id,
-                account,
-                expected_pending_balance_credit_counter,
-                new_decryptable_available_balance,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Enable confidential transfer `Deposit` and `Transfer` instructions for a
-    /// token account
-    pub async fn confidential_transfer_enable_confidential_credits<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer::instruction::enable_confidential_credits(
-                    &self.program_id,
-                    account,
-                    authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Disable confidential transfer `Deposit` and `Transfer` instructions for
-    /// a token account
-    pub async fn confidential_transfer_disable_confidential_credits<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer::instruction::disable_confidential_credits(
-                    &self.program_id,
-                    account,
-                    authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Enable a confidential extension token account to receive
-    /// non-confidential payments
-    pub async fn confidential_transfer_enable_non_confidential_credits<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer::instruction::enable_non_confidential_credits(
-                    &self.program_id,
-                    account,
-                    authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Disable non-confidential payments for a confidential extension token
-    /// account
-    pub async fn confidential_transfer_disable_non_confidential_credits<S: Signers>(
-        &self,
-        account: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer::instruction::disable_non_confidential_credits(
-                    &self.program_id,
-                    account,
-                    authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Withdraw withheld confidential tokens from mint
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_withdraw_withheld_tokens_from_mint<S: Signers>(
-        &self,
-        destination_account: &Pubkey,
-        withdraw_withheld_authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        withheld_tokens_info: Option<WithheldTokensInfo>,
-        withdraw_withheld_authority_elgamal_keypair: &ElGamalKeypair,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        new_decryptable_available_balance: &DecryptableBalance,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers =
-            self.get_multisig_signers(withdraw_withheld_authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = withheld_tokens_info {
-            account_info
-        } else {
-            let mint_info = self.get_mint_info().await?;
-            let confidential_transfer_fee_config =
-                mint_info.get_extension::<ConfidentialTransferFeeConfig>()?;
-            WithheldTokensInfo::new(&confidential_transfer_fee_config.withheld_amount)
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_proof_data(
-                        withdraw_withheld_authority_elgamal_keypair,
-                        destination_elgamal_pubkey,
-                    )
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        self.process_ixs(
-            &confidential_transfer_fee::instruction::withdraw_withheld_tokens_from_mint(
-                &self.program_id,
-                &self.pubkey,
-                destination_account,
-                new_decryptable_available_balance,
-                withdraw_withheld_authority,
-                &multisig_signers,
-                proof_location,
-            )?,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Withdraw withheld confidential tokens from accounts
-    #[allow(clippy::too_many_arguments)]
-    pub async fn confidential_transfer_withdraw_withheld_tokens_from_accounts<S: Signers>(
-        &self,
-        destination_account: &Pubkey,
-        withdraw_withheld_authority: &Pubkey,
-        context_state_account: Option<&Pubkey>,
-        withheld_tokens_info: Option<WithheldTokensInfo>,
-        withdraw_withheld_authority_elgamal_keypair: &ElGamalKeypair,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        new_decryptable_available_balance: &DecryptableBalance,
-        sources: &[&Pubkey],
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers =
-            self.get_multisig_signers(withdraw_withheld_authority, &signing_pubkeys);
-
-        let account_info = if let Some(account_info) = withheld_tokens_info {
-            account_info
-        } else {
-            let futures = sources.iter().map(|source| self.get_account_info(source));
-            let sources_extensions = join_all(futures).await;
-
-            let mut aggregate_withheld_amount = ElGamalCiphertext::default();
-            for source_extension in sources_extensions {
-                let withheld_amount: ElGamalCiphertext = source_extension?
-                    .get_extension::<ConfidentialTransferFeeAmount>()?
-                    .withheld_amount
-                    .try_into()
-                    .map_err(|_| TokenError::AccountDecryption)?;
-                aggregate_withheld_amount = aggregate_withheld_amount + withheld_amount;
-            }
-
-            WithheldTokensInfo::new(&aggregate_withheld_amount.into())
-        };
-
-        let proof_data = if context_state_account.is_some() {
-            None
-        } else {
-            Some(
-                account_info
-                    .generate_proof_data(
-                        withdraw_withheld_authority_elgamal_keypair,
-                        destination_elgamal_pubkey,
-                    )
-                    .map_err(|_| TokenError::ProofGeneration)?,
-            )
-        };
-
-        let proof_location = if let Some(proof_data_temp) = proof_data.as_ref() {
-            ProofLocation::InstructionOffset(1.try_into().unwrap(), proof_data_temp)
-        } else {
-            let context_state_account = context_state_account.unwrap();
-            ProofLocation::ContextStateAccount(context_state_account)
-        };
-
-        self.process_ixs(
-            &confidential_transfer_fee::instruction::withdraw_withheld_tokens_from_accounts(
-                &self.program_id,
-                &self.pubkey,
-                destination_account,
-                new_decryptable_available_balance,
-                withdraw_withheld_authority,
-                &multisig_signers,
-                sources,
-                proof_location,
-            )?,
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Harvest withheld confidential tokens to mint
-    pub async fn confidential_transfer_harvest_withheld_tokens_to_mint(
-        &self,
-        sources: &[&Pubkey],
-    ) -> TokenResult<T::Output> {
-        self.process_ixs::<[&dyn Signer; 0]>(
-            &[
-                confidential_transfer_fee::instruction::harvest_withheld_tokens_to_mint(
-                    &self.program_id,
-                    &self.pubkey,
-                    sources,
-                )?,
-            ],
-            &[],
-        )
-        .await
-    }
-
-    /// Enable harvest of confidential fees to mint
-    pub async fn confidential_transfer_enable_harvest_to_mint<S: Signers>(
-        &self,
-        withdraw_withheld_authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers =
-            self.get_multisig_signers(withdraw_withheld_authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer_fee::instruction::enable_harvest_to_mint(
-                    &self.program_id,
-                    &self.pubkey,
-                    withdraw_withheld_authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Disable harvest of confidential fees to mint
-    pub async fn confidential_transfer_disable_harvest_to_mint<S: Signers>(
-        &self,
-        withdraw_withheld_authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers =
-            self.get_multisig_signers(withdraw_withheld_authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[
-                confidential_transfer_fee::instruction::disable_harvest_to_mint(
-                    &self.program_id,
-                    &self.pubkey,
-                    withdraw_withheld_authority,
-                    &multisig_signers,
-                )?,
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    pub async fn withdraw_excess_lamports<S: Signers>(
-        &self,
-        source: &Pubkey,
-        destination: &Pubkey,
-        authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let signing_pubkeys = signing_keypairs.pubkeys();
-        let multisig_signers = self.get_multisig_signers(authority, &signing_pubkeys);
-
-        self.process_ixs(
-            &[spl_token_2022::instruction::withdraw_excess_lamports(
-                &self.program_id,
-                source,
-                destination,
-                authority,
-                &multisig_signers,
-            )?],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Initialize token-metadata on a mint
-    pub async fn token_metadata_initialize<S: Signers>(
-        &self,
-        update_authority: &Pubkey,
-        mint_authority: &Pubkey,
-        name: String,
-        symbol: String,
-        uri: String,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_metadata_interface::instruction::initialize(
-                &self.program_id,
-                &self.pubkey,
-                update_authority,
-                &self.pubkey,
-                mint_authority,
-                name,
-                symbol,
-                uri,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    async fn get_additional_rent_for_new_metadata(
-        &self,
-        token_metadata: &TokenMetadata,
-    ) -> TokenResult<u64> {
-        let account = self.get_account(self.pubkey).await?;
-        let account_lamports = account.lamports;
-        let mint_state = self.unpack_mint_info(account)?;
-        let new_account_len = mint_state
-            .try_get_new_account_len_for_variable_len_extension::<TokenMetadata>(token_metadata)?;
-        let new_rent_exempt_minimum = self
-            .client
-            .get_minimum_balance_for_rent_exemption(new_account_len)
-            .await
-            .map_err(TokenError::Client)?;
-        Ok(new_rent_exempt_minimum.saturating_sub(account_lamports))
-    }
-
-    /// Initialize token-metadata on a mint
-    #[allow(clippy::too_many_arguments)]
-    pub async fn token_metadata_initialize_with_rent_transfer<S: Signers>(
-        &self,
-        payer: &Pubkey,
-        update_authority: &Pubkey,
-        mint_authority: &Pubkey,
-        name: String,
-        symbol: String,
-        uri: String,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let token_metadata = TokenMetadata {
-            name,
-            symbol,
-            uri,
-            ..Default::default()
-        };
-        let additional_lamports = self
-            .get_additional_rent_for_new_metadata(&token_metadata)
-            .await?;
-        let mut instructions = vec![];
-        if additional_lamports > 0 {
-            instructions.push(system_instruction::transfer(
-                payer,
-                &self.pubkey,
-                additional_lamports,
-            ));
-        }
-        instructions.push(spl_token_metadata_interface::instruction::initialize(
-            &self.program_id,
-            &self.pubkey,
-            update_authority,
-            &self.pubkey,
-            mint_authority,
-            token_metadata.name,
-            token_metadata.symbol,
-            token_metadata.uri,
-        ));
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Update a token-metadata field on a mint
-    pub async fn token_metadata_update_field<S: Signers>(
-        &self,
-        update_authority: &Pubkey,
-        field: Field,
-        value: String,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_metadata_interface::instruction::update_field(
-                &self.program_id,
-                &self.pubkey,
-                update_authority,
-                field,
-                value,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    async fn get_additional_rent_for_updated_metadata(
-        &self,
-        field: Field,
-        value: String,
-    ) -> TokenResult<u64> {
-        let account = self.get_account(self.pubkey).await?;
-        let account_lamports = account.lamports;
-        let mint_state = self.unpack_mint_info(account)?;
-        let mut token_metadata = mint_state.get_variable_len_extension::<TokenMetadata>()?;
-        token_metadata.update(field, value);
-        let new_account_len = mint_state
-            .try_get_new_account_len_for_variable_len_extension::<TokenMetadata>(&token_metadata)?;
-        let new_rent_exempt_minimum = self
-            .client
-            .get_minimum_balance_for_rent_exemption(new_account_len)
-            .await
-            .map_err(TokenError::Client)?;
-        Ok(new_rent_exempt_minimum.saturating_sub(account_lamports))
-    }
-
-    /// Update a token-metadata field on a mint. Includes a transfer for any
-    /// additional rent-exempt SOL required.
-    #[allow(clippy::too_many_arguments)]
-    pub async fn token_metadata_update_field_with_rent_transfer<S: Signers>(
-        &self,
-        payer: &Pubkey,
-        update_authority: &Pubkey,
-        field: Field,
-        value: String,
-        transfer_lamports: Option<u64>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let additional_lamports = if let Some(transfer_lamports) = transfer_lamports {
-            transfer_lamports
-        } else {
-            self.get_additional_rent_for_updated_metadata(field.clone(), value.clone())
-                .await?
-        };
-        let mut instructions = vec![];
-        if additional_lamports > 0 {
-            instructions.push(system_instruction::transfer(
-                payer,
-                &self.pubkey,
-                additional_lamports,
-            ));
-        }
-        instructions.push(spl_token_metadata_interface::instruction::update_field(
-            &self.program_id,
-            &self.pubkey,
-            update_authority,
-            field,
-            value,
-        ));
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Update the token-metadata authority in a mint
-    pub async fn token_metadata_update_authority<S: Signers>(
-        &self,
-        current_authority: &Pubkey,
-        new_authority: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_metadata_interface::instruction::update_authority(
-                &self.program_id,
-                &self.pubkey,
-                current_authority,
-                new_authority.try_into()?,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Remove a token-metadata field on a mint
-    pub async fn token_metadata_remove_key<S: Signers>(
-        &self,
-        update_authority: &Pubkey,
-        key: String,
-        idempotent: bool,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_metadata_interface::instruction::remove_key(
-                &self.program_id,
-                &self.pubkey,
-                update_authority,
-                key,
-                idempotent,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Initialize token-group on a mint
-    pub async fn token_group_initialize<S: Signers>(
-        &self,
-        mint_authority: &Pubkey,
-        update_authority: &Pubkey,
-        max_size: u32,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_group_interface::instruction::initialize_group(
-                &self.program_id,
-                &self.pubkey,
-                &self.pubkey,
-                mint_authority,
-                Some(*update_authority),
-                max_size,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    async fn get_additional_rent_for_fixed_len_extension<V: Extension + Pod>(
-        &self,
-    ) -> TokenResult<u64> {
-        let account = self.get_account(self.pubkey).await?;
-        let account_lamports = account.lamports;
-        let mint_state = self.unpack_mint_info(account)?;
-        if mint_state.get_extension::<V>().is_ok() {
-            Ok(0)
-        } else {
-            let new_account_len = mint_state.try_get_new_account_len::<V>()?;
-            let new_rent_exempt_minimum = self
-                .client
-                .get_minimum_balance_for_rent_exemption(new_account_len)
-                .await
-                .map_err(TokenError::Client)?;
-            Ok(new_rent_exempt_minimum.saturating_sub(account_lamports))
-        }
-    }
-
-    /// Initialize token-group on a mint
-    pub async fn token_group_initialize_with_rent_transfer<S: Signers>(
-        &self,
-        payer: &Pubkey,
-        mint_authority: &Pubkey,
-        update_authority: &Pubkey,
-        max_size: u32,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let additional_lamports = self
-            .get_additional_rent_for_fixed_len_extension::<TokenGroup>()
-            .await?;
-        let mut instructions = vec![];
-        if additional_lamports > 0 {
-            instructions.push(system_instruction::transfer(
-                payer,
-                &self.pubkey,
-                additional_lamports,
-            ));
-        }
-        instructions.push(spl_token_group_interface::instruction::initialize_group(
-            &self.program_id,
-            &self.pubkey,
-            &self.pubkey,
-            mint_authority,
-            Some(*update_authority),
-            max_size,
-        ));
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-
-    /// Update a token-group max size on a mint
-    pub async fn token_group_update_max_size<S: Signers>(
-        &self,
-        update_authority: &Pubkey,
-        new_max_size: u32,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[
-                spl_token_group_interface::instruction::update_group_max_size(
-                    &self.program_id,
-                    &self.pubkey,
-                    update_authority,
-                    new_max_size,
-                ),
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Update the token-group authority in a mint
-    pub async fn token_group_update_authority<S: Signers>(
-        &self,
-        current_authority: &Pubkey,
-        new_authority: Option<Pubkey>,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[
-                spl_token_group_interface::instruction::update_group_authority(
-                    &self.program_id,
-                    &self.pubkey,
-                    current_authority,
-                    new_authority,
-                ),
-            ],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Initialize a token-group member on a mint
-    pub async fn token_group_initialize_member<S: Signers>(
-        &self,
-        mint_authority: &Pubkey,
-        group_mint: &Pubkey,
-        group_update_authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        self.process_ixs(
-            &[spl_token_group_interface::instruction::initialize_member(
-                &self.program_id,
-                &self.pubkey,
-                &self.pubkey,
-                mint_authority,
-                group_mint,
-                group_update_authority,
-            )],
-            signing_keypairs,
-        )
-        .await
-    }
-
-    /// Initialize a token-group member on a mint
-    #[allow(clippy::too_many_arguments)]
-    pub async fn token_group_initialize_member_with_rent_transfer<S: Signers>(
-        &self,
-        payer: &Pubkey,
-        mint_authority: &Pubkey,
-        group_mint: &Pubkey,
-        group_update_authority: &Pubkey,
-        signing_keypairs: &S,
-    ) -> TokenResult<T::Output> {
-        let additional_lamports = self
-            .get_additional_rent_for_fixed_len_extension::<TokenGroupMember>()
-            .await?;
-        let mut instructions = vec![];
-        if additional_lamports > 0 {
-            instructions.push(system_instruction::transfer(
-                payer,
-                &self.pubkey,
-                additional_lamports,
-            ));
-        }
-        instructions.push(spl_token_group_interface::instruction::initialize_member(
-            &self.program_id,
-            &self.pubkey,
-            &self.pubkey,
-            mint_authority,
-            group_mint,
-            group_update_authority,
-        ));
-        self.process_ixs(&instructions, signing_keypairs).await
-    }
-}
diff --git a/token/client/tests/program-test.rs b/token/client/tests/program-test.rs
deleted file mode 100644
index f48ae2d9c27..00000000000
--- a/token/client/tests/program-test.rs
+++ /dev/null
@@ -1,311 +0,0 @@
-use {
-    solana_program_test::{
-        tokio::{self, sync::Mutex},
-        ProgramTest,
-    },
-    solana_sdk::{
-        program_option::COption,
-        signer::{keypair::Keypair, Signer},
-    },
-    spl_token_2022::{instruction, state},
-    spl_token_client::{
-        client::{ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient},
-        token::Token,
-    },
-    std::sync::Arc,
-};
-
-struct TestContext {
-    pub decimals: u8,
-    pub mint_authority: Keypair,
-    pub token: Token<ProgramBanksClientProcessTransaction>,
-
-    pub alice: Keypair,
-    pub bob: Keypair,
-}
-
-impl TestContext {
-    async fn new() -> Self {
-        let program_test = ProgramTest::default();
-        let ctx = program_test.start_with_context().await;
-        let ctx = Arc::new(Mutex::new(ctx));
-
-        let payer = keypair_clone(&ctx.lock().await.payer);
-
-        let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
-            Arc::new(ProgramBanksClient::new_from_context(
-                Arc::clone(&ctx),
-                ProgramBanksClientProcessTransaction,
-            ));
-
-        let decimals: u8 = 6;
-
-        let mint_account = Keypair::new();
-        let mint_authority = Keypair::new();
-        let mint_authority_pubkey = mint_authority.pubkey();
-
-        let token = Token::new(
-            Arc::clone(&client),
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(decimals),
-            Arc::new(keypair_clone(&payer)),
-        );
-
-        token
-            .create_mint(&mint_authority_pubkey, None, vec![], &[&mint_account])
-            .await
-            .expect("failed to create mint");
-
-        Self {
-            decimals,
-            mint_authority,
-            token,
-
-            alice: Keypair::new(),
-            bob: Keypair::new(),
-        }
-    }
-}
-
-fn keypair_clone(kp: &Keypair) -> Keypair {
-    Keypair::from_bytes(&kp.to_bytes()).expect("failed to copy keypair")
-}
-
-#[tokio::test]
-async fn associated_token_account() {
-    let TestContext { token, alice, .. } = TestContext::new().await;
-
-    token
-        .create_associated_token_account(&alice.pubkey())
-        .await
-        .expect("failed to create associated token account");
-    let alice_vault = token.get_associated_token_address(&alice.pubkey());
-
-    assert_eq!(
-        token.get_associated_token_address(&alice.pubkey()),
-        alice_vault
-    );
-
-    assert_eq!(
-        token
-            .get_account_info(&alice_vault)
-            .await
-            .expect("failed to get account info")
-            .base,
-        state::Account {
-            mint: *token.get_address(),
-            owner: alice.pubkey(),
-            amount: 0,
-            delegate: COption::None,
-            state: state::AccountState::Initialized,
-            is_native: COption::None,
-            delegated_amount: 0,
-            close_authority: COption::None,
-        }
-    );
-}
-
-#[tokio::test]
-async fn get_or_create_associated_token_account() {
-    let TestContext { token, alice, .. } = TestContext::new().await;
-
-    assert_eq!(
-        token
-            .get_or_create_associated_account_info(&alice.pubkey())
-            .await
-            .expect("failed to get account info")
-            .base,
-        state::Account {
-            mint: *token.get_address(),
-            owner: alice.pubkey(),
-            amount: 0,
-            delegate: COption::None,
-            state: state::AccountState::Initialized,
-            is_native: COption::None,
-            delegated_amount: 0,
-            close_authority: COption::None,
-        }
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let TestContext {
-        mint_authority,
-        token,
-        alice,
-        bob,
-        ..
-    } = TestContext::new().await;
-
-    let alice_vault = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_vault, &alice.pubkey())
-        .await
-        .expect("failed to create token account");
-    let alice_vault = alice_vault.pubkey();
-
-    token
-        .mint_to(
-            &alice_vault,
-            &mint_authority.pubkey(),
-            1,
-            &[&mint_authority],
-        )
-        .await
-        .expect("failed to mint token");
-
-    token
-        .set_authority(
-            token.get_address(),
-            &mint_authority.pubkey(),
-            None,
-            instruction::AuthorityType::MintTokens,
-            &[&mint_authority],
-        )
-        .await
-        .expect("failed to set authority");
-
-    let mint = token
-        .get_mint_info()
-        .await
-        .expect("failed to get mint info");
-    assert!(mint.base.mint_authority.is_none());
-
-    // TODO: compare
-    // Err(Client(TransactionError(InstructionError(0, Custom(5)))))
-    assert!(token
-        .mint_to(
-            &alice_vault,
-            &mint_authority.pubkey(),
-            2,
-            &[&mint_authority]
-        )
-        .await
-        .is_err());
-
-    token
-        .set_authority(
-            &alice_vault,
-            &alice.pubkey(),
-            Some(&bob.pubkey()),
-            instruction::AuthorityType::AccountOwner,
-            &[&alice],
-        )
-        .await
-        .expect("failed to set_authority");
-
-    assert_eq!(
-        token
-            .get_account_info(&alice_vault)
-            .await
-            .expect("failed to get account info")
-            .base
-            .owner,
-        bob.pubkey(),
-    );
-}
-
-#[tokio::test]
-async fn mint_to() {
-    let TestContext {
-        decimals,
-        mint_authority,
-        token,
-        alice,
-        ..
-    } = TestContext::new().await;
-
-    token
-        .create_associated_token_account(&alice.pubkey())
-        .await
-        .expect("failed to create associated token account");
-    let alice_vault = token.get_associated_token_address(&alice.pubkey());
-
-    let mint_amount = 10 * u64::pow(10, decimals as u32);
-    token
-        .mint_to(
-            &alice_vault,
-            &mint_authority.pubkey(),
-            mint_amount,
-            &[&mint_authority],
-        )
-        .await
-        .expect("failed to mint token");
-
-    assert_eq!(
-        token
-            .get_account_info(&alice_vault)
-            .await
-            .expect("failed to get account")
-            .base
-            .amount,
-        mint_amount
-    );
-}
-
-#[tokio::test]
-async fn transfer() {
-    let TestContext {
-        decimals,
-        mint_authority,
-        token,
-        alice,
-        bob,
-        ..
-    } = TestContext::new().await;
-
-    token
-        .create_associated_token_account(&alice.pubkey())
-        .await
-        .expect("failed to create associated token account");
-    let alice_vault = token.get_associated_token_address(&alice.pubkey());
-    token
-        .create_associated_token_account(&bob.pubkey())
-        .await
-        .expect("failed to create associated token account");
-    let bob_vault = token.get_associated_token_address(&bob.pubkey());
-
-    let mint_amount = 10 * u64::pow(10, decimals as u32);
-    token
-        .mint_to(
-            &alice_vault,
-            &mint_authority.pubkey(),
-            mint_amount,
-            &[&mint_authority],
-        )
-        .await
-        .expect("failed to mint token");
-
-    let transfer_amount = mint_amount.overflowing_div(3).0;
-    token
-        .transfer(
-            &alice_vault,
-            &bob_vault,
-            &alice.pubkey(),
-            transfer_amount,
-            &[&alice],
-        )
-        .await
-        .expect("failed to transfer");
-
-    assert_eq!(
-        token
-            .get_account_info(&alice_vault)
-            .await
-            .expect("failed to get account")
-            .base
-            .amount,
-        mint_amount - transfer_amount
-    );
-    assert_eq!(
-        token
-            .get_account_info(&bob_vault)
-            .await
-            .expect("failed to get account")
-            .base
-            .amount,
-        transfer_amount
-    );
-}
diff --git a/token/js/.eslintignore b/token/js/.eslintignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token/js/.eslintignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token/js/.eslintrc b/token/js/.eslintrc
deleted file mode 100644
index 5aef10a4729..00000000000
--- a/token/js/.eslintrc
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "root": true,
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended",
-        "plugin:require-extensions/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint",
-        "prettier",
-        "require-extensions"
-    ],
-    "rules": {
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/consistent-type-imports": "error"
-    },
-    "overrides": [
-        {
-            "files": [
-                "examples/**/*",
-                "test/**/*"
-            ],
-            "rules": {
-                "require-extensions/require-extensions": "off",
-                "require-extensions/require-index": "off"
-            }
-        }
-    ]
-}
diff --git a/token/js/.gitignore b/token/js/.gitignore
deleted file mode 100644
index 21f33db819c..00000000000
--- a/token/js/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.idea
-.vscode
-.DS_Store
-
-node_modules
-
-pnpm-lock.yaml
-yarn.lock
-
-docs
-lib
-test-ledger
-*.tsbuildinfo
diff --git a/token/js/.mocharc.json b/token/js/.mocharc.json
deleted file mode 100644
index 451c14c3016..00000000000
--- a/token/js/.mocharc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "extension": ["ts"],
-    "node-option": ["experimental-specifier-resolution=node", "loader=ts-node/esm"],
-    "timeout": 5000
-}
diff --git a/token/js/.nojekyll b/token/js/.nojekyll
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/token/js/.prettierignore b/token/js/.prettierignore
deleted file mode 100644
index 6da325effab..00000000000
--- a/token/js/.prettierignore
+++ /dev/null
@@ -1,5 +0,0 @@
-docs
-lib
-test-ledger
-
-package-lock.json
diff --git a/token/js/.prettierrc b/token/js/.prettierrc
deleted file mode 100644
index b9ce4c1923a..00000000000
--- a/token/js/.prettierrc
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "printWidth": 120,
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}
\ No newline at end of file
diff --git a/token/js/LICENSE b/token/js/LICENSE
deleted file mode 100644
index d6456956733..00000000000
--- a/token/js/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/token/js/README.md b/token/js/README.md
deleted file mode 100644
index 11e20732044..00000000000
--- a/token/js/README.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# `@solana/spl-token`
-
-A TypeScript library for interacting with the SPL Token and Token-2022 programs.
-
-## Links
-
-- [TypeScript Docs](https://solana-labs.github.io/solana-program-library/token/js/)
-- [FAQs (Frequently Asked Questions)](#faqs)
-- [Install](#install)
-- [Build from Source](#build-from-source)
-
-## FAQs
-
-### How can I get support?
-
-Please ask questions in the Solana Stack Exchange: https://solana.stackexchange.com/
-
-If you've found a bug or you'd like to request a feature, please
-[open an issue](https://github.com/solana-labs/solana-program-library/issues/new).
-
-### No export named Token
-
-Please see [upgrading from 0.1.x](#upgrading-from-01x).
-
-## Install
-
-```shell
-npm install --save @solana/spl-token @solana/web3.js
-```
-_OR_
-```shell
-yarn add @solana/spl-token @solana/web3.js
-```
-
-## Build from Source
-
-0. Prerequisites
-
-* Node 16+
-* PNPM
-
-If you have Node 16+, you can [activate PNPM with Corepack](https://pnpm.io/installation#using-corepack).
-
-1. Clone the project:
-```shell
-git clone https://github.com/solana-labs/solana-program-library.git
-```
-
-2. Navigate to the root of the repository:
-```shell
-cd solana-program-library
-```
-
-3. Install the dependencies:
-```shell
-pnpm install
-```
-
-4. Build the libraries in the repository:
-```shell
-pnpm run build
-```
-
-5. Navigate to the SPL Token library:
-```shell
-cd token/js
-```
-
-6. Build the on-chain programs:
-```shell
-pnpm run test:build-programs
-```
-
-7. Run the tests:
-```shell
-pnpm run test
-```
-
-8. Run the example:
-```shell
-pnpm run example
-```
-
-## Upgrading
-
-### Upgrading from 0.2.0
-
-There are no breaking changes from 0.2.0, only new functionality for Token-2022.
-
-### Upgrading from 0.1.x
-
-When upgrading from spl-token 0.1.x, you may see the following error in your code:
-
-```
-import {TOKEN_PROGRAM_ID, Token, AccountLayout} from '@solana/spl-token';
-                          ^^^^^
-SyntaxError: The requested module '@solana/spl-token' does not provide an export named 'Token'
-```
-
-The `@solana/spl-token` library as of version 0.2.0 does not have the `Token`
-class. Instead the actions are split up and exported separately.
-
-To use the old version, install it with:
-
-```
-npm install @solana/spl-token@0.1.8
-```
-
-Otherwise you can find documentation on how to use new versions on the
-[SPL docs](https://spl.solana.com/token) or
-[Solana Cookbook](https://solanacookbook.com/references/token.html).
diff --git a/token/js/examples/cpiGuard.ts b/token/js/examples/cpiGuard.ts
deleted file mode 100644
index 9158d32107f..00000000000
--- a/token/js/examples/cpiGuard.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    createMint,
-    createEnableCpiGuardInstruction,
-    createInitializeAccountInstruction,
-    disableCpiGuard,
-    enableCpiGuard,
-    getAccountLen,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const decimals = 9;
-    const mint = await createMint(
-        connection,
-        payer,
-        mintAuthority.publicKey,
-        mintAuthority.publicKey,
-        decimals,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const accountLen = getAccountLen([ExtensionType.CpiGuard]);
-    const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-    const owner = Keypair.generate();
-    const destinationKeypair = Keypair.generate();
-    const destination = destinationKeypair.publicKey;
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: destination,
-            space: accountLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeAccountInstruction(destination, mint, owner.publicKey, TOKEN_2022_PROGRAM_ID),
-        createEnableCpiGuardInstruction(destination, owner.publicKey, [], TOKEN_2022_PROGRAM_ID)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, owner, destinationKeypair], undefined);
-
-    await disableCpiGuard(connection, payer, destination, owner, [], undefined, TOKEN_2022_PROGRAM_ID);
-
-    await enableCpiGuard(connection, payer, destination, owner, [], undefined, TOKEN_2022_PROGRAM_ID);
-})();
diff --git a/token/js/examples/createMintAndTransferTokens.ts b/token/js/examples/createMintAndTransferTokens.ts
deleted file mode 100644
index 30a619b980d..00000000000
--- a/token/js/examples/createMintAndTransferTokens.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { clusterApiUrl, Connection, Keypair, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { createMint, getOrCreateAssociatedTokenAccount, mintTo, transfer } from '../src'; // @FIXME: replace with @solana/spl-token
-
-(async () => {
-    // Connect to cluster
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    // Generate a new wallet keypair and airdrop SOL
-    const fromWallet = Keypair.generate();
-    const fromAirdropSignature = await connection.requestAirdrop(fromWallet.publicKey, LAMPORTS_PER_SOL);
-
-    // Wait for airdrop confirmation
-    await connection.confirmTransaction({
-        signature: fromAirdropSignature,
-        ...(await connection.getLatestBlockhash()),
-    });
-
-    // Generate a new wallet to receive newly minted token
-    const toWallet = Keypair.generate();
-
-    // Create new token mint
-    const mint = await createMint(connection, fromWallet, fromWallet.publicKey, null, 9);
-
-    // Get the token account of the fromWallet address, and if it does not exist, create it
-    const fromTokenAccount = await getOrCreateAssociatedTokenAccount(
-        connection,
-        fromWallet,
-        mint,
-        fromWallet.publicKey
-    );
-
-    // Get the token account of the toWallet address, and if it does not exist, create it
-    const toTokenAccount = await getOrCreateAssociatedTokenAccount(connection, fromWallet, mint, toWallet.publicKey);
-
-    // Mint 1 new token to the "fromTokenAccount" account we just created
-    let signature = await mintTo(
-        connection,
-        fromWallet,
-        mint,
-        fromTokenAccount.address,
-        fromWallet.publicKey,
-        1000000000,
-        []
-    );
-    console.log('mint tx:', signature);
-
-    // Transfer the new token to the "toTokenAccount" we just created
-    signature = await transfer(
-        connection,
-        fromWallet,
-        fromTokenAccount.address,
-        toTokenAccount.address,
-        fromWallet.publicKey,
-        1000000000,
-        []
-    );
-    console.log('transfer tx:', signature);
-})();
diff --git a/token/js/examples/createMintCloseAuthority.ts b/token/js/examples/createMintCloseAuthority.ts
deleted file mode 100644
index 9850d782445..00000000000
--- a/token/js/examples/createMintCloseAuthority.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import {
-    closeAccount,
-    createInitializeMintInstruction,
-    createInitializeMintCloseAuthorityInstruction,
-    getMintLen,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-    const mintAuthority = Keypair.generate();
-    const freezeAuthority = Keypair.generate();
-    const closeAuthority = Keypair.generate();
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const extensions = [ExtensionType.MintCloseAuthority];
-    const mintLen = getMintLen(extensions);
-    const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeMintCloseAuthorityInstruction(mint, closeAuthority.publicKey, TOKEN_2022_PROGRAM_ID),
-        createInitializeMintInstruction(
-            mint,
-            9,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            TOKEN_2022_PROGRAM_ID
-        )
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-
-    console.log(mint.toBase58());
-
-    await closeAccount(connection, payer, mint, payer.publicKey, closeAuthority, [], undefined, TOKEN_2022_PROGRAM_ID);
-})();
diff --git a/token/js/examples/defaultAccountState.ts b/token/js/examples/defaultAccountState.ts
deleted file mode 100644
index 8529cf442c5..00000000000
--- a/token/js/examples/defaultAccountState.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    AccountState,
-    createInitializeMintInstruction,
-    createInitializeDefaultAccountStateInstruction,
-    getMintLen,
-    updateDefaultAccountState,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mintAuthority = Keypair.generate();
-    const freezeAuthority = Keypair.generate();
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-
-    const extensions = [ExtensionType.DefaultAccountState];
-    const mintLen = getMintLen(extensions);
-    const decimals = 9;
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const defaultState = AccountState.Frozen;
-
-    const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeDefaultAccountStateInstruction(mint, defaultState, TOKEN_2022_PROGRAM_ID),
-        createInitializeMintInstruction(
-            mint,
-            decimals,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            TOKEN_2022_PROGRAM_ID
-        )
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-
-    await updateDefaultAccountState(
-        connection,
-        payer,
-        mint,
-        AccountState.Initialized,
-        freezeAuthority,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-})();
diff --git a/token/js/examples/immutableOwner.ts b/token/js/examples/immutableOwner.ts
deleted file mode 100644
index 4010a35d074..00000000000
--- a/token/js/examples/immutableOwner.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    createAccount,
-    createMint,
-    createInitializeImmutableOwnerInstruction,
-    createInitializeAccountInstruction,
-    getAccountLen,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const decimals = 9;
-    const mint = await createMint(
-        connection,
-        payer,
-        mintAuthority.publicKey,
-        mintAuthority.publicKey,
-        decimals,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const accountLen = getAccountLen([ExtensionType.ImmutableOwner]);
-    const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-    const owner = Keypair.generate();
-    const accountKeypair = Keypair.generate();
-    const account = accountKeypair.publicKey;
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: account,
-            space: accountLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeImmutableOwnerInstruction(account, TOKEN_2022_PROGRAM_ID),
-        createInitializeAccountInstruction(account, mint, owner.publicKey, TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer, accountKeypair], undefined);
-
-    // create associated token account
-    await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TOKEN_2022_PROGRAM_ID);
-})();
diff --git a/token/js/examples/interestBearing.ts b/token/js/examples/interestBearing.ts
deleted file mode 100644
index 8d688e83ea2..00000000000
--- a/token/js/examples/interestBearing.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { clusterApiUrl, Connection, Keypair, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { createInterestBearingMint, updateRateInterestBearingMint, TOKEN_2022_PROGRAM_ID } from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const freezeAuthority = Keypair.generate();
-    const rateAuthority = Keypair.generate();
-    const mintKeypair = Keypair.generate();
-    const rate = 10;
-    const decimals = 9;
-    const mint = await createInterestBearingMint(
-        connection,
-        payer,
-        mintAuthority.publicKey,
-        freezeAuthority.publicKey,
-        rateAuthority.publicKey,
-        rate,
-        decimals,
-        mintKeypair,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const updateRate = 50;
-    await updateRateInterestBearingMint(
-        connection,
-        payer,
-        mint,
-        rateAuthority,
-        updateRate,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-})();
diff --git a/token/js/examples/memoTransfer.ts b/token/js/examples/memoTransfer.ts
deleted file mode 100644
index 598f17dc650..00000000000
--- a/token/js/examples/memoTransfer.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import { createMemoInstruction } from '@solana/spl-memo';
-import {
-    createAssociatedTokenAccount,
-    createMint,
-    createEnableRequiredMemoTransfersInstruction,
-    createInitializeAccountInstruction,
-    createTransferInstruction,
-    disableRequiredMemoTransfers,
-    enableRequiredMemoTransfers,
-    getAccountLen,
-    mintTo,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const decimals = 9;
-    const mint = await createMint(
-        connection,
-        payer,
-        mintAuthority.publicKey,
-        mintAuthority.publicKey,
-        decimals,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const accountLen = getAccountLen([ExtensionType.MemoTransfer]);
-    const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-    const owner = Keypair.generate();
-    const destinationKeypair = Keypair.generate();
-    const destination = destinationKeypair.publicKey;
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: destination,
-            space: accountLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeAccountInstruction(destination, mint, owner.publicKey, TOKEN_2022_PROGRAM_ID),
-        createEnableRequiredMemoTransfersInstruction(destination, owner.publicKey, [], TOKEN_2022_PROGRAM_ID)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, owner, destinationKeypair], undefined);
-
-    await disableRequiredMemoTransfers(connection, payer, destination, owner, [], undefined, TOKEN_2022_PROGRAM_ID);
-
-    await enableRequiredMemoTransfers(connection, payer, destination, owner, [], undefined, TOKEN_2022_PROGRAM_ID);
-
-    const sourceTokenAccount = await createAssociatedTokenAccount(
-        connection,
-        payer,
-        mint,
-        payer.publicKey,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-    await mintTo(connection, payer, mint, sourceTokenAccount, mintAuthority, 100, [], undefined, TOKEN_2022_PROGRAM_ID);
-
-    const transferTransaction = new Transaction().add(
-        createMemoInstruction('Hello, memo-transfer!', [payer.publicKey]),
-        createTransferInstruction(sourceTokenAccount, destination, payer.publicKey, 100, [], TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, transferTransaction, [payer], undefined);
-})();
diff --git a/token/js/examples/metadata.ts b/token/js/examples/metadata.ts
deleted file mode 100644
index 66b47cb3291..00000000000
--- a/token/js/examples/metadata.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-import {
-    clusterApiUrl,
-    Connection,
-    Keypair,
-    LAMPORTS_PER_SOL,
-    sendAndConfirmTransaction,
-    SystemProgram,
-    Transaction,
-} from '@solana/web3.js';
-import {
-    createInitializeMetadataPointerInstruction,
-    createInitializeMintInstruction,
-    ExtensionType,
-    getMintLen,
-    LENGTH_SIZE,
-    TOKEN_2022_PROGRAM_ID,
-    TYPE_SIZE,
-} from '@solana/spl-token';
-import type { TokenMetadata } from '@solana/spl-token-metadata';
-import {
-    createInitializeInstruction,
-    pack,
-    createUpdateFieldInstruction,
-    createRemoveKeyInstruction,
-} from '@solana/spl-token-metadata';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mint = Keypair.generate();
-    const decimals = 9;
-
-    const metadata: TokenMetadata = {
-        mint: mint.publicKey,
-        name: 'TOKEN_NAME',
-        symbol: 'SMBL',
-        uri: 'URI',
-        additionalMetadata: [['new-field', 'new-value']],
-    };
-
-    const mintLen = getMintLen([ExtensionType.MetadataPointer]);
-
-    const metadataLen = TYPE_SIZE + LENGTH_SIZE + pack(metadata).length;
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({
-        signature: airdropSignature,
-        ...(await connection.getLatestBlockhash()),
-    });
-
-    const mintLamports = await connection.getMinimumBalanceForRentExemption(mintLen + metadataLen);
-    const mintTransaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint.publicKey,
-            space: mintLen,
-            lamports: mintLamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeMetadataPointerInstruction(
-            mint.publicKey,
-            payer.publicKey,
-            mint.publicKey,
-            TOKEN_2022_PROGRAM_ID
-        ),
-        createInitializeMintInstruction(mint.publicKey, decimals, payer.publicKey, null, TOKEN_2022_PROGRAM_ID),
-        createInitializeInstruction({
-            programId: TOKEN_2022_PROGRAM_ID,
-            mint: mint.publicKey,
-            metadata: mint.publicKey,
-            name: metadata.name,
-            symbol: metadata.symbol,
-            uri: metadata.uri,
-            mintAuthority: payer.publicKey,
-            updateAuthority: payer.publicKey,
-        }),
-
-        // add a custom field
-        createUpdateFieldInstruction({
-            metadata: mint.publicKey,
-            updateAuthority: payer.publicKey,
-            programId: TOKEN_2022_PROGRAM_ID,
-            field: metadata.additionalMetadata[0][0],
-            value: metadata.additionalMetadata[0][1],
-        }),
-
-        // update a field
-        createUpdateFieldInstruction({
-            metadata: mint.publicKey,
-            updateAuthority: payer.publicKey,
-            programId: TOKEN_2022_PROGRAM_ID,
-            field: 'name',
-            value: 'YourToken',
-        }),
-
-        // remove a field
-        createRemoveKeyInstruction({
-            programId: TOKEN_2022_PROGRAM_ID,
-            metadata: mint.publicKey,
-            updateAuthority: payer.publicKey,
-            key: 'new-field',
-            idempotent: true, // If false the operation will fail if the field does not exist in the metadata
-        })
-    );
-    const sig = await sendAndConfirmTransaction(connection, mintTransaction, [payer, mint]);
-    console.log('Signature:', sig);
-})();
diff --git a/token/js/examples/nonTransferable.ts b/token/js/examples/nonTransferable.ts
deleted file mode 100644
index 0e2bb7d4e41..00000000000
--- a/token/js/examples/nonTransferable.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    createInitializeNonTransferableMintInstruction,
-    createInitializeMintInstruction,
-    getMintLen,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const decimals = 9;
-
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-    const mintLen = getMintLen([ExtensionType.NonTransferable]);
-    const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeNonTransferableMintInstruction(mint, TOKEN_2022_PROGRAM_ID),
-        createInitializeMintInstruction(mint, decimals, mintAuthority.publicKey, null, TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-})();
diff --git a/token/js/examples/permanentDelegate.ts b/token/js/examples/permanentDelegate.ts
deleted file mode 100644
index 2b87570c602..00000000000
--- a/token/js/examples/permanentDelegate.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    createInitializePermanentDelegateInstruction,
-    mintTo,
-    createAccount,
-    getMintLen,
-    transferChecked,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mintAuthority = Keypair.generate();
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-    const permanentDelegate = Keypair.generate();
-
-    const extensions = [ExtensionType.PermanentDelegate];
-    const mintLen = getMintLen(extensions);
-    const decimals = 9;
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintLamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-    const mintTransaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports: mintLamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializePermanentDelegateInstruction(mint, permanentDelegate.publicKey, TOKEN_2022_PROGRAM_ID),
-        createInitializeMintInstruction(mint, decimals, mintAuthority.publicKey, null, TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, mintTransaction, [payer, mintKeypair], undefined);
-
-    const mintAmount = BigInt(1_000_000_000);
-    const owner = Keypair.generate();
-    const sourceAccount = await createAccount(
-        connection,
-        payer,
-        mint,
-        owner.publicKey,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-    await mintTo(
-        connection,
-        payer,
-        mint,
-        sourceAccount,
-        mintAuthority,
-        mintAmount,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const accountKeypair = Keypair.generate();
-    const destinationAccount = await createAccount(
-        connection,
-        payer,
-        mint,
-        owner.publicKey,
-        accountKeypair,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    // Transfer by signing with the permanent delegate
-    const signature = await transferChecked(
-        connection,
-        payer,
-        sourceAccount,
-        mint,
-        destinationAccount,
-        permanentDelegate,
-        mintAmount,
-        decimals,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-})();
diff --git a/token/js/examples/reallocate.ts b/token/js/examples/reallocate.ts
deleted file mode 100644
index aece8c1ec23..00000000000
--- a/token/js/examples/reallocate.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    createAccount,
-    createMint,
-    createEnableRequiredMemoTransfersInstruction,
-    createReallocateInstruction,
-    ExtensionType,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const payer = Keypair.generate();
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintAuthority = Keypair.generate();
-    const decimals = 9;
-    const mint = await createMint(
-        connection,
-        payer,
-        mintAuthority.publicKey,
-        mintAuthority.publicKey,
-        decimals,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const owner = Keypair.generate();
-    const account = await createAccount(
-        connection,
-        payer,
-        mint,
-        owner.publicKey,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const extensions = [ExtensionType.MemoTransfer];
-    const transaction = new Transaction().add(
-        createReallocateInstruction(
-            account,
-            payer.publicKey,
-            extensions,
-            owner.publicKey,
-            undefined,
-            TOKEN_2022_PROGRAM_ID
-        ),
-        createEnableRequiredMemoTransfersInstruction(account, owner.publicKey, [], TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer, owner], undefined);
-})();
diff --git a/token/js/examples/transferFee.ts b/token/js/examples/transferFee.ts
deleted file mode 100644
index 953a780895b..00000000000
--- a/token/js/examples/transferFee.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    mintTo,
-    createAccount,
-    getMintLen,
-    getTransferFeeAmount,
-    unpackAccount,
-    TOKEN_2022_PROGRAM_ID,
-} from '../src';
-
-import {
-    createInitializeTransferFeeConfigInstruction,
-    harvestWithheldTokensToMint,
-    transferCheckedWithFee,
-    withdrawWithheldTokensFromAccounts,
-    withdrawWithheldTokensFromMint,
-} from '../src/extensions/transferFee/index';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mintAuthority = Keypair.generate();
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-    const transferFeeConfigAuthority = Keypair.generate();
-    const withdrawWithheldAuthority = Keypair.generate();
-
-    const extensions = [ExtensionType.TransferFeeConfig];
-
-    const mintLen = getMintLen(extensions);
-    const decimals = 9;
-    const feeBasisPoints = 50;
-    const maxFee = BigInt(5_000);
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintLamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-    const mintTransaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports: mintLamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeTransferFeeConfigInstruction(
-            mint,
-            transferFeeConfigAuthority.publicKey,
-            withdrawWithheldAuthority.publicKey,
-            feeBasisPoints,
-            maxFee,
-            TOKEN_2022_PROGRAM_ID
-        ),
-        createInitializeMintInstruction(mint, decimals, mintAuthority.publicKey, null, TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, mintTransaction, [payer, mintKeypair], undefined);
-
-    const mintAmount = BigInt(1_000_000_000);
-    const owner = Keypair.generate();
-    const sourceAccount = await createAccount(
-        connection,
-        payer,
-        mint,
-        owner.publicKey,
-        undefined,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-    await mintTo(
-        connection,
-        payer,
-        mint,
-        sourceAccount,
-        mintAuthority,
-        mintAmount,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const accountKeypair = Keypair.generate();
-    const destinationAccount = await createAccount(
-        connection,
-        payer,
-        mint,
-        owner.publicKey,
-        accountKeypair,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const transferAmount = BigInt(1_000_000);
-    const fee = (transferAmount * BigInt(feeBasisPoints)) / BigInt(10_000);
-    await transferCheckedWithFee(
-        connection,
-        payer,
-        sourceAccount,
-        mint,
-        destinationAccount,
-        owner,
-        transferAmount,
-        decimals,
-        fee,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const allAccounts = await connection.getProgramAccounts(TOKEN_2022_PROGRAM_ID, {
-        commitment: 'confirmed',
-        filters: [
-            {
-                memcmp: {
-                    offset: 0,
-                    bytes: mint.toString(),
-                },
-            },
-        ],
-    });
-    const accountsToWithdrawFrom = [];
-    for (const accountInfo of allAccounts) {
-        const account = unpackAccount(accountInfo.pubkey, accountInfo.account, TOKEN_2022_PROGRAM_ID);
-        const transferFeeAmount = getTransferFeeAmount(account);
-        if (transferFeeAmount !== null && transferFeeAmount.withheldAmount > BigInt(0)) {
-            accountsToWithdrawFrom.push(accountInfo.pubkey);
-        }
-    }
-
-    await withdrawWithheldTokensFromAccounts(
-        connection,
-        payer,
-        mint,
-        destinationAccount,
-        withdrawWithheldAuthority,
-        [],
-        accountsToWithdrawFrom,
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    await harvestWithheldTokensToMint(connection, payer, mint, [destinationAccount], undefined, TOKEN_2022_PROGRAM_ID);
-
-    await withdrawWithheldTokensFromMint(
-        connection,
-        payer,
-        mint,
-        destinationAccount,
-        withdrawWithheldAuthority,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-})();
diff --git a/token/js/examples/transferHook.ts b/token/js/examples/transferHook.ts
deleted file mode 100644
index bd73583b797..00000000000
--- a/token/js/examples/transferHook.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import {
-    clusterApiUrl,
-    sendAndConfirmTransaction,
-    Connection,
-    Keypair,
-    PublicKey,
-    SystemProgram,
-    Transaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    createInitializeTransferHookInstruction,
-    getMintLen,
-    TOKEN_2022_PROGRAM_ID,
-    updateTransferHook,
-    transferCheckedWithTransferHook,
-    getAssociatedTokenAddressSync,
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-} from '../src';
-
-(async () => {
-    const payer = Keypair.generate();
-
-    const mintAuthority = Keypair.generate();
-    const mintKeypair = Keypair.generate();
-    const mint = mintKeypair.publicKey;
-
-    const sender = Keypair.generate();
-    const recipient = Keypair.generate();
-
-    const extensions = [ExtensionType.TransferHook];
-    const mintLen = getMintLen(extensions);
-    const decimals = 9;
-    const transferHookPogramId = new PublicKey('7N4HggYEJAtCLJdnHGCtFqfxcB5rhQCsQTze3ftYstVj');
-    const newTransferHookProgramId = new PublicKey('7N4HggYEJAtCLJdnHGCtFqfxcB5rhQCsQTze3ftYstVj');
-
-    const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
-
-    const airdropSignature = await connection.requestAirdrop(payer.publicKey, 2 * LAMPORTS_PER_SOL);
-    await connection.confirmTransaction({ signature: airdropSignature, ...(await connection.getLatestBlockhash()) });
-
-    const mintLamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-    const mintTransaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: mint,
-            space: mintLen,
-            lamports: mintLamports,
-            programId: TOKEN_2022_PROGRAM_ID,
-        }),
-        createInitializeTransferHookInstruction(mint, payer.publicKey, transferHookPogramId, TOKEN_2022_PROGRAM_ID),
-        createInitializeMintInstruction(mint, decimals, mintAuthority.publicKey, null, TOKEN_2022_PROGRAM_ID)
-    );
-    await sendAndConfirmTransaction(connection, mintTransaction, [payer, mintKeypair], undefined);
-
-    await updateTransferHook(
-        connection,
-        payer,
-        mint,
-        newTransferHookProgramId,
-        payer.publicKey,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-
-    const senderAta = getAssociatedTokenAddressSync(
-        mint,
-        sender.publicKey,
-        false,
-        TOKEN_2022_PROGRAM_ID,
-        ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    const recipientAta = getAssociatedTokenAddressSync(
-        mint,
-        recipient.publicKey,
-        false,
-        TOKEN_2022_PROGRAM_ID,
-        ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-
-    await transferCheckedWithTransferHook(
-        connection,
-        payer,
-        senderAta,
-        mint,
-        recipientAta,
-        sender,
-        BigInt(1000000000),
-        9,
-        [],
-        undefined,
-        TOKEN_2022_PROGRAM_ID
-    );
-})();
diff --git a/token/js/package.json b/token/js/package.json
deleted file mode 100644
index 00c501efedc..00000000000
--- a/token/js/package.json
+++ /dev/null
@@ -1,90 +0,0 @@
-{
-    "name": "@solana/spl-token",
-    "description": "SPL Token Program JS API",
-    "version": "0.4.4",
-    "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
-    "repository": "https://github.com/solana-labs/solana-program-library",
-    "license": "Apache-2.0",
-    "type": "module",
-    "sideEffects": false,
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "lib",
-        "src",
-        "LICENSE",
-        "README.md"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "./lib/cjs/index.js",
-    "module": "./lib/esm/index.js",
-    "types": "./lib/types/index.d.ts",
-    "exports": {
-        "types": "./lib/types/index.d.ts",
-        "require": "./lib/cjs/index.js",
-        "import": "./lib/esm/index.js"
-    },
-    "scripts": {
-        "nuke": "shx rm -rf node_modules package-lock.json || true",
-        "reinstall": "npm run nuke && npm install",
-        "clean": "shx rm -rf lib **/*.tsbuildinfo || true",
-        "build": "tsc --build --verbose tsconfig.all.json",
-        "postbuild": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json",
-        "build:program": "cargo build-sbf --manifest-path=../program/Cargo.toml && cargo build-sbf --manifest-path=../program-2022/Cargo.toml && cargo build-sbf --manifest-path=../../associated-token-account/program/Cargo.toml && cargo build-sbf --no-default-features --manifest-path=../transfer-hook/example/Cargo.toml",
-        "watch": "tsc --build --verbose --watch tsconfig.all.json",
-        "release": "npm run clean && npm run build",
-        "fmt": "prettier --write '{*,**/*}.{ts,tsx,js,jsx,json}'",
-        "lint": "prettier --check '{*,**/*}.{ts,tsx,js,jsx,json}' && eslint --max-warnings 0 .",
-        "lint:fix": "npm run fmt && eslint --fix .",
-        "example": "node --experimental-specifier-resolution=node --loader ts-node/esm examples/createMintAndTransferTokens.ts",
-        "test": "npm run test:unit && npm run test:e2e-built && npm run test:e2e-native && npm run test:e2e-2022",
-        "test:unit": "mocha test/unit",
-        "test:e2e-built": "start-server-and-test 'solana-test-validator --bpf-program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA ../../target/deploy/spl_token.so --reset --quiet' http://127.0.0.1:8899/health 'mocha test/e2e'",
-        "test:e2e-2022": "TEST_PROGRAM_ID=TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb start-server-and-test 'solana-test-validator --bpf-program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL ../../target/deploy/spl_associated_token_account.so --bpf-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb ../../target/deploy/spl_token_2022.so --bpf-program TokenHookExampLe8smaVNrxTBezWTRbEwxwb1Zykrb ../../target/deploy/spl_transfer_hook_example.so --reset --quiet' http://127.0.0.1:8899/health 'mocha test/e2e*'",
-        "test:e2e-native": "start-server-and-test 'solana-test-validator --reset --quiet' http://127.0.0.1:8899/health 'mocha test/e2e'",
-        "test:build-programs": "cargo build-sbf --manifest-path ../program/Cargo.toml && cargo build-sbf --manifest-path ../program-2022/Cargo.toml && cargo build-sbf --manifest-path ../../associated-token-account/program/Cargo.toml",
-        "deploy": "npm run deploy:docs",
-        "docs": "shx rm -rf docs && typedoc && shx cp .nojekyll docs/",
-        "deploy:docs": "npm run docs && gh-pages --dest token/js --dist docs --dotfiles"
-    },
-    "peerDependencies": {
-        "@solana/web3.js": "^1.93.0"
-    },
-    "dependencies": {
-        "@solana/buffer-layout": "^4.0.0",
-        "@solana/buffer-layout-utils": "^0.2.0",
-        "@solana/spl-token-group": "^0.0.3",
-        "@solana/spl-token-metadata": "^0.1.3",
-        "buffer": "^6.0.3"
-    },
-    "devDependencies": {
-        "@solana/codecs-strings": "2.0.0-preview.3",
-        "@solana/spl-memo": "0.2.4",
-        "@solana/web3.js": "^1.93.0",
-        "@types/chai-as-promised": "^7.1.4",
-        "@types/chai": "^4.3.16",
-        "@types/mocha": "^10.0.6",
-        "@types/node": "^20.14.5",
-        "@types/node-fetch": "^2.6.11",
-        "@typescript-eslint/eslint-plugin": "^7.13.1",
-        "@typescript-eslint/parser": "^7.13.1",
-        "chai": "^5.1.1",
-        "chai-as-promised": "^8.0.0",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "eslint-plugin-require-extensions": "^0.1.1",
-        "gh-pages": "^6.1.1",
-        "mocha": "^10.4.0",
-        "prettier": "^3.3.2",
-        "process": "^0.11.10",
-        "shx": "^0.3.4",
-        "start-server-and-test": "^2.0.4",
-        "ts-node": "^10.9.2",
-        "typedoc": "^0.25.13",
-        "typescript": "^5.4.5"
-    }
-}
diff --git a/token/js/src/actions/amountToUiAmount.ts b/token/js/src/actions/amountToUiAmount.ts
deleted file mode 100644
index e39d13ae260..00000000000
--- a/token/js/src/actions/amountToUiAmount.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import type { Connection, PublicKey, Signer, TransactionError } from '@solana/web3.js';
-import { Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createAmountToUiAmountInstruction } from '../instructions/amountToUiAmount.js';
-
-/**
- * Amount as a string using mint-prescribed decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param amount         Amount of tokens to be converted to Ui Amount
- * @param programId      SPL Token program account
- *
- * @return Ui Amount generated
- */
-export async function amountToUiAmount(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | bigint,
-    programId = TOKEN_PROGRAM_ID
-): Promise<string | TransactionError | null> {
-    const transaction = new Transaction().add(createAmountToUiAmountInstruction(mint, amount, programId));
-    const { returnData, err } = (await connection.simulateTransaction(transaction, [payer], false)).value;
-    if (returnData?.data) {
-        return Buffer.from(returnData.data[0], returnData.data[1]).toString('utf-8');
-    }
-    return err;
-}
diff --git a/token/js/src/actions/approve.ts b/token/js/src/actions/approve.ts
deleted file mode 100644
index 3c16310ee91..00000000000
--- a/token/js/src/actions/approve.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createApproveInstruction } from '../instructions/approve.js';
-import { getSigners } from './internal.js';
-
-/**
- * Approve a delegate to transfer up to a maximum number of tokens from an account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Address of the token account
- * @param delegate       Account authorized to transfer tokens from the account
- * @param owner          Owner of the account
- * @param amount         Maximum number of tokens the delegate may transfer
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function approve(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    delegate: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createApproveInstruction(account, delegate, ownerPublicKey, amount, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/approveChecked.ts b/token/js/src/actions/approveChecked.ts
deleted file mode 100644
index b32c0b796ff..00000000000
--- a/token/js/src/actions/approveChecked.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createApproveCheckedInstruction } from '../instructions/approveChecked.js';
-import { getSigners } from './internal.js';
-
-/**
- * Approve a delegate to transfer up to a maximum number of tokens from an account, asserting the token mint and
- * decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           Address of the mint
- * @param account        Address of the account
- * @param delegate       Account authorized to perform a transfer tokens from the source account
- * @param owner          Owner of the source account
- * @param amount         Maximum number of tokens the delegate may transfer
- * @param decimals       Number of decimals in approve amount
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function approveChecked(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    account: PublicKey,
-    delegate: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createApproveCheckedInstruction(
-            account,
-            mint,
-            delegate,
-            ownerPublicKey,
-            amount,
-            decimals,
-            multiSigners,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/burn.ts b/token/js/src/actions/burn.ts
deleted file mode 100644
index ea54f591151..00000000000
--- a/token/js/src/actions/burn.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createBurnInstruction } from '../instructions/burn.js';
-import { getSigners } from './internal.js';
-
-/**
- * Burn tokens from an account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to burn tokens from
- * @param mint           Mint for the account
- * @param owner          Account owner
- * @param amount         Amount to burn
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function burn(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    mint: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createBurnInstruction(account, mint, ownerPublicKey, amount, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/burnChecked.ts b/token/js/src/actions/burnChecked.ts
deleted file mode 100644
index 5ca9b7285bb..00000000000
--- a/token/js/src/actions/burnChecked.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createBurnCheckedInstruction } from '../instructions/burnChecked.js';
-import { getSigners } from './internal.js';
-
-/**
- * Burn tokens from an account, asserting the token mint and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to burn tokens from
- * @param mint           Mint for the account
- * @param owner          Account owner
- * @param amount         Amount to burn
- * @param decimals       Number of decimals in amount to burn
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function burnChecked(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    mint: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createBurnCheckedInstruction(account, mint, ownerPublicKey, amount, decimals, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/closeAccount.ts b/token/js/src/actions/closeAccount.ts
deleted file mode 100644
index fe99dc4ec72..00000000000
--- a/token/js/src/actions/closeAccount.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createCloseAccountInstruction } from '../instructions/closeAccount.js';
-import { getSigners } from './internal.js';
-
-/**
- * Close a token account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to close
- * @param destination    Account to receive the remaining balance of the closed account
- * @param authority      Authority which is allowed to close the account
- * @param multiSigners   Signing accounts if `authority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function closeAccount(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createCloseAccountInstruction(account, destination, authorityPublicKey, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/createAccount.ts b/token/js/src/actions/createAccount.ts
deleted file mode 100644
index 9a680a73006..00000000000
--- a/token/js/src/actions/createAccount.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type { ConfirmOptions, Connection, Keypair, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { getAccountLenForMint } from '../extensions/extensionType.js';
-import { createInitializeAccountInstruction } from '../instructions/initializeAccount.js';
-import { getMint } from '../state/mint.js';
-import { createAssociatedTokenAccount } from './createAssociatedTokenAccount.js';
-
-/**
- * Create and initialize a new token account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction and initialization fees
- * @param mint           Mint for the account
- * @param owner          Owner of the new account
- * @param keypair        Optional keypair, defaulting to the associated token account for the `mint` and `owner`
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Address of the new token account
- */
-export async function createAccount(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    owner: PublicKey,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    // If a keypair isn't provided, create the associated token account and return its address
-    if (!keypair) return await createAssociatedTokenAccount(connection, payer, mint, owner, confirmOptions, programId);
-
-    // Otherwise, create the account with the provided keypair and return its public key
-    const mintState = await getMint(connection, mint, confirmOptions?.commitment, programId);
-    const space = getAccountLenForMint(mintState);
-    const lamports = await connection.getMinimumBalanceForRentExemption(space);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: keypair.publicKey,
-            space,
-            lamports,
-            programId,
-        }),
-        createInitializeAccountInstruction(keypair.publicKey, mint, owner, programId)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, keypair], confirmOptions);
-
-    return keypair.publicKey;
-}
diff --git a/token/js/src/actions/createAssociatedTokenAccount.ts b/token/js/src/actions/createAssociatedTokenAccount.ts
deleted file mode 100644
index 42199a0cd24..00000000000
--- a/token/js/src/actions/createAssociatedTokenAccount.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-import { createAssociatedTokenAccountInstruction } from '../instructions/associatedTokenAccount.js';
-import { getAssociatedTokenAddressSync } from '../state/mint.js';
-
-/**
- * Create and initialize a new associated token account
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param mint                     Mint for the account
- * @param owner                    Owner of the new account
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Address of the new associated token account
- */
-export async function createAssociatedTokenAccount(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    owner: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    const associatedToken = getAssociatedTokenAddressSync(mint, owner, false, programId, associatedTokenProgramId);
-
-    const transaction = new Transaction().add(
-        createAssociatedTokenAccountInstruction(
-            payer.publicKey,
-            associatedToken,
-            owner,
-            mint,
-            programId,
-            associatedTokenProgramId
-        )
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-
-    return associatedToken;
-}
diff --git a/token/js/src/actions/createAssociatedTokenAccountIdempotent.ts b/token/js/src/actions/createAssociatedTokenAccountIdempotent.ts
deleted file mode 100644
index 25329bef677..00000000000
--- a/token/js/src/actions/createAssociatedTokenAccountIdempotent.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-import { createAssociatedTokenAccountIdempotentInstruction } from '../instructions/associatedTokenAccount.js';
-import { getAssociatedTokenAddressSync } from '../state/mint.js';
-
-/**
- * Create and initialize a new associated token account
- * The instruction will succeed even if the associated token account already exists
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param mint                     Mint for the account
- * @param owner                    Owner of the new account
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Address of the new or existing associated token account
- */
-export async function createAssociatedTokenAccountIdempotent(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    owner: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    const associatedToken = getAssociatedTokenAddressSync(mint, owner, false, programId, associatedTokenProgramId);
-
-    const transaction = new Transaction().add(
-        createAssociatedTokenAccountIdempotentInstruction(
-            payer.publicKey,
-            associatedToken,
-            owner,
-            mint,
-            programId,
-            associatedTokenProgramId
-        )
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-
-    return associatedToken;
-}
diff --git a/token/js/src/actions/createMint.ts b/token/js/src/actions/createMint.ts
deleted file mode 100644
index 39818e17cf4..00000000000
--- a/token/js/src/actions/createMint.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createInitializeMint2Instruction } from '../instructions/initializeMint2.js';
-import { getMinimumBalanceForRentExemptMint, MINT_SIZE } from '../state/mint.js';
-
-/**
- * Create and initialize a new mint
- *
- * @param connection      Connection to use
- * @param payer           Payer of the transaction and initialization fees
- * @param mintAuthority   Account or multisig that will control minting
- * @param freezeAuthority Optional account or multisig that can freeze token accounts
- * @param decimals        Location of the decimal place
- * @param keypair         Optional keypair, defaulting to a new random one
- * @param confirmOptions  Options for confirming the transaction
- * @param programId       SPL Token program account
- *
- * @return Address of the new mint
- */
-export async function createMint(
-    connection: Connection,
-    payer: Signer,
-    mintAuthority: PublicKey,
-    freezeAuthority: PublicKey | null,
-    decimals: number,
-    keypair = Keypair.generate(),
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    const lamports = await getMinimumBalanceForRentExemptMint(connection);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: keypair.publicKey,
-            space: MINT_SIZE,
-            lamports,
-            programId,
-        }),
-        createInitializeMint2Instruction(keypair.publicKey, decimals, mintAuthority, freezeAuthority, programId)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, keypair], confirmOptions);
-
-    return keypair.publicKey;
-}
diff --git a/token/js/src/actions/createMultisig.ts b/token/js/src/actions/createMultisig.ts
deleted file mode 100644
index f7e0ac45d32..00000000000
--- a/token/js/src/actions/createMultisig.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createInitializeMultisigInstruction } from '../instructions/initializeMultisig.js';
-import { getMinimumBalanceForRentExemptMultisig, MULTISIG_SIZE } from '../state/multisig.js';
-
-/**
- * Create and initialize a new multisig
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction and initialization fees
- * @param signers        Full set of signers
- * @param m              Number of required signatures
- * @param keypair        Optional keypair, defaulting to a new random one
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Address of the new multisig
- */
-export async function createMultisig(
-    connection: Connection,
-    payer: Signer,
-    signers: PublicKey[],
-    m: number,
-    keypair = Keypair.generate(),
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    const lamports = await getMinimumBalanceForRentExemptMultisig(connection);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: keypair.publicKey,
-            space: MULTISIG_SIZE,
-            lamports,
-            programId,
-        }),
-        createInitializeMultisigInstruction(keypair.publicKey, signers, m, programId)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, keypair], confirmOptions);
-
-    return keypair.publicKey;
-}
diff --git a/token/js/src/actions/createNativeMint.ts b/token/js/src/actions/createNativeMint.ts
deleted file mode 100644
index 95262693229..00000000000
--- a/token/js/src/actions/createNativeMint.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import type { ConfirmOptions, Connection, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { NATIVE_MINT_2022, TOKEN_2022_PROGRAM_ID } from '../constants.js';
-import { createCreateNativeMintInstruction } from '../instructions/createNativeMint.js';
-
-/**
- * Create native mint
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param nativeMint               Native mint id associated with program
- */
-export async function createNativeMint(
-    connection: Connection,
-    payer: Signer,
-    confirmOptions?: ConfirmOptions,
-    nativeMint = NATIVE_MINT_2022,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<void> {
-    const transaction = new Transaction().add(
-        createCreateNativeMintInstruction(payer.publicKey, nativeMint, programId)
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-}
diff --git a/token/js/src/actions/createWrappedNativeAccount.ts b/token/js/src/actions/createWrappedNativeAccount.ts
deleted file mode 100644
index cc4188d0656..00000000000
--- a/token/js/src/actions/createWrappedNativeAccount.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { ConfirmOptions, Connection, Keypair, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, NATIVE_MINT, TOKEN_PROGRAM_ID } from '../constants.js';
-import { createAssociatedTokenAccountInstruction } from '../instructions/associatedTokenAccount.js';
-import { createInitializeAccountInstruction } from '../instructions/initializeAccount.js';
-import { createSyncNativeInstruction } from '../instructions/syncNative.js';
-import { ACCOUNT_SIZE, getMinimumBalanceForRentExemptAccount } from '../state/account.js';
-import { getAssociatedTokenAddressSync } from '../state/mint.js';
-import { createAccount } from './createAccount.js';
-
-/**
- * Create, initialize, and fund a new wrapped native SOL account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction and initialization fees
- * @param owner          Owner of the new token account
- * @param amount         Number of lamports to wrap
- * @param keypair        Optional keypair, defaulting to the associated token account for the native mint and `owner`
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Address of the new wrapped native SOL account
- */
-export async function createWrappedNativeAccount(
-    connection: Connection,
-    payer: Signer,
-    owner: PublicKey,
-    amount: number,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID,
-    nativeMint = NATIVE_MINT
-): Promise<PublicKey> {
-    // If the amount provided is explicitly 0 or NaN, just create the account without funding it
-    if (!amount) return await createAccount(connection, payer, nativeMint, owner, keypair, confirmOptions, programId);
-
-    // If a keypair isn't provided, create the account at the owner's ATA for the native mint and return its address
-    if (!keypair) {
-        const associatedToken = getAssociatedTokenAddressSync(
-            nativeMint,
-            owner,
-            false,
-            programId,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-
-        const transaction = new Transaction().add(
-            createAssociatedTokenAccountInstruction(
-                payer.publicKey,
-                associatedToken,
-                owner,
-                nativeMint,
-                programId,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            ),
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: associatedToken,
-                lamports: amount,
-            }),
-            createSyncNativeInstruction(associatedToken, programId)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-
-        return associatedToken;
-    }
-
-    // Otherwise, create the account with the provided keypair and return its public key
-    const lamports = await getMinimumBalanceForRentExemptAccount(connection);
-
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: keypair.publicKey,
-            space: ACCOUNT_SIZE,
-            lamports,
-            programId,
-        }),
-        SystemProgram.transfer({
-            fromPubkey: payer.publicKey,
-            toPubkey: keypair.publicKey,
-            lamports: amount,
-        }),
-        createInitializeAccountInstruction(keypair.publicKey, nativeMint, owner, programId)
-    );
-
-    await sendAndConfirmTransaction(connection, transaction, [payer, keypair], confirmOptions);
-
-    return keypair.publicKey;
-}
diff --git a/token/js/src/actions/freezeAccount.ts b/token/js/src/actions/freezeAccount.ts
deleted file mode 100644
index 1ef51fec49e..00000000000
--- a/token/js/src/actions/freezeAccount.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createFreezeAccountInstruction } from '../instructions/freezeAccount.js';
-import { getSigners } from './internal.js';
-
-/**
- * Freeze a token account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to freeze
- * @param mint           Mint for the account
- * @param authority      Mint freeze authority
- * @param multiSigners   Signing accounts if `authority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function freezeAccount(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    mint: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createFreezeAccountInstruction(account, mint, authorityPublicKey, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/getOrCreateAssociatedTokenAccount.ts b/token/js/src/actions/getOrCreateAssociatedTokenAccount.ts
deleted file mode 100644
index caf21388f0d..00000000000
--- a/token/js/src/actions/getOrCreateAssociatedTokenAccount.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import type { Commitment, ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenAccountNotFoundError,
-    TokenInvalidAccountOwnerError,
-    TokenInvalidMintError,
-    TokenInvalidOwnerError,
-} from '../errors.js';
-import { createAssociatedTokenAccountInstruction } from '../instructions/associatedTokenAccount.js';
-import type { Account } from '../state/account.js';
-import { getAccount } from '../state/account.js';
-import { getAssociatedTokenAddressSync } from '../state/mint.js';
-
-/**
- * Retrieve the associated token account, or create it if it doesn't exist
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param mint                     Mint associated with the account to set or verify
- * @param owner                    Owner of the account to set or verify
- * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
- * @param commitment               Desired level of commitment for querying the state
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Address of the new associated token account
- */
-export async function getOrCreateAssociatedTokenAccount(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve = false,
-    commitment?: Commitment,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<Account> {
-    const associatedToken = getAssociatedTokenAddressSync(
-        mint,
-        owner,
-        allowOwnerOffCurve,
-        programId,
-        associatedTokenProgramId
-    );
-
-    // This is the optimal logic, considering TX fee, client-side computation, RPC roundtrips and guaranteed idempotent.
-    // Sadly we can't do this atomically.
-    let account: Account;
-    try {
-        account = await getAccount(connection, associatedToken, commitment, programId);
-    } catch (error: unknown) {
-        // TokenAccountNotFoundError can be possible if the associated address has already received some lamports,
-        // becoming a system account. Assuming program derived addressing is safe, this is the only case for the
-        // TokenInvalidAccountOwnerError in this code path.
-        if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
-            // As this isn't atomic, it's possible others can create associated accounts meanwhile.
-            try {
-                const transaction = new Transaction().add(
-                    createAssociatedTokenAccountInstruction(
-                        payer.publicKey,
-                        associatedToken,
-                        owner,
-                        mint,
-                        programId,
-                        associatedTokenProgramId
-                    )
-                );
-
-                await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-            } catch (error: unknown) {
-                // Ignore all errors; for now there is no API-compatible way to selectively ignore the expected
-                // instruction error if the associated account exists already.
-            }
-
-            // Now this should always succeed
-            account = await getAccount(connection, associatedToken, commitment, programId);
-        } else {
-            throw error;
-        }
-    }
-
-    if (!account.mint.equals(mint)) throw new TokenInvalidMintError();
-    if (!account.owner.equals(owner)) throw new TokenInvalidOwnerError();
-
-    return account;
-}
diff --git a/token/js/src/actions/index.ts b/token/js/src/actions/index.ts
deleted file mode 100644
index 03f24f25d07..00000000000
--- a/token/js/src/actions/index.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-export * from './amountToUiAmount.js';
-export * from './approve.js';
-export * from './approveChecked.js';
-export * from './burn.js';
-export * from './burnChecked.js';
-export * from './closeAccount.js';
-export * from './createAccount.js';
-export * from './createAssociatedTokenAccount.js';
-export * from './createAssociatedTokenAccountIdempotent.js';
-export * from './createMint.js';
-export * from './createMultisig.js';
-export * from './createNativeMint.js';
-export * from './createWrappedNativeAccount.js';
-export * from './freezeAccount.js';
-export * from './getOrCreateAssociatedTokenAccount.js';
-export * from './mintTo.js';
-export * from './mintToChecked.js';
-export * from './recoverNested.js';
-export * from './revoke.js';
-export * from './setAuthority.js';
-export * from './syncNative.js';
-export * from './thawAccount.js';
-export * from './transfer.js';
-export * from './transferChecked.js';
-export * from './uiAmountToAmount.js';
diff --git a/token/js/src/actions/internal.ts b/token/js/src/actions/internal.ts
deleted file mode 100644
index 8af17111659..00000000000
--- a/token/js/src/actions/internal.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-
-/** @internal */
-export function getSigners(signerOrMultisig: Signer | PublicKey, multiSigners: Signer[]): [PublicKey, Signer[]] {
-    return signerOrMultisig instanceof PublicKey
-        ? [signerOrMultisig, multiSigners]
-        : [signerOrMultisig.publicKey, [signerOrMultisig]];
-}
diff --git a/token/js/src/actions/mintTo.ts b/token/js/src/actions/mintTo.ts
deleted file mode 100644
index 06dc5aff049..00000000000
--- a/token/js/src/actions/mintTo.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createMintToInstruction } from '../instructions/mintTo.js';
-import { getSigners } from './internal.js';
-
-/**
- * Mint tokens to an account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to
- * @param authority      Minting authority
- * @param amount         Amount to mint
- * @param multiSigners   Signing accounts if `authority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function mintTo(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createMintToInstruction(mint, destination, authorityPublicKey, amount, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/mintToChecked.ts b/token/js/src/actions/mintToChecked.ts
deleted file mode 100644
index eef7f45cb05..00000000000
--- a/token/js/src/actions/mintToChecked.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createMintToCheckedInstruction } from '../instructions/mintToChecked.js';
-import { getSigners } from './internal.js';
-
-/**
- * Mint tokens to an account, asserting the token mint and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to
- * @param authority      Minting authority
- * @param amount         Amount to mint
- * @param decimals       Number of decimals in amount to mint
- * @param multiSigners   Signing accounts if `authority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function mintToChecked(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createMintToCheckedInstruction(mint, destination, authorityPublicKey, amount, decimals, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/recoverNested.ts b/token/js/src/actions/recoverNested.ts
deleted file mode 100644
index ee1e73b401b..00000000000
--- a/token/js/src/actions/recoverNested.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-import { createRecoverNestedInstruction } from '../instructions/associatedTokenAccount.js';
-import { getAssociatedTokenAddressSync } from '../state/mint.js';
-
-/**
- * Recover funds funds in an associated token account which is owned by an associated token account
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param owner                    Owner of original ATA
- * @param mint                     Mint for the original ATA
- * @param nestedMint               Mint for the nested ATA
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function recoverNested(
-    connection: Connection,
-    payer: Signer,
-    owner: Signer,
-    mint: PublicKey,
-    nestedMint: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const ownerAssociatedToken = getAssociatedTokenAddressSync(
-        mint,
-        owner.publicKey,
-        false,
-        programId,
-        associatedTokenProgramId
-    );
-
-    const destinationAssociatedToken = getAssociatedTokenAddressSync(
-        nestedMint,
-        owner.publicKey,
-        false,
-        programId,
-        associatedTokenProgramId
-    );
-
-    const nestedAssociatedToken = getAssociatedTokenAddressSync(
-        nestedMint,
-        ownerAssociatedToken,
-        true,
-        programId,
-        associatedTokenProgramId
-    );
-
-    const transaction = new Transaction().add(
-        createRecoverNestedInstruction(
-            nestedAssociatedToken,
-            nestedMint,
-            destinationAssociatedToken,
-            ownerAssociatedToken,
-            mint,
-            owner.publicKey,
-            programId,
-            associatedTokenProgramId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, owner], confirmOptions);
-}
diff --git a/token/js/src/actions/revoke.ts b/token/js/src/actions/revoke.ts
deleted file mode 100644
index 1bc3e6dfeb1..00000000000
--- a/token/js/src/actions/revoke.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createRevokeInstruction } from '../instructions/revoke.js';
-import { getSigners } from './internal.js';
-
-/**
- * Revoke approval for the transfer of tokens from an account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Address of the token account
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function revoke(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    owner: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createRevokeInstruction(account, ownerPublicKey, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/setAuthority.ts b/token/js/src/actions/setAuthority.ts
deleted file mode 100644
index f233fb35c37..00000000000
--- a/token/js/src/actions/setAuthority.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import type { AuthorityType } from '../instructions/setAuthority.js';
-import { createSetAuthorityInstruction } from '../instructions/setAuthority.js';
-import { getSigners } from './internal.js';
-
-/**
- * Assign a new authority to the account
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param account          Address of the account
- * @param currentAuthority Current authority of the specified type
- * @param authorityType    Type of authority to set
- * @param newAuthority     New authority of the account
- * @param multiSigners     Signing accounts if `currentAuthority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function setAuthority(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    currentAuthority: Signer | PublicKey,
-    authorityType: AuthorityType,
-    newAuthority: PublicKey | null,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [currentAuthorityPublicKey, signers] = getSigners(currentAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createSetAuthorityInstruction(
-            account,
-            currentAuthorityPublicKey,
-            authorityType,
-            newAuthority,
-            multiSigners,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/syncNative.ts b/token/js/src/actions/syncNative.ts
deleted file mode 100644
index 32bcc886932..00000000000
--- a/token/js/src/actions/syncNative.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createSyncNativeInstruction } from '../instructions/syncNative.js';
-
-/**
- * Sync the balance of a native SPL token account to the underlying system account's lamports
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Native account to sync
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function syncNative(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const transaction = new Transaction().add(createSyncNativeInstruction(account, programId));
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-}
diff --git a/token/js/src/actions/thawAccount.ts b/token/js/src/actions/thawAccount.ts
deleted file mode 100644
index 6491b159b16..00000000000
--- a/token/js/src/actions/thawAccount.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createThawAccountInstruction } from '../instructions/thawAccount.js';
-import { getSigners } from './internal.js';
-
-/**
- * Thaw (unfreeze) a token account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to thaw
- * @param mint           Mint for the account
- * @param authority      Mint freeze authority
- * @param multiSigners   Signing accounts if `authority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function thawAccount(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    mint: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createThawAccountInstruction(account, mint, authorityPublicKey, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/transfer.ts b/token/js/src/actions/transfer.ts
deleted file mode 100644
index c69229838ec..00000000000
--- a/token/js/src/actions/transfer.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createTransferInstruction } from '../instructions/transfer.js';
-import { getSigners } from './internal.js';
-
-/**
- * Transfer tokens from one account to another
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param source         Source account
- * @param destination    Destination account
- * @param owner          Owner of the source account
- * @param amount         Number of tokens to transfer
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function transfer(
-    connection: Connection,
-    payer: Signer,
-    source: PublicKey,
-    destination: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createTransferInstruction(source, destination, ownerPublicKey, amount, multiSigners, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/transferChecked.ts b/token/js/src/actions/transferChecked.ts
deleted file mode 100644
index cd4c6d6c982..00000000000
--- a/token/js/src/actions/transferChecked.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createTransferCheckedInstruction } from '../instructions/transferChecked.js';
-import { getSigners } from './internal.js';
-
-/**
- * Transfer tokens from one account to another, asserting the token mint and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param source         Source account
- * @param mint           Mint for the account
- * @param destination    Destination account
- * @param owner          Owner of the source account
- * @param amount         Number of tokens to transfer
- * @param decimals       Number of decimals in transfer amount
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function transferChecked(
-    connection: Connection,
-    payer: Signer,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: Signer | PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createTransferCheckedInstruction(
-            source,
-            mint,
-            destination,
-            ownerPublicKey,
-            amount,
-            decimals,
-            multiSigners,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/actions/uiAmountToAmount.ts b/token/js/src/actions/uiAmountToAmount.ts
deleted file mode 100644
index 7987b69b64c..00000000000
--- a/token/js/src/actions/uiAmountToAmount.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { u64 } from '@solana/buffer-layout-utils';
-import type { Connection, PublicKey, Signer, TransactionError } from '@solana/web3.js';
-import { Transaction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { createUiAmountToAmountInstruction } from '../instructions/uiAmountToAmount.js';
-
-/**
- * Amount as a string using mint-prescribed decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param amount         Ui Amount of tokens to be converted to Amount
- * @param programId      SPL Token program account
- *
- * @return Ui Amount generated
- */
-export async function uiAmountToAmount(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    amount: string,
-    programId = TOKEN_PROGRAM_ID
-): Promise<bigint | TransactionError | null> {
-    const transaction = new Transaction().add(createUiAmountToAmountInstruction(mint, amount, programId));
-    const { returnData, err } = (await connection.simulateTransaction(transaction, [payer], false)).value;
-    if (returnData) {
-        const data = Buffer.from(returnData.data[0], returnData.data[1]);
-        return u64().decode(data);
-    }
-    return err;
-}
diff --git a/token/js/src/constants.ts b/token/js/src/constants.ts
deleted file mode 100644
index 717755aff7d..00000000000
--- a/token/js/src/constants.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-
-/** Address of the SPL Token program */
-export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-
-/** Address of the SPL Token 2022 program */
-export const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
-
-/** Address of the SPL Associated Token Account program */
-export const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-
-/** Address of the special mint for wrapped native SOL in spl-token */
-export const NATIVE_MINT = new PublicKey('So11111111111111111111111111111111111111112');
-
-/** Address of the special mint for wrapped native SOL in spl-token-2022 */
-export const NATIVE_MINT_2022 = new PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');
-
-/** Check that the token program provided is not `Tokenkeg...`, useful when using extensions */
-export function programSupportsExtensions(programId: PublicKey): boolean {
-    if (programId.equals(TOKEN_PROGRAM_ID)) {
-        return false;
-    } else {
-        return true;
-    }
-}
diff --git a/token/js/src/errors.ts b/token/js/src/errors.ts
deleted file mode 100644
index 4671200eb51..00000000000
--- a/token/js/src/errors.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-/** Base class for errors */
-export abstract class TokenError extends Error {
-    constructor(message?: string) {
-        super(message);
-    }
-}
-
-/** Thrown if an account is not found at the expected address */
-export class TokenAccountNotFoundError extends TokenError {
-    name = 'TokenAccountNotFoundError';
-}
-
-/** Thrown if a program state account is not a valid Account */
-export class TokenInvalidAccountError extends TokenError {
-    name = 'TokenInvalidAccountError';
-}
-
-/** Thrown if a program state account does not contain valid data */
-export class TokenInvalidAccountDataError extends TokenError {
-    name = 'TokenInvalidAccountDataError';
-}
-
-/** Thrown if a program state account is not owned by the expected token program */
-export class TokenInvalidAccountOwnerError extends TokenError {
-    name = 'TokenInvalidAccountOwnerError';
-}
-
-/** Thrown if the byte length of an program state account doesn't match the expected size */
-export class TokenInvalidAccountSizeError extends TokenError {
-    name = 'TokenInvalidAccountSizeError';
-}
-
-/** Thrown if the mint of a token account doesn't match the expected mint */
-export class TokenInvalidMintError extends TokenError {
-    name = 'TokenInvalidMintError';
-}
-
-/** Thrown if the owner of a token account doesn't match the expected owner */
-export class TokenInvalidOwnerError extends TokenError {
-    name = 'TokenInvalidOwnerError';
-}
-
-/** Thrown if the owner of a token account is a PDA (Program Derived Address) */
-export class TokenOwnerOffCurveError extends TokenError {
-    name = 'TokenOwnerOffCurveError';
-}
-
-/** Thrown if an instruction's program is invalid */
-export class TokenInvalidInstructionProgramError extends TokenError {
-    name = 'TokenInvalidInstructionProgramError';
-}
-
-/** Thrown if an instruction's keys are invalid */
-export class TokenInvalidInstructionKeysError extends TokenError {
-    name = 'TokenInvalidInstructionKeysError';
-}
-
-/** Thrown if an instruction's data is invalid */
-export class TokenInvalidInstructionDataError extends TokenError {
-    name = 'TokenInvalidInstructionDataError';
-}
-
-/** Thrown if an instruction's type is invalid */
-export class TokenInvalidInstructionTypeError extends TokenError {
-    name = 'TokenInvalidInstructionTypeError';
-}
-
-/** Thrown if the program does not support the desired instruction */
-export class TokenUnsupportedInstructionError extends TokenError {
-    name = 'TokenUnsupportedInstructionError';
-}
-
-/** Thrown if the transfer hook extra accounts contains an invalid account index */
-export class TokenTransferHookAccountNotFound extends TokenError {
-    name = 'TokenTransferHookAccountNotFound';
-}
-
-/** Thrown if the transfer hook extra accounts contains an invalid seed */
-export class TokenTransferHookInvalidSeed extends TokenError {
-    name = 'TokenTransferHookInvalidSeed';
-}
-
-/** Thrown if account data required by an extra account meta seed config could not be fetched */
-export class TokenTransferHookAccountDataNotFound extends TokenError {
-    name = 'TokenTransferHookAccountDataNotFound';
-}
diff --git a/token/js/src/extensions/accountType.ts b/token/js/src/extensions/accountType.ts
deleted file mode 100644
index 6389c930f68..00000000000
--- a/token/js/src/extensions/accountType.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export enum AccountType {
-    Uninitialized,
-    Mint,
-    Account,
-}
-export const ACCOUNT_TYPE_SIZE = 1;
diff --git a/token/js/src/extensions/cpiGuard/actions.ts b/token/js/src/extensions/cpiGuard/actions.ts
deleted file mode 100644
index 05393b30ab6..00000000000
--- a/token/js/src/extensions/cpiGuard/actions.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { createDisableCpiGuardInstruction, createEnableCpiGuardInstruction } from './instructions.js';
-
-/**
- * Enable CPI Guard on the given account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to modify
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function enableCpiGuard(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    owner: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createEnableCpiGuardInstruction(account, ownerPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Disable CPI Guard on the given account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to modify
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function disableCpiGuard(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    owner: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createDisableCpiGuardInstruction(account, ownerPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/cpiGuard/index.ts b/token/js/src/extensions/cpiGuard/index.ts
deleted file mode 100644
index 5e28fd6b10a..00000000000
--- a/token/js/src/extensions/cpiGuard/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/cpiGuard/instructions.ts b/token/js/src/extensions/cpiGuard/instructions.ts
deleted file mode 100644
index 57754ef4f04..00000000000
--- a/token/js/src/extensions/cpiGuard/instructions.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-
-export enum CpiGuardInstruction {
-    Enable = 0,
-    Disable = 1,
-}
-
-/** TODO: docs */
-export interface CpiGuardInstructionData {
-    instruction: TokenInstruction.CpiGuardExtension;
-    cpiGuardInstruction: CpiGuardInstruction;
-}
-
-/** TODO: docs */
-export const cpiGuardInstructionData = struct<CpiGuardInstructionData>([u8('instruction'), u8('cpiGuardInstruction')]);
-
-/**
- * Construct an EnableCpiGuard instruction
- *
- * @param account         Token account to update
- * @param authority       The account's owner/delegate
- * @param signers         The signer account(s)
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createEnableCpiGuardInstruction(
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    return createCpiGuardInstruction(CpiGuardInstruction.Enable, account, authority, multiSigners, programId);
-}
-
-/**
- * Construct a DisableCpiGuard instruction
- *
- * @param account         Token account to update
- * @param authority       The account's owner/delegate
- * @param signers         The signer account(s)
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createDisableCpiGuardInstruction(
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    return createCpiGuardInstruction(CpiGuardInstruction.Disable, account, authority, multiSigners, programId);
-}
-
-function createCpiGuardInstruction(
-    cpiGuardInstruction: CpiGuardInstruction,
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[],
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = addSigners([{ pubkey: account, isSigner: false, isWritable: true }], authority, multiSigners);
-
-    const data = Buffer.alloc(cpiGuardInstructionData.span);
-    cpiGuardInstructionData.encode(
-        {
-            instruction: TokenInstruction.CpiGuardExtension,
-            cpiGuardInstruction,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/extensions/cpiGuard/state.ts b/token/js/src/extensions/cpiGuard/state.ts
deleted file mode 100644
index b9e5682ed9e..00000000000
--- a/token/js/src/extensions/cpiGuard/state.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { bool } from '@solana/buffer-layout-utils';
-import type { Account } from '../../state/account.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** CpiGuard as stored by the program */
-export interface CpiGuard {
-    /** Lock certain token operations from taking place within CPI for this account */
-    lockCpi: boolean;
-}
-
-/** Buffer layout for de/serializing a CPI Guard extension */
-export const CpiGuardLayout = struct<CpiGuard>([bool('lockCpi')]);
-
-export const CPI_GUARD_SIZE = CpiGuardLayout.span;
-
-export function getCpiGuard(account: Account): CpiGuard | null {
-    const extensionData = getExtensionData(ExtensionType.CpiGuard, account.tlvData);
-    if (extensionData !== null) {
-        return CpiGuardLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/defaultAccountState/actions.ts b/token/js/src/extensions/defaultAccountState/actions.ts
deleted file mode 100644
index 03727a635d7..00000000000
--- a/token/js/src/extensions/defaultAccountState/actions.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import type { AccountState } from '../../state/account.js';
-import {
-    createInitializeDefaultAccountStateInstruction,
-    createUpdateDefaultAccountStateInstruction,
-} from './instructions.js';
-
-/**
- * Initialize a default account state on a mint
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint        Mint to initialize with extension
- * @param state        Account state with which to initialize new accounts
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function initializeDefaultAccountState(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    state: AccountState,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const transaction = new Transaction().add(createInitializeDefaultAccountStateInstruction(mint, state, programId));
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-}
-
-/**
- * Update the default account state on a mint
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint        Mint to modify
- * @param state        New account state to set on created accounts
- * @param freezeAuthority          Freeze authority of the mint
- * @param multiSigners   Signing accounts if `freezeAuthority` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function updateDefaultAccountState(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    state: AccountState,
-    freezeAuthority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [freezeAuthorityPublicKey, signers] = getSigners(freezeAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateDefaultAccountStateInstruction(mint, state, freezeAuthorityPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/defaultAccountState/index.ts b/token/js/src/extensions/defaultAccountState/index.ts
deleted file mode 100644
index 5e28fd6b10a..00000000000
--- a/token/js/src/extensions/defaultAccountState/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/defaultAccountState/instructions.ts b/token/js/src/extensions/defaultAccountState/instructions.ts
deleted file mode 100644
index 518507ec79d..00000000000
--- a/token/js/src/extensions/defaultAccountState/instructions.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import type { AccountState } from '../../state/account.js';
-
-export enum DefaultAccountStateInstruction {
-    Initialize = 0,
-    Update = 1,
-}
-
-/** TODO: docs */
-export interface DefaultAccountStateInstructionData {
-    instruction: TokenInstruction.DefaultAccountStateExtension;
-    defaultAccountStateInstruction: DefaultAccountStateInstruction;
-    accountState: AccountState;
-}
-
-/** TODO: docs */
-export const defaultAccountStateInstructionData = struct<DefaultAccountStateInstructionData>([
-    u8('instruction'),
-    u8('defaultAccountStateInstruction'),
-    u8('accountState'),
-]);
-
-/**
- * Construct an InitializeDefaultAccountState instruction
- *
- * @param mint         Mint to initialize
- * @param accountState Default account state to set on all new accounts
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeDefaultAccountStateInstruction(
-    mint: PublicKey,
-    accountState: AccountState,
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-    const data = Buffer.alloc(defaultAccountStateInstructionData.span);
-    defaultAccountStateInstructionData.encode(
-        {
-            instruction: TokenInstruction.DefaultAccountStateExtension,
-            defaultAccountStateInstruction: DefaultAccountStateInstruction.Initialize,
-            accountState,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/**
- * Construct an UpdateDefaultAccountState instruction
- *
- * @param mint         Mint to update
- * @param accountState    Default account state to set on all accounts
- * @param freezeAuthority       The mint's freeze authority
- * @param signers         The signer account(s) for a multisig
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createUpdateDefaultAccountStateInstruction(
-    mint: PublicKey,
-    accountState: AccountState,
-    freezeAuthority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], freezeAuthority, multiSigners);
-    const data = Buffer.alloc(defaultAccountStateInstructionData.span);
-    defaultAccountStateInstructionData.encode(
-        {
-            instruction: TokenInstruction.DefaultAccountStateExtension,
-            defaultAccountStateInstruction: DefaultAccountStateInstruction.Update,
-            accountState,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/extensions/defaultAccountState/state.ts b/token/js/src/extensions/defaultAccountState/state.ts
deleted file mode 100644
index bd6cb0950f6..00000000000
--- a/token/js/src/extensions/defaultAccountState/state.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountState } from '../../state/account.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** DefaultAccountState as stored by the program */
-export interface DefaultAccountState {
-    /** Default AccountState in which new accounts are initialized */
-    state: AccountState;
-}
-
-/** Buffer layout for de/serializing a transfer fee config extension */
-export const DefaultAccountStateLayout = struct<DefaultAccountState>([u8('state')]);
-
-export const DEFAULT_ACCOUNT_STATE_SIZE = DefaultAccountStateLayout.span;
-
-export function getDefaultAccountState(mint: Mint): DefaultAccountState | null {
-    const extensionData = getExtensionData(ExtensionType.DefaultAccountState, mint.tlvData);
-    if (extensionData !== null) {
-        return DefaultAccountStateLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/extensionType.ts b/token/js/src/extensions/extensionType.ts
deleted file mode 100644
index 2eadd1c973e..00000000000
--- a/token/js/src/extensions/extensionType.ts
+++ /dev/null
@@ -1,304 +0,0 @@
-import type { AccountInfo, PublicKey } from '@solana/web3.js';
-
-import { ACCOUNT_SIZE } from '../state/account.js';
-import type { Mint } from '../state/mint.js';
-import { MINT_SIZE, unpackMint } from '../state/mint.js';
-import { MULTISIG_SIZE } from '../state/multisig.js';
-import { ACCOUNT_TYPE_SIZE } from './accountType.js';
-import { CPI_GUARD_SIZE } from './cpiGuard/index.js';
-import { DEFAULT_ACCOUNT_STATE_SIZE } from './defaultAccountState/index.js';
-import { TOKEN_GROUP_SIZE, TOKEN_GROUP_MEMBER_SIZE } from './tokenGroup/index.js';
-import { GROUP_MEMBER_POINTER_SIZE } from './groupMemberPointer/state.js';
-import { GROUP_POINTER_SIZE } from './groupPointer/state.js';
-import { IMMUTABLE_OWNER_SIZE } from './immutableOwner.js';
-import { INTEREST_BEARING_MINT_CONFIG_STATE_SIZE } from './interestBearingMint/state.js';
-import { MEMO_TRANSFER_SIZE } from './memoTransfer/index.js';
-import { METADATA_POINTER_SIZE } from './metadataPointer/state.js';
-import { MINT_CLOSE_AUTHORITY_SIZE } from './mintCloseAuthority.js';
-import { NON_TRANSFERABLE_SIZE, NON_TRANSFERABLE_ACCOUNT_SIZE } from './nonTransferable.js';
-import { PERMANENT_DELEGATE_SIZE } from './permanentDelegate.js';
-import { TRANSFER_FEE_AMOUNT_SIZE, TRANSFER_FEE_CONFIG_SIZE } from './transferFee/index.js';
-import { TRANSFER_HOOK_ACCOUNT_SIZE, TRANSFER_HOOK_SIZE } from './transferHook/index.js';
-import { TOKEN_2022_PROGRAM_ID } from '../constants.js';
-
-// Sequence from https://github.com/solana-labs/solana-program-library/blob/master/token/program-2022/src/extension/mod.rs#L903
-export enum ExtensionType {
-    Uninitialized,
-    TransferFeeConfig,
-    TransferFeeAmount,
-    MintCloseAuthority,
-    ConfidentialTransferMint,
-    ConfidentialTransferAccount,
-    DefaultAccountState,
-    ImmutableOwner,
-    MemoTransfer,
-    NonTransferable,
-    InterestBearingConfig,
-    CpiGuard,
-    PermanentDelegate,
-    NonTransferableAccount,
-    TransferHook,
-    TransferHookAccount,
-    // ConfidentialTransferFee, // Not implemented yet
-    // ConfidentialTransferFeeAmount, // Not implemented yet
-    MetadataPointer = 18, // Remove number once above extensions implemented
-    TokenMetadata = 19, // Remove number once above extensions implemented
-    GroupPointer = 20,
-    TokenGroup = 21,
-    GroupMemberPointer = 22,
-    TokenGroupMember = 23,
-}
-
-export const TYPE_SIZE = 2;
-export const LENGTH_SIZE = 2;
-
-function addTypeAndLengthToLen(len: number): number {
-    return len + TYPE_SIZE + LENGTH_SIZE;
-}
-
-function isVariableLengthExtension(e: ExtensionType): boolean {
-    switch (e) {
-        case ExtensionType.TokenMetadata:
-            return true;
-        default:
-            return false;
-    }
-}
-
-// NOTE: All of these should eventually use their type's Span instead of these
-// constants.  This is provided for at least creation to work.
-export function getTypeLen(e: ExtensionType): number {
-    switch (e) {
-        case ExtensionType.Uninitialized:
-            return 0;
-        case ExtensionType.TransferFeeConfig:
-            return TRANSFER_FEE_CONFIG_SIZE;
-        case ExtensionType.TransferFeeAmount:
-            return TRANSFER_FEE_AMOUNT_SIZE;
-        case ExtensionType.MintCloseAuthority:
-            return MINT_CLOSE_AUTHORITY_SIZE;
-        case ExtensionType.ConfidentialTransferMint:
-            return 65;
-        case ExtensionType.ConfidentialTransferAccount:
-            return 295;
-        case ExtensionType.CpiGuard:
-            return CPI_GUARD_SIZE;
-        case ExtensionType.DefaultAccountState:
-            return DEFAULT_ACCOUNT_STATE_SIZE;
-        case ExtensionType.ImmutableOwner:
-            return IMMUTABLE_OWNER_SIZE;
-        case ExtensionType.MemoTransfer:
-            return MEMO_TRANSFER_SIZE;
-        case ExtensionType.MetadataPointer:
-            return METADATA_POINTER_SIZE;
-        case ExtensionType.NonTransferable:
-            return NON_TRANSFERABLE_SIZE;
-        case ExtensionType.InterestBearingConfig:
-            return INTEREST_BEARING_MINT_CONFIG_STATE_SIZE;
-        case ExtensionType.PermanentDelegate:
-            return PERMANENT_DELEGATE_SIZE;
-        case ExtensionType.NonTransferableAccount:
-            return NON_TRANSFERABLE_ACCOUNT_SIZE;
-        case ExtensionType.TransferHook:
-            return TRANSFER_HOOK_SIZE;
-        case ExtensionType.TransferHookAccount:
-            return TRANSFER_HOOK_ACCOUNT_SIZE;
-        case ExtensionType.GroupPointer:
-            return GROUP_POINTER_SIZE;
-        case ExtensionType.GroupMemberPointer:
-            return GROUP_MEMBER_POINTER_SIZE;
-        case ExtensionType.TokenGroup:
-            return TOKEN_GROUP_SIZE;
-        case ExtensionType.TokenGroupMember:
-            return TOKEN_GROUP_MEMBER_SIZE;
-        case ExtensionType.TokenMetadata:
-            throw Error(`Cannot get type length for variable extension type: ${e}`);
-        default:
-            throw Error(`Unknown extension type: ${e}`);
-    }
-}
-
-export function isMintExtension(e: ExtensionType): boolean {
-    switch (e) {
-        case ExtensionType.TransferFeeConfig:
-        case ExtensionType.MintCloseAuthority:
-        case ExtensionType.ConfidentialTransferMint:
-        case ExtensionType.DefaultAccountState:
-        case ExtensionType.NonTransferable:
-        case ExtensionType.InterestBearingConfig:
-        case ExtensionType.PermanentDelegate:
-        case ExtensionType.TransferHook:
-        case ExtensionType.MetadataPointer:
-        case ExtensionType.TokenMetadata:
-        case ExtensionType.GroupPointer:
-        case ExtensionType.GroupMemberPointer:
-        case ExtensionType.TokenGroup:
-        case ExtensionType.TokenGroupMember:
-            return true;
-        case ExtensionType.Uninitialized:
-        case ExtensionType.TransferFeeAmount:
-        case ExtensionType.ConfidentialTransferAccount:
-        case ExtensionType.ImmutableOwner:
-        case ExtensionType.MemoTransfer:
-        case ExtensionType.CpiGuard:
-        case ExtensionType.NonTransferableAccount:
-        case ExtensionType.TransferHookAccount:
-            return false;
-        default:
-            throw Error(`Unknown extension type: ${e}`);
-    }
-}
-
-export function isAccountExtension(e: ExtensionType): boolean {
-    switch (e) {
-        case ExtensionType.TransferFeeAmount:
-        case ExtensionType.ConfidentialTransferAccount:
-        case ExtensionType.ImmutableOwner:
-        case ExtensionType.MemoTransfer:
-        case ExtensionType.CpiGuard:
-        case ExtensionType.NonTransferableAccount:
-        case ExtensionType.TransferHookAccount:
-            return true;
-        case ExtensionType.Uninitialized:
-        case ExtensionType.TransferFeeConfig:
-        case ExtensionType.MintCloseAuthority:
-        case ExtensionType.ConfidentialTransferMint:
-        case ExtensionType.DefaultAccountState:
-        case ExtensionType.NonTransferable:
-        case ExtensionType.InterestBearingConfig:
-        case ExtensionType.PermanentDelegate:
-        case ExtensionType.TransferHook:
-        case ExtensionType.MetadataPointer:
-        case ExtensionType.TokenMetadata:
-        case ExtensionType.GroupPointer:
-        case ExtensionType.GroupMemberPointer:
-        case ExtensionType.TokenGroup:
-        case ExtensionType.TokenGroupMember:
-            return false;
-        default:
-            throw Error(`Unknown extension type: ${e}`);
-    }
-}
-
-export function getAccountTypeOfMintType(e: ExtensionType): ExtensionType {
-    switch (e) {
-        case ExtensionType.TransferFeeConfig:
-            return ExtensionType.TransferFeeAmount;
-        case ExtensionType.ConfidentialTransferMint:
-            return ExtensionType.ConfidentialTransferAccount;
-        case ExtensionType.NonTransferable:
-            return ExtensionType.NonTransferableAccount;
-        case ExtensionType.TransferHook:
-            return ExtensionType.TransferHookAccount;
-        case ExtensionType.TransferFeeAmount:
-        case ExtensionType.ConfidentialTransferAccount:
-        case ExtensionType.CpiGuard:
-        case ExtensionType.DefaultAccountState:
-        case ExtensionType.ImmutableOwner:
-        case ExtensionType.MemoTransfer:
-        case ExtensionType.MintCloseAuthority:
-        case ExtensionType.MetadataPointer:
-        case ExtensionType.TokenMetadata:
-        case ExtensionType.Uninitialized:
-        case ExtensionType.InterestBearingConfig:
-        case ExtensionType.PermanentDelegate:
-        case ExtensionType.NonTransferableAccount:
-        case ExtensionType.TransferHookAccount:
-        case ExtensionType.GroupPointer:
-        case ExtensionType.GroupMemberPointer:
-        case ExtensionType.TokenGroup:
-        case ExtensionType.TokenGroupMember:
-            return ExtensionType.Uninitialized;
-    }
-}
-
-function getLen(
-    extensionTypes: ExtensionType[],
-    baseSize: number,
-    variableLengthExtensions: { [E in ExtensionType]?: number } = {}
-): number {
-    if (extensionTypes.length === 0 && Object.keys(variableLengthExtensions).length === 0) {
-        return baseSize;
-    } else {
-        const accountLength =
-            ACCOUNT_SIZE +
-            ACCOUNT_TYPE_SIZE +
-            extensionTypes
-                .filter((element, i) => i === extensionTypes.indexOf(element))
-                .map((element) => addTypeAndLengthToLen(getTypeLen(element)))
-                .reduce((a, b) => a + b, 0) +
-            Object.entries(variableLengthExtensions)
-                .map(([extension, len]) => {
-                    if (!isVariableLengthExtension(Number(extension))) {
-                        throw Error(`Extension ${extension} is not variable length`);
-                    }
-                    return addTypeAndLengthToLen(len);
-                })
-                .reduce((a, b) => a + b, 0);
-        if (accountLength === MULTISIG_SIZE) {
-            return accountLength + TYPE_SIZE;
-        } else {
-            return accountLength;
-        }
-    }
-}
-
-export function getMintLen(
-    extensionTypes: ExtensionType[],
-    variableLengthExtensions: { [E in ExtensionType]?: number } = {}
-): number {
-    return getLen(extensionTypes, MINT_SIZE, variableLengthExtensions);
-}
-
-export function getAccountLen(extensionTypes: ExtensionType[]): number {
-    // There are currently no variable length extensions for accounts
-    return getLen(extensionTypes, ACCOUNT_SIZE);
-}
-
-export function getExtensionData(extension: ExtensionType, tlvData: Buffer): Buffer | null {
-    let extensionTypeIndex = 0;
-    while (addTypeAndLengthToLen(extensionTypeIndex) <= tlvData.length) {
-        const entryType = tlvData.readUInt16LE(extensionTypeIndex);
-        const entryLength = tlvData.readUInt16LE(extensionTypeIndex + TYPE_SIZE);
-        const typeIndex = addTypeAndLengthToLen(extensionTypeIndex);
-        if (entryType == extension) {
-            return tlvData.slice(typeIndex, typeIndex + entryLength);
-        }
-        extensionTypeIndex = typeIndex + entryLength;
-    }
-    return null;
-}
-
-export function getExtensionTypes(tlvData: Buffer): ExtensionType[] {
-    const extensionTypes = [];
-    let extensionTypeIndex = 0;
-    while (extensionTypeIndex < tlvData.length) {
-        const entryType = tlvData.readUInt16LE(extensionTypeIndex);
-        extensionTypes.push(entryType);
-        const entryLength = tlvData.readUInt16LE(extensionTypeIndex + TYPE_SIZE);
-        extensionTypeIndex += addTypeAndLengthToLen(entryLength);
-    }
-    return extensionTypes;
-}
-
-export function getAccountLenForMint(mint: Mint): number {
-    const extensionTypes = getExtensionTypes(mint.tlvData);
-    const accountExtensions = extensionTypes.map(getAccountTypeOfMintType);
-    return getAccountLen(accountExtensions);
-}
-
-export function getNewAccountLenForExtensionLen(
-    info: AccountInfo<Buffer>,
-    address: PublicKey,
-    extensionType: ExtensionType,
-    extensionLen: number,
-    programId = TOKEN_2022_PROGRAM_ID
-): number {
-    const mint = unpackMint(address, info, programId);
-    const extensionData = getExtensionData(extensionType, mint.tlvData);
-
-    const currentExtensionLen = extensionData ? addTypeAndLengthToLen(extensionData.length) : 0;
-    const newExtensionLen = addTypeAndLengthToLen(extensionLen);
-
-    return info.data.length + newExtensionLen - currentExtensionLen;
-}
diff --git a/token/js/src/extensions/groupMemberPointer/index.ts b/token/js/src/extensions/groupMemberPointer/index.ts
deleted file mode 100644
index 8bf2a08d1f9..00000000000
--- a/token/js/src/extensions/groupMemberPointer/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/groupMemberPointer/instructions.ts b/token/js/src/extensions/groupMemberPointer/instructions.ts
deleted file mode 100644
index fa389cff0b6..00000000000
--- a/token/js/src/extensions/groupMemberPointer/instructions.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { Signer } from '@solana/web3.js';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID, programSupportsExtensions } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import { addSigners } from '../../instructions/internal.js';
-
-export enum GroupMemberPointerInstruction {
-    Initialize = 0,
-    Update = 1,
-}
-
-export const initializeGroupMemberPointerData = struct<{
-    instruction: TokenInstruction.GroupMemberPointerExtension;
-    groupMemberPointerInstruction: number;
-    authority: PublicKey;
-    memberAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('groupMemberPointerInstruction'),
-    publicKey('authority'),
-    publicKey('memberAddress'),
-]);
-
-/**
- * Construct an Initialize GroupMemberPointer instruction
- *
- * @param mint            Token mint account
- * @param authority       Optional Authority that can set the member address
- * @param memberAddress   Optional Account address that holds the member
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeGroupMemberPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey | null,
-    memberAddress: PublicKey | null,
-    programId: PublicKey = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeGroupMemberPointerData.span);
-    initializeGroupMemberPointerData.encode(
-        {
-            instruction: TokenInstruction.GroupMemberPointerExtension,
-            groupMemberPointerInstruction: GroupMemberPointerInstruction.Initialize,
-            authority: authority ?? PublicKey.default,
-            memberAddress: memberAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
-
-export const updateGroupMemberPointerData = struct<{
-    instruction: TokenInstruction.GroupMemberPointerExtension;
-    groupMemberPointerInstruction: number;
-    memberAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('groupMemberPointerInstruction'),
-    publicKey('memberAddress'),
-]);
-
-export function createUpdateGroupMemberPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    memberAddress: PublicKey | null,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId: PublicKey = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], authority, multiSigners);
-
-    const data = Buffer.alloc(updateGroupMemberPointerData.span);
-    updateGroupMemberPointerData.encode(
-        {
-            instruction: TokenInstruction.GroupMemberPointerExtension,
-            groupMemberPointerInstruction: GroupMemberPointerInstruction.Update,
-            memberAddress: memberAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
diff --git a/token/js/src/extensions/groupMemberPointer/state.ts b/token/js/src/extensions/groupMemberPointer/state.ts
deleted file mode 100644
index ceda2073010..00000000000
--- a/token/js/src/extensions/groupMemberPointer/state.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** GroupMemberPointer as stored by the program */
-export interface GroupMemberPointer {
-    /** Optional authority that can set the member address */
-    authority: PublicKey | null;
-    /** Optional account address that holds the member */
-    memberAddress: PublicKey | null;
-}
-
-/** Buffer layout for de/serializing a Group Pointer extension */
-export const GroupMemberPointerLayout = struct<{ authority: PublicKey; memberAddress: PublicKey }>([
-    publicKey('authority'),
-    publicKey('memberAddress'),
-]);
-
-export const GROUP_MEMBER_POINTER_SIZE = GroupMemberPointerLayout.span;
-
-export function getGroupMemberPointerState(mint: Mint): Partial<GroupMemberPointer> | null {
-    const extensionData = getExtensionData(ExtensionType.GroupMemberPointer, mint.tlvData);
-    if (extensionData !== null) {
-        const { authority, memberAddress } = GroupMemberPointerLayout.decode(extensionData);
-
-        // Explicitly set None/Zero keys to null
-        return {
-            authority: authority.equals(PublicKey.default) ? null : authority,
-            memberAddress: memberAddress.equals(PublicKey.default) ? null : memberAddress,
-        };
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/groupPointer/index.ts b/token/js/src/extensions/groupPointer/index.ts
deleted file mode 100644
index 8bf2a08d1f9..00000000000
--- a/token/js/src/extensions/groupPointer/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/groupPointer/instructions.ts b/token/js/src/extensions/groupPointer/instructions.ts
deleted file mode 100644
index e48b7d8ae6e..00000000000
--- a/token/js/src/extensions/groupPointer/instructions.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { Signer } from '@solana/web3.js';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID, programSupportsExtensions } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import { addSigners } from '../../instructions/internal.js';
-
-export enum GroupPointerInstruction {
-    Initialize = 0,
-    Update = 1,
-}
-
-export const initializeGroupPointerData = struct<{
-    instruction: TokenInstruction.GroupPointerExtension;
-    groupPointerInstruction: number;
-    authority: PublicKey;
-    groupAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('groupPointerInstruction'),
-    publicKey('authority'),
-    publicKey('groupAddress'),
-]);
-
-/**
- * Construct an Initialize GroupPointer instruction
- *
- * @param mint            Token mint account
- * @param authority       Optional Authority that can set the group address
- * @param groupAddress    Optional Account address that holds the group
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeGroupPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey | null,
-    groupAddress: PublicKey | null,
-    programId: PublicKey = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeGroupPointerData.span);
-    initializeGroupPointerData.encode(
-        {
-            instruction: TokenInstruction.GroupPointerExtension,
-            groupPointerInstruction: GroupPointerInstruction.Initialize,
-            authority: authority ?? PublicKey.default,
-            groupAddress: groupAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
-
-export const updateGroupPointerData = struct<{
-    instruction: TokenInstruction.GroupPointerExtension;
-    groupPointerInstruction: number;
-    groupAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('groupPointerInstruction'),
-    publicKey('groupAddress'),
-]);
-
-export function createUpdateGroupPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    groupAddress: PublicKey | null,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId: PublicKey = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], authority, multiSigners);
-
-    const data = Buffer.alloc(updateGroupPointerData.span);
-    updateGroupPointerData.encode(
-        {
-            instruction: TokenInstruction.GroupPointerExtension,
-            groupPointerInstruction: GroupPointerInstruction.Update,
-            groupAddress: groupAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
diff --git a/token/js/src/extensions/groupPointer/state.ts b/token/js/src/extensions/groupPointer/state.ts
deleted file mode 100644
index 1f522612cc6..00000000000
--- a/token/js/src/extensions/groupPointer/state.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** GroupPointer as stored by the program */
-export interface GroupPointer {
-    /** Optional authority that can set the group address */
-    authority: PublicKey | null;
-    /** Optional account address that holds the group */
-    groupAddress: PublicKey | null;
-}
-
-/** Buffer layout for de/serializing a GroupPointer extension */
-export const GroupPointerLayout = struct<{ authority: PublicKey; groupAddress: PublicKey }>([
-    publicKey('authority'),
-    publicKey('groupAddress'),
-]);
-
-export const GROUP_POINTER_SIZE = GroupPointerLayout.span;
-
-export function getGroupPointerState(mint: Mint): Partial<GroupPointer> | null {
-    const extensionData = getExtensionData(ExtensionType.GroupPointer, mint.tlvData);
-    if (extensionData !== null) {
-        const { authority, groupAddress } = GroupPointerLayout.decode(extensionData);
-
-        // Explicitly set None/Zero keys to null
-        return {
-            authority: authority.equals(PublicKey.default) ? null : authority,
-            groupAddress: groupAddress.equals(PublicKey.default) ? null : groupAddress,
-        };
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/immutableOwner.ts b/token/js/src/extensions/immutableOwner.ts
deleted file mode 100644
index 72a1ce25245..00000000000
--- a/token/js/src/extensions/immutableOwner.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import type { Account } from '../state/account.js';
-import { ExtensionType, getExtensionData } from './extensionType.js';
-
-/** ImmutableOwner as stored by the program */
-export interface ImmutableOwner {} // eslint-disable-line
-
-/** Buffer layout for de/serializing an account */
-export const ImmutableOwnerLayout = struct<ImmutableOwner>([]);
-
-export const IMMUTABLE_OWNER_SIZE = ImmutableOwnerLayout.span;
-
-export function getImmutableOwner(account: Account): ImmutableOwner | null {
-    const extensionData = getExtensionData(ExtensionType.ImmutableOwner, account.tlvData);
-    if (extensionData !== null) {
-        return ImmutableOwnerLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/index.ts b/token/js/src/extensions/index.ts
deleted file mode 100644
index cfa585b9482..00000000000
--- a/token/js/src/extensions/index.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-export * from './accountType.js';
-export * from './cpiGuard/index.js';
-export * from './defaultAccountState/index.js';
-export * from './extensionType.js';
-export * from './groupMemberPointer/index.js';
-export * from './groupPointer/index.js';
-export * from './immutableOwner.js';
-export * from './interestBearingMint/index.js';
-export * from './memoTransfer/index.js';
-export * from './metadataPointer/index.js';
-export * from './tokenGroup/index.js';
-export * from './tokenMetadata/index.js';
-export * from './mintCloseAuthority.js';
-export * from './nonTransferable.js';
-export * from './transferFee/index.js';
-export * from './permanentDelegate.js';
-export * from './transferHook/index.js';
diff --git a/token/js/src/extensions/interestBearingMint/actions.ts b/token/js/src/extensions/interestBearingMint/actions.ts
deleted file mode 100644
index a60b2f9677b..00000000000
--- a/token/js/src/extensions/interestBearingMint/actions.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { createInitializeMintInstruction } from '../../instructions/initializeMint.js';
-import { ExtensionType, getMintLen } from '../extensionType.js';
-import {
-    createInitializeInterestBearingMintInstruction,
-    createUpdateRateInterestBearingMintInstruction,
-} from './instructions.js';
-
-/**
- * Initialize an interest bearing account on a mint
- *
- * @param connection      Connection to use
- * @param payer           Payer of the transaction fees
- * @param mintAuthority   Account or multisig that will control minting
- * @param freezeAuthority Optional account or multisig that can freeze token accounts
- * @param rateAuthority   The public key for the account that can update the rate
- * @param rate            The initial interest rate
- * @param decimals        Location of the decimal place
- * @param keypair         Optional keypair, defaulting to a new random one
- * @param confirmOptions  Options for confirming the transaction
- * @param programId       SPL Token program account
- *
- * @return Public key of the mint
- */
-export async function createInterestBearingMint(
-    connection: Connection,
-    payer: Signer,
-    mintAuthority: PublicKey,
-    freezeAuthority: PublicKey,
-    rateAuthority: PublicKey,
-    rate: number,
-    decimals: number,
-    keypair = Keypair.generate(),
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<PublicKey> {
-    const mintLen = getMintLen([ExtensionType.InterestBearingConfig]);
-    const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-    const transaction = new Transaction().add(
-        SystemProgram.createAccount({
-            fromPubkey: payer.publicKey,
-            newAccountPubkey: keypair.publicKey,
-            space: mintLen,
-            lamports,
-            programId,
-        }),
-        createInitializeInterestBearingMintInstruction(keypair.publicKey, rateAuthority, rate, programId),
-        createInitializeMintInstruction(keypair.publicKey, decimals, mintAuthority, freezeAuthority, programId)
-    );
-    await sendAndConfirmTransaction(connection, transaction, [payer, keypair], confirmOptions);
-    return keypair.publicKey;
-}
-
-/**
- * Update the interest rate of an interest bearing account
- *
- * @param connection      Connection to use
- * @param payer           Payer of the transaction fees
- * @param mint            Public key of the mint
- * @param rateAuthority   The public key for the account that can update the rate
- * @param rate            The initial interest rate
- * @param multiSigners    Signing accounts if `owner` is a multisig
- * @param confirmOptions  Options for confirming the transaction
- * @param programId       SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function updateRateInterestBearingMint(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    rateAuthority: Signer,
-    rate: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<string> {
-    const [rateAuthorityPublicKey, signers] = getSigners(rateAuthority, multiSigners);
-    const transaction = new Transaction().add(
-        createUpdateRateInterestBearingMintInstruction(mint, rateAuthorityPublicKey, rate, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, rateAuthority, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/interestBearingMint/index.ts b/token/js/src/extensions/interestBearingMint/index.ts
deleted file mode 100644
index 5e28fd6b10a..00000000000
--- a/token/js/src/extensions/interestBearingMint/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/interestBearingMint/instructions.ts b/token/js/src/extensions/interestBearingMint/instructions.ts
deleted file mode 100644
index 34b3eef52db..00000000000
--- a/token/js/src/extensions/interestBearingMint/instructions.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import { s16, struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-
-export enum InterestBearingMintInstruction {
-    Initialize = 0,
-    UpdateRate = 1,
-}
-
-export interface InterestBearingMintInitializeInstructionData {
-    instruction: TokenInstruction.InterestBearingMintExtension;
-    interestBearingMintInstruction: InterestBearingMintInstruction.Initialize;
-    rateAuthority: PublicKey;
-    rate: number;
-}
-
-export interface InterestBearingMintUpdateRateInstructionData {
-    instruction: TokenInstruction.InterestBearingMintExtension;
-    interestBearingMintInstruction: InterestBearingMintInstruction.UpdateRate;
-    rate: number;
-}
-
-export const interestBearingMintInitializeInstructionData = struct<InterestBearingMintInitializeInstructionData>([
-    u8('instruction'),
-    u8('interestBearingMintInstruction'),
-    // TODO: Make this an optional public key
-    publicKey('rateAuthority'),
-    s16('rate'),
-]);
-
-export const interestBearingMintUpdateRateInstructionData = struct<InterestBearingMintUpdateRateInstructionData>([
-    u8('instruction'),
-    u8('interestBearingMintInstruction'),
-    s16('rate'),
-]);
-
-/**
- * Construct an InitializeInterestBearingMint instruction
- *
- * @param mint           Mint to initialize
- * @param rateAuthority  The public key for the account that can update the rate
- * @param rate           The initial interest rate
- * @param programId      SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeInterestBearingMintInstruction(
-    mint: PublicKey,
-    rateAuthority: PublicKey,
-    rate: number,
-    programId = TOKEN_2022_PROGRAM_ID
-) {
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-    const data = Buffer.alloc(interestBearingMintInitializeInstructionData.span);
-    interestBearingMintInitializeInstructionData.encode(
-        {
-            instruction: TokenInstruction.InterestBearingMintExtension,
-            interestBearingMintInstruction: InterestBearingMintInstruction.Initialize,
-            rateAuthority,
-            rate,
-        },
-        data
-    );
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/**
- * Construct an UpdateRateInterestBearingMint instruction
- *
- * @param mint           Mint to initialize
- * @param rateAuthority  The public key for the account that can update the rate
- * @param rate           The updated interest rate
- * @param multiSigners   Signing accounts if `rateAuthority` is a multisig
- * @param programId      SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createUpdateRateInterestBearingMintInstruction(
-    mint: PublicKey,
-    rateAuthority: PublicKey,
-    rate: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-) {
-    const keys = addSigners(
-        [
-            { pubkey: mint, isSigner: false, isWritable: true },
-            { pubkey: rateAuthority, isSigner: !multiSigners.length, isWritable: false },
-        ],
-        rateAuthority,
-        multiSigners
-    );
-    const data = Buffer.alloc(interestBearingMintUpdateRateInstructionData.span);
-    interestBearingMintUpdateRateInstructionData.encode(
-        {
-            instruction: TokenInstruction.InterestBearingMintExtension,
-            interestBearingMintInstruction: InterestBearingMintInstruction.UpdateRate,
-            rate,
-        },
-        data
-    );
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/extensions/interestBearingMint/state.ts b/token/js/src/extensions/interestBearingMint/state.ts
deleted file mode 100644
index b10cb3ab866..00000000000
--- a/token/js/src/extensions/interestBearingMint/state.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { ns64, s16, struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-export interface InterestBearingMintConfigState {
-    rateAuthority: PublicKey;
-    initializationTimestamp: bigint;
-    preUpdateAverageRate: number;
-    lastUpdateTimestamp: bigint;
-    currentRate: number;
-}
-
-export const InterestBearingMintConfigStateLayout = struct<InterestBearingMintConfigState>([
-    publicKey('rateAuthority'),
-    ns64('initializationTimestamp'),
-    s16('preUpdateAverageRate'),
-    ns64('lastUpdateTimestamp'),
-    s16('currentRate'),
-]);
-
-export const INTEREST_BEARING_MINT_CONFIG_STATE_SIZE = InterestBearingMintConfigStateLayout.span;
-
-export function getInterestBearingMintConfigState(mint: Mint): InterestBearingMintConfigState | null {
-    const extensionData = getExtensionData(ExtensionType.InterestBearingConfig, mint.tlvData);
-    if (extensionData !== null) {
-        return InterestBearingMintConfigStateLayout.decode(extensionData);
-    }
-    return null;
-}
diff --git a/token/js/src/extensions/memoTransfer/actions.ts b/token/js/src/extensions/memoTransfer/actions.ts
deleted file mode 100644
index 7a2dceff98b..00000000000
--- a/token/js/src/extensions/memoTransfer/actions.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import {
-    createDisableRequiredMemoTransfersInstruction,
-    createEnableRequiredMemoTransfersInstruction,
-} from './instructions.js';
-
-/**
- * Enable memo transfers on the given account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to modify
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function enableRequiredMemoTransfers(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    owner: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createEnableRequiredMemoTransfersInstruction(account, ownerPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Disable memo transfers on the given account
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param account        Account to modify
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function disableRequiredMemoTransfers(
-    connection: Connection,
-    payer: Signer,
-    account: PublicKey,
-    owner: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createDisableRequiredMemoTransfersInstruction(account, ownerPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/memoTransfer/index.ts b/token/js/src/extensions/memoTransfer/index.ts
deleted file mode 100644
index 5e28fd6b10a..00000000000
--- a/token/js/src/extensions/memoTransfer/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/memoTransfer/instructions.ts b/token/js/src/extensions/memoTransfer/instructions.ts
deleted file mode 100644
index 689b5761540..00000000000
--- a/token/js/src/extensions/memoTransfer/instructions.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-
-export enum MemoTransferInstruction {
-    Enable = 0,
-    Disable = 1,
-}
-
-/** TODO: docs */
-export interface MemoTransferInstructionData {
-    instruction: TokenInstruction.MemoTransferExtension;
-    memoTransferInstruction: MemoTransferInstruction;
-}
-
-/** TODO: docs */
-export const memoTransferInstructionData = struct<MemoTransferInstructionData>([
-    u8('instruction'),
-    u8('memoTransferInstruction'),
-]);
-
-/**
- * Construct an EnableRequiredMemoTransfers instruction
- *
- * @param account         Token account to update
- * @param authority       The account's owner/delegate
- * @param signers         The signer account(s)
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createEnableRequiredMemoTransfersInstruction(
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    return createMemoTransferInstruction(MemoTransferInstruction.Enable, account, authority, multiSigners, programId);
-}
-
-/**
- * Construct a DisableMemoTransfer instruction
- *
- * @param account         Token account to update
- * @param authority       The account's owner/delegate
- * @param signers         The signer account(s)
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createDisableRequiredMemoTransfersInstruction(
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    return createMemoTransferInstruction(MemoTransferInstruction.Disable, account, authority, multiSigners, programId);
-}
-
-function createMemoTransferInstruction(
-    memoTransferInstruction: MemoTransferInstruction,
-    account: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[],
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: account, isSigner: false, isWritable: true }], authority, multiSigners);
-    const data = Buffer.alloc(memoTransferInstructionData.span);
-    memoTransferInstructionData.encode(
-        {
-            instruction: TokenInstruction.MemoTransferExtension,
-            memoTransferInstruction,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/extensions/memoTransfer/state.ts b/token/js/src/extensions/memoTransfer/state.ts
deleted file mode 100644
index 0f8a726096a..00000000000
--- a/token/js/src/extensions/memoTransfer/state.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { bool } from '@solana/buffer-layout-utils';
-import type { Account } from '../../state/account.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** MemoTransfer as stored by the program */
-export interface MemoTransfer {
-    /** Require transfers into this account to be accompanied by a memo */
-    requireIncomingTransferMemos: boolean;
-}
-
-/** Buffer layout for de/serializing a memo transfer extension */
-export const MemoTransferLayout = struct<MemoTransfer>([bool('requireIncomingTransferMemos')]);
-
-export const MEMO_TRANSFER_SIZE = MemoTransferLayout.span;
-
-export function getMemoTransfer(account: Account): MemoTransfer | null {
-    const extensionData = getExtensionData(ExtensionType.MemoTransfer, account.tlvData);
-    if (extensionData !== null) {
-        return MemoTransferLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/metadataPointer/index.ts b/token/js/src/extensions/metadataPointer/index.ts
deleted file mode 100644
index 8bf2a08d1f9..00000000000
--- a/token/js/src/extensions/metadataPointer/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/metadataPointer/instructions.ts b/token/js/src/extensions/metadataPointer/instructions.ts
deleted file mode 100644
index 2d4b83541b4..00000000000
--- a/token/js/src/extensions/metadataPointer/instructions.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { Signer } from '@solana/web3.js';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_2022_PROGRAM_ID, programSupportsExtensions } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import { addSigners } from '../../instructions/internal.js';
-
-export enum MetadataPointerInstruction {
-    Initialize = 0,
-    Update = 1,
-}
-
-export const initializeMetadataPointerData = struct<{
-    instruction: TokenInstruction.MetadataPointerExtension;
-    metadataPointerInstruction: number;
-    authority: PublicKey;
-    metadataAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('metadataPointerInstruction'),
-    publicKey('authority'),
-    publicKey('metadataAddress'),
-]);
-
-/**
- * Construct an Initialize MetadataPointer instruction
- *
- * @param mint            Token mint account
- * @param authority       Optional Authority that can set the metadata address
- * @param metadataAddress Optional Account address that holds the metadata
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeMetadataPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey | null,
-    metadataAddress: PublicKey | null,
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeMetadataPointerData.span);
-    initializeMetadataPointerData.encode(
-        {
-            instruction: TokenInstruction.MetadataPointerExtension,
-            metadataPointerInstruction: MetadataPointerInstruction.Initialize,
-            authority: authority ?? PublicKey.default,
-            metadataAddress: metadataAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
-
-export const updateMetadataPointerData = struct<{
-    instruction: TokenInstruction.MetadataPointerExtension;
-    metadataPointerInstruction: number;
-    metadataAddress: PublicKey;
-}>([
-    // prettier-ignore
-    u8('instruction'),
-    u8('metadataPointerInstruction'),
-    publicKey('metadataAddress'),
-]);
-
-export function createUpdateMetadataPointerInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    metadataAddress: PublicKey | null,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId: PublicKey = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], authority, multiSigners);
-
-    const data = Buffer.alloc(updateMetadataPointerData.span);
-    updateMetadataPointerData.encode(
-        {
-            instruction: TokenInstruction.MetadataPointerExtension,
-            metadataPointerInstruction: MetadataPointerInstruction.Update,
-            metadataAddress: metadataAddress ?? PublicKey.default,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data: data });
-}
diff --git a/token/js/src/extensions/metadataPointer/state.ts b/token/js/src/extensions/metadataPointer/state.ts
deleted file mode 100644
index 75335fb1458..00000000000
--- a/token/js/src/extensions/metadataPointer/state.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-/** MetadataPointer as stored by the program */
-export interface MetadataPointer {
-    /** Optional authority that can set the metadata address */
-    authority: PublicKey | null;
-    /** Optional Account Address that holds the metadata */
-    metadataAddress: PublicKey | null;
-}
-
-/** Buffer layout for de/serializing a Metadata Pointer extension */
-export const MetadataPointerLayout = struct<{ authority: PublicKey; metadataAddress: PublicKey }>([
-    publicKey('authority'),
-    publicKey('metadataAddress'),
-]);
-
-export const METADATA_POINTER_SIZE = MetadataPointerLayout.span;
-
-export function getMetadataPointerState(mint: Mint): Partial<MetadataPointer> | null {
-    const extensionData = getExtensionData(ExtensionType.MetadataPointer, mint.tlvData);
-    if (extensionData !== null) {
-        const { authority, metadataAddress } = MetadataPointerLayout.decode(extensionData);
-
-        // Explicitly set None/Zero keys to null
-        return {
-            authority: authority.equals(PublicKey.default) ? null : authority,
-            metadataAddress: metadataAddress.equals(PublicKey.default) ? null : metadataAddress,
-        };
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/mintCloseAuthority.ts b/token/js/src/extensions/mintCloseAuthority.ts
deleted file mode 100644
index 5f09f451a65..00000000000
--- a/token/js/src/extensions/mintCloseAuthority.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../state/mint.js';
-import { ExtensionType, getExtensionData } from './extensionType.js';
-
-/** MintCloseAuthority as stored by the program */
-export interface MintCloseAuthority {
-    closeAuthority: PublicKey;
-}
-
-/** Buffer layout for de/serializing a mint */
-export const MintCloseAuthorityLayout = struct<MintCloseAuthority>([publicKey('closeAuthority')]);
-
-export const MINT_CLOSE_AUTHORITY_SIZE = MintCloseAuthorityLayout.span;
-
-export function getMintCloseAuthority(mint: Mint): MintCloseAuthority | null {
-    const extensionData = getExtensionData(ExtensionType.MintCloseAuthority, mint.tlvData);
-    if (extensionData !== null) {
-        return MintCloseAuthorityLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/nonTransferable.ts b/token/js/src/extensions/nonTransferable.ts
deleted file mode 100644
index af9e85168ac..00000000000
--- a/token/js/src/extensions/nonTransferable.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import type { Account } from '../state/account.js';
-import type { Mint } from '../state/mint.js';
-import { ExtensionType, getExtensionData } from './extensionType.js';
-
-/** Non-transferable mint state as stored by the program */
-export interface NonTransferable {} // eslint-disable-line
-
-/** Non-transferable token account state as stored by the program */
-export interface NonTransferableAccount {} // eslint-disable-line
-
-/** Buffer layout for de/serializing an account */
-export const NonTransferableLayout = struct<NonTransferable>([]);
-
-export const NON_TRANSFERABLE_SIZE = NonTransferableLayout.span;
-export const NON_TRANSFERABLE_ACCOUNT_SIZE = NonTransferableLayout.span;
-
-export function getNonTransferable(mint: Mint): NonTransferable | null {
-    const extensionData = getExtensionData(ExtensionType.NonTransferable, mint.tlvData);
-    if (extensionData !== null) {
-        return NonTransferableLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
-
-export function getNonTransferableAccount(account: Account): NonTransferableAccount | null {
-    const extensionData = getExtensionData(ExtensionType.NonTransferableAccount, account.tlvData);
-    if (extensionData !== null) {
-        return NonTransferableLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/permanentDelegate.ts b/token/js/src/extensions/permanentDelegate.ts
deleted file mode 100644
index 5b1fb1ef542..00000000000
--- a/token/js/src/extensions/permanentDelegate.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { struct } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { PublicKey } from '@solana/web3.js';
-import type { Mint } from '../state/mint.js';
-import { ExtensionType, getExtensionData } from './extensionType.js';
-
-/** PermanentDelegate as stored by the program */
-export interface PermanentDelegate {
-    delegate: PublicKey;
-}
-
-/** Buffer layout for de/serializing a mint */
-export const PermanentDelegateLayout = struct<PermanentDelegate>([publicKey('delegate')]);
-
-export const PERMANENT_DELEGATE_SIZE = PermanentDelegateLayout.span;
-
-export function getPermanentDelegate(mint: Mint): PermanentDelegate | null {
-    const extensionData = getExtensionData(ExtensionType.PermanentDelegate, mint.tlvData);
-    if (extensionData !== null) {
-        return PermanentDelegateLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/tokenGroup/actions.ts b/token/js/src/extensions/tokenGroup/actions.ts
deleted file mode 100644
index 553a7aa4404..00000000000
--- a/token/js/src/extensions/tokenGroup/actions.ts
+++ /dev/null
@@ -1,281 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createInitializeGroupInstruction,
-    createUpdateGroupMaxSizeInstruction,
-    createUpdateGroupAuthorityInstruction,
-    createInitializeMemberInstruction,
-    TOKEN_GROUP_SIZE,
-    TOKEN_GROUP_MEMBER_SIZE,
-} from '@solana/spl-token-group';
-
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { getSigners } from '../../actions/internal.js';
-
-/**
- * Initialize a new `Group`
- *
- * Assumes one has already initialized a mint for the group.
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fee
- * @param mint             Group mint
- * @param mintAuthority    Group mint authority
- * @param updateAuthority  Group update authority
- * @param maxSize          Maximum number of members in the group
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupInitializeGroup(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    updateAuthority: PublicKey | null,
-    maxSize: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createInitializeGroupInstruction({
-            programId,
-            group: mint,
-            mint,
-            mintAuthority: mintAuthorityPublicKey,
-            updateAuthority,
-            maxSize,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Initialize a new `Group` with rent transfer.
- *
- * Assumes one has already initialized a mint for the group.
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fee
- * @param mint             Group mint
- * @param mintAuthority    Group mint authority
- * @param updateAuthority  Group update authority
- * @param maxSize          Maximum number of members in the group
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupInitializeGroupWithRentTransfer(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    updateAuthority: PublicKey | null,
-    maxSize: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const lamports = await connection.getMinimumBalanceForRentExemption(TOKEN_GROUP_SIZE);
-
-    const transaction = new Transaction().add(
-        SystemProgram.transfer({
-            fromPubkey: payer.publicKey,
-            toPubkey: mint,
-            lamports,
-        }),
-        createInitializeGroupInstruction({
-            programId,
-            group: mint,
-            mint,
-            mintAuthority: mintAuthorityPublicKey,
-            updateAuthority,
-            maxSize,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Update the max size of a `Group`
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fee
- * @param mint             Group mint
- * @param updateAuthority  Group update authority
- * @param maxSize          Maximum number of members in the group
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupUpdateGroupMaxSize(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    maxSize: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateGroupMaxSizeInstruction({
-            programId,
-            group: mint,
-            updateAuthority: updateAuthorityPublicKey,
-            maxSize,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Update the authority of a `Group`
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fee
- * @param mint             Group mint
- * @param updateAuthority  Group update authority
- * @param newAuthority     New authority for the token group, or unset
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupUpdateGroupAuthority(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    newAuthority: PublicKey | null,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateGroupAuthorityInstruction({
-            programId,
-            group: mint,
-            currentAuthority: updateAuthorityPublicKey,
-            newAuthority,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Initialize a new `Member` of a `Group`
- *
- * Assumes the `Group` has already been initialized,
- * as well as the mint for the member.
- *
- * @param connection             Connection to use
- * @param payer                  Payer of the transaction fee
- * @param mint                   Member mint
- * @param mintAuthority          Member mint authority
- * @param group                  Group mint
- * @param groupUpdateAuthority   Group update authority
- * @param multiSigners           Signing accounts if `authority` is a multisig
- * @param confirmOptions         Options for confirming the transaction
- * @param programId              SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupMemberInitialize(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    group: PublicKey,
-    groupUpdateAuthority: PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createInitializeMemberInstruction({
-            programId,
-            member: mint,
-            memberMint: mint,
-            memberMintAuthority: mintAuthorityPublicKey,
-            group,
-            groupUpdateAuthority,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Initialize a new `Member` of a `Group` with rent transfer.
- *
- * Assumes the `Group` has already been initialized,
- * as well as the mint for the member.
- *
- * @param connection             Connection to use
- * @param payer                  Payer of the transaction fee
- * @param mint                   Member mint
- * @param mintAuthority          Member mint authority
- * @param group                  Group mint
- * @param groupUpdateAuthority   Group update authority
- * @param multiSigners           Signing accounts if `authority` is a multisig
- * @param confirmOptions         Options for confirming the transaction
- * @param programId              SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenGroupMemberInitializeWithRentTransfer(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    group: PublicKey,
-    groupUpdateAuthority: PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const lamports = await connection.getMinimumBalanceForRentExemption(TOKEN_GROUP_MEMBER_SIZE);
-
-    const transaction = new Transaction().add(
-        SystemProgram.transfer({
-            fromPubkey: payer.publicKey,
-            toPubkey: mint,
-            lamports,
-        }),
-        createInitializeMemberInstruction({
-            programId,
-            member: mint,
-            memberMint: mint,
-            memberMintAuthority: mintAuthorityPublicKey,
-            group,
-            groupUpdateAuthority,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/tokenGroup/index.ts b/token/js/src/extensions/tokenGroup/index.ts
deleted file mode 100644
index 898210857d0..00000000000
--- a/token/js/src/extensions/tokenGroup/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './actions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/tokenGroup/state.ts b/token/js/src/extensions/tokenGroup/state.ts
deleted file mode 100644
index a0822357c41..00000000000
--- a/token/js/src/extensions/tokenGroup/state.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { struct, u32 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import { PublicKey } from '@solana/web3.js';
-import {
-    unpackTokenGroup,
-    unpackTokenGroupMember,
-    type TokenGroup,
-    type TokenGroupMember,
-} from '@solana/spl-token-group';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-export { TOKEN_GROUP_SIZE, TOKEN_GROUP_MEMBER_SIZE } from '@solana/spl-token-group';
-
-export function getTokenGroupState(mint: Mint): Partial<TokenGroup> | null {
-    const extensionData = getExtensionData(ExtensionType.TokenGroup, mint.tlvData);
-    if (extensionData !== null) {
-        const { updateAuthority, mint, size, maxSize } = unpackTokenGroup(extensionData);
-
-        // Explicitly set None/Zero keys to null
-        return {
-            updateAuthority: updateAuthority?.equals(PublicKey.default) ? undefined : updateAuthority,
-            mint,
-            size,
-            maxSize,
-        };
-    } else {
-        return null;
-    }
-}
-
-export function getTokenGroupMemberState(mint: Mint): Partial<TokenGroupMember> | null {
-    const extensionData = getExtensionData(ExtensionType.TokenGroupMember, mint.tlvData);
-    if (extensionData !== null) {
-        const { mint, group, memberNumber } = unpackTokenGroupMember(extensionData);
-
-        return {
-            mint,
-            group,
-            memberNumber,
-        };
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/tokenMetadata/actions.ts b/token/js/src/extensions/tokenMetadata/actions.ts
deleted file mode 100644
index f37868638e6..00000000000
--- a/token/js/src/extensions/tokenMetadata/actions.ts
+++ /dev/null
@@ -1,382 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, SystemProgram, Transaction } from '@solana/web3.js';
-import type { Field, TokenMetadata } from '@solana/spl-token-metadata';
-import {
-    createInitializeInstruction,
-    createRemoveKeyInstruction,
-    createUpdateAuthorityInstruction,
-    createUpdateFieldInstruction,
-    pack,
-    unpack,
-} from '@solana/spl-token-metadata';
-
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { getSigners } from '../../actions/internal.js';
-import { ExtensionType, getExtensionData, getNewAccountLenForExtensionLen } from '../extensionType.js';
-import { updateTokenMetadata } from './state.js';
-import { TokenAccountNotFoundError } from '../../errors.js';
-import { unpackMint } from '../../state/index.js';
-
-async function getAdditionalRentForNewMetadata(
-    connection: Connection,
-    address: PublicKey,
-    tokenMetadata: TokenMetadata,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<number> {
-    const info = await connection.getAccountInfo(address);
-    if (!info) {
-        throw new TokenAccountNotFoundError();
-    }
-
-    const extensionLen = pack(tokenMetadata).length;
-    const newAccountLen = getNewAccountLenForExtensionLen(
-        info,
-        address,
-        ExtensionType.TokenMetadata,
-        extensionLen,
-        programId
-    );
-
-    if (newAccountLen <= info.data.length) {
-        return 0;
-    }
-
-    const newRentExemptMinimum = await connection.getMinimumBalanceForRentExemption(newAccountLen);
-
-    return newRentExemptMinimum - info.lamports;
-}
-
-async function getAdditionalRentForUpdatedMetadata(
-    connection: Connection,
-    address: PublicKey,
-    field: string | Field,
-    value: string,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<number> {
-    const info = await connection.getAccountInfo(address);
-    if (!info) {
-        throw new TokenAccountNotFoundError();
-    }
-
-    const mint = unpackMint(address, info, programId);
-    const extensionData = getExtensionData(ExtensionType.TokenMetadata, mint.tlvData);
-    if (extensionData === null) {
-        throw new Error('TokenMetadata extension not initialized');
-    }
-
-    const updatedTokenMetadata = updateTokenMetadata(unpack(extensionData), field, value);
-    const extensionLen = pack(updatedTokenMetadata).length;
-
-    const newAccountLen = getNewAccountLenForExtensionLen(
-        info,
-        address,
-        ExtensionType.TokenMetadata,
-        extensionLen,
-        programId
-    );
-
-    if (newAccountLen <= info.data.length) {
-        return 0;
-    }
-
-    const newRentExemptMinimum = await connection.getMinimumBalanceForRentExemption(newAccountLen);
-
-    return newRentExemptMinimum - info.lamports;
-}
-
-/**
- * Initializes a TLV entry with the basic token-metadata fields.
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param mintAuthority    Mint Authority
- * @param name             Longer name of token
- * @param symbol           Shortened symbol of token
- * @param uri              URI pointing to more metadata (image, video, etc)
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataInitialize(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    name: string,
-    symbol: string,
-    uri: string,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createInitializeInstruction({
-            programId,
-            metadata: mint,
-            updateAuthority,
-            mint,
-            mintAuthority: mintAuthorityPublicKey,
-            name,
-            symbol,
-            uri,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Initializes a TLV entry with the basic token-metadata fields,
- * Includes a transfer for any additional rent-exempt SOL if required.
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param mintAuthority    Mint Authority
- * @param name             Longer name of token
- * @param symbol           Shortened symbol of token
- * @param uri              URI pointing to more metadata (image, video, etc)
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataInitializeWithRentTransfer(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey,
-    mintAuthority: PublicKey | Signer,
-    name: string,
-    symbol: string,
-    uri: string,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [mintAuthorityPublicKey, signers] = getSigners(mintAuthority, multiSigners);
-
-    const transaction = new Transaction();
-
-    const lamports = await getAdditionalRentForNewMetadata(
-        connection,
-        mint,
-        {
-            updateAuthority,
-            mint,
-            name,
-            symbol,
-            uri,
-            additionalMetadata: [],
-        },
-        programId
-    );
-
-    if (lamports > 0) {
-        transaction.add(SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: mint, lamports: lamports }));
-    }
-
-    transaction.add(
-        createInitializeInstruction({
-            programId,
-            metadata: mint,
-            updateAuthority,
-            mint,
-            mintAuthority: mintAuthorityPublicKey,
-            name,
-            symbol,
-            uri,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Updates a field in a token-metadata account.
- * If the field does not exist on the account, it will be created.
- * If the field does exist, it will be overwritten.
- *
- * The field can be one of the required fields (name, symbol, URI), or a
- * totally new field denoted by a "key" string.
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param field            Field to update in the metadata
- * @param value            Value to write for the field
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataUpdateField(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    field: string | Field,
-    value: string,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateFieldInstruction({
-            programId,
-            metadata: mint,
-            updateAuthority: updateAuthorityPublicKey,
-            field,
-            value,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Updates a field in a token-metadata account.
- * If the field does not exist on the account, it will be created.
- * If the field does exist, it will be overwritten.
- * Includes a transfer for any additional rent-exempt SOL if required.
- *
- * The field can be one of the required fields (name, symbol, URI), or a
- * totally new field denoted by a "key" string.
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param field            Field to update in the metadata
- * @param value            Value to write for the field
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataUpdateFieldWithRentTransfer(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    field: string | Field,
-    value: string,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction();
-
-    const lamports = await getAdditionalRentForUpdatedMetadata(connection, mint, field, value, programId);
-
-    if (lamports > 0) {
-        transaction.add(SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: mint, lamports: lamports }));
-    }
-
-    transaction.add(
-        createUpdateFieldInstruction({
-            programId,
-            metadata: mint,
-            updateAuthority: updateAuthorityPublicKey,
-            field,
-            value,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Remove a field in a token-metadata account.
- *
- * The field can be one of the required fields (name, symbol, URI), or a
- * totally new field denoted by a "key" string.
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param key              Key to remove in the additional metadata portion
- * @param idempotent       When true, instruction will not error if the key does not exist
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataRemoveKey(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    key: string,
-    idempotent: boolean,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createRemoveKeyInstruction({
-            programId,
-            metadata: mint,
-            updateAuthority: updateAuthorityPublicKey,
-            key,
-            idempotent,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- *  Update authority
- *
- * @param connection       Connection to use
- * @param payer            Payer of the transaction fees
- * @param mint             Mint Account
- * @param updateAuthority  Update Authority
- * @param newAuthority     New authority for the token metadata, or unset
- * @param multiSigners     Signing accounts if `authority` is a multisig
- * @param confirmOptions   Options for confirming the transaction
- * @param programId        SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function tokenMetadataUpdateAuthority(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    updateAuthority: PublicKey | Signer,
-    newAuthority: PublicKey | null,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [updateAuthorityPublicKey, signers] = getSigners(updateAuthority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateAuthorityInstruction({
-            programId,
-            metadata: mint,
-            oldAuthority: updateAuthorityPublicKey,
-            newAuthority,
-        })
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/tokenMetadata/index.ts b/token/js/src/extensions/tokenMetadata/index.ts
deleted file mode 100644
index 898210857d0..00000000000
--- a/token/js/src/extensions/tokenMetadata/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './actions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/tokenMetadata/state.ts b/token/js/src/extensions/tokenMetadata/state.ts
deleted file mode 100644
index d124dcc7509..00000000000
--- a/token/js/src/extensions/tokenMetadata/state.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import type { Commitment, Connection } from '@solana/web3.js';
-import type { PublicKey } from '@solana/web3.js';
-import type { TokenMetadata } from '@solana/spl-token-metadata';
-import { Field, unpack } from '@solana/spl-token-metadata';
-
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-import { getMint } from '../../state/mint.js';
-
-const getNormalizedTokenMetadataField = (field: Field | string): string => {
-    if (field === Field.Name || field === 'Name' || field === 'name') {
-        return 'name';
-    }
-
-    if (field === Field.Symbol || field === 'Symbol' || field === 'symbol') {
-        return 'symbol';
-    }
-
-    if (field === Field.Uri || field === 'Uri' || field === 'uri') {
-        return 'uri';
-    }
-
-    return field;
-};
-
-export function updateTokenMetadata(current: TokenMetadata, key: Field | string, value: string): TokenMetadata {
-    const field = getNormalizedTokenMetadataField(key);
-
-    if (field === 'mint' || field === 'updateAuthority') {
-        throw new Error(`Cannot update ${field} via this instruction`);
-    }
-
-    // Handle updates to default keys
-    if (['name', 'symbol', 'uri'].includes(field)) {
-        return {
-            ...current,
-            [field]: value,
-        };
-    }
-
-    // Avoid mutating input, make a shallow copy
-    const additionalMetadata = [...current.additionalMetadata];
-
-    const i = current.additionalMetadata.findIndex((x) => x[0] === field);
-
-    if (i === -1) {
-        // Key was not found, add it
-        additionalMetadata.push([field, value]);
-    } else {
-        // Key was found, change value
-        additionalMetadata[i] = [field, value];
-    }
-
-    return {
-        ...current,
-        additionalMetadata,
-    };
-}
-
-/**
- * Retrieve Token Metadata Information
- *
- * @param connection Connection to use
- * @param address    Mint account
- * @param commitment Desired level of commitment for querying the state
- * @param programId  SPL Token program account
- *
- * @return Token Metadata information
- */
-export async function getTokenMetadata(
-    connection: Connection,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TokenMetadata | null> {
-    const mintInfo = await getMint(connection, address, commitment, programId);
-    const data = getExtensionData(ExtensionType.TokenMetadata, mintInfo.tlvData);
-
-    if (data === null) {
-        return null;
-    }
-
-    return unpack(data);
-}
diff --git a/token/js/src/extensions/transferFee/actions.ts b/token/js/src/extensions/transferFee/actions.ts
deleted file mode 100644
index aaa67577c90..00000000000
--- a/token/js/src/extensions/transferFee/actions.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-import type { ConfirmOptions, Connection, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import {
-    createHarvestWithheldTokensToMintInstruction,
-    createSetTransferFeeInstruction,
-    createTransferCheckedWithFeeInstruction,
-    createWithdrawWithheldTokensFromAccountsInstruction,
-    createWithdrawWithheldTokensFromMintInstruction,
-} from './instructions.js';
-
-/**
- * Transfer tokens from one account to another, asserting the transfer fee, token mint, and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param source         Source account
- * @param mint           Mint for the account
- * @param destination    Destination account
- * @param owner          Owner of the source account
- * @param amount         Number of tokens to transfer
- * @param decimals       Number of decimals in transfer amount
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function transferCheckedWithFee(
-    connection: Connection,
-    payer: Signer,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: Signer | PublicKey,
-    amount: bigint,
-    decimals: number,
-    fee: bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [ownerPublicKey, signers] = getSigners(owner, multiSigners);
-
-    const transaction = new Transaction().add(
-        createTransferCheckedWithFeeInstruction(
-            source,
-            mint,
-            destination,
-            ownerPublicKey,
-            amount,
-            decimals,
-            fee,
-            multiSigners,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Withdraw withheld tokens from mint
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           The token mint
- * @param destination    The destination account
- * @param authority      The mint's withdraw withheld tokens authority
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function withdrawWithheldTokensFromMint(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createWithdrawWithheldTokensFromMintInstruction(mint, destination, authorityPublicKey, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Withdraw withheld tokens from accounts
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           The token mint
- * @param destination    The destination account
- * @param authority      The mint's withdraw withheld tokens authority
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param sources        Source accounts from which to withdraw withheld fees
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function withdrawWithheldTokensFromAccounts(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[],
-    sources: PublicKey[],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createWithdrawWithheldTokensFromAccountsInstruction(
-            mint,
-            destination,
-            authorityPublicKey,
-            signers,
-            sources,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Harvest withheld tokens from accounts to the mint
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param mint           The token mint
- * @param sources        Source accounts from which to withdraw withheld fees
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function harvestWithheldTokensToMint(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    sources: PublicKey[],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const transaction = new Transaction().add(createHarvestWithheldTokensToMintInstruction(mint, sources, programId));
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-}
-
-/**
- * Update transfer fee and maximum fee
- *
- * @param connection                Connection to use
- * @param payer                     Payer of the transaction fees
- * @param mint                      The token mint
- * @param authority                 The authority of the transfer fee
- * @param multiSigners              Signing accounts if `owner` is a multisig
- * @param transferFeeBasisPoints    Amount of transfer collected as fees, expressed as basis points of the transfer amount
- * @param maximumFee                Maximum fee assessed on transfers
- * @param confirmOptions            Options for confirming the transaction
- * @param programId                 SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function setTransferFee(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[],
-    transferFeeBasisPoints: number,
-    maximumFee: bigint,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createSetTransferFeeInstruction(
-            mint,
-            authorityPublicKey,
-            signers,
-            transferFeeBasisPoints,
-            maximumFee,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/transferFee/index.ts b/token/js/src/extensions/transferFee/index.ts
deleted file mode 100644
index 5e28fd6b10a..00000000000
--- a/token/js/src/extensions/transferFee/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/transferFee/instructions.ts b/token/js/src/extensions/transferFee/instructions.ts
deleted file mode 100644
index f2a74d85a7c..00000000000
--- a/token/js/src/extensions/transferFee/instructions.ts
+++ /dev/null
@@ -1,983 +0,0 @@
-import { struct, u16, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, Signer, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-    TokenUnsupportedInstructionError,
-} from '../../errors.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import { COptionPublicKeyLayout } from '../../serialization.js';
-
-export enum TransferFeeInstruction {
-    InitializeTransferFeeConfig = 0,
-    TransferCheckedWithFee = 1,
-    WithdrawWithheldTokensFromMint = 2,
-    WithdrawWithheldTokensFromAccounts = 3,
-    HarvestWithheldTokensToMint = 4,
-    SetTransferFee = 5,
-}
-
-// InitializeTransferFeeConfig
-
-/** TODO: docs */
-export interface InitializeTransferFeeConfigInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.InitializeTransferFeeConfig;
-    transferFeeConfigAuthority: PublicKey | null;
-    withdrawWithheldAuthority: PublicKey | null;
-    transferFeeBasisPoints: number;
-    maximumFee: bigint;
-}
-
-/** TODO: docs */
-export const initializeTransferFeeConfigInstructionData = struct<InitializeTransferFeeConfigInstructionData>([
-    u8('instruction'),
-    u8('transferFeeInstruction'),
-    new COptionPublicKeyLayout('transferFeeConfigAuthority'),
-    new COptionPublicKeyLayout('withdrawWithheldAuthority'),
-    u16('transferFeeBasisPoints'),
-    u64('maximumFee'),
-]);
-
-/**
- * Construct an InitializeTransferFeeConfig instruction
- *
- * @param mint            Token mint account
- * @param transferFeeConfigAuthority  Optional authority that can update the fees
- * @param withdrawWithheldAuthority Optional authority that can withdraw fees
- * @param transferFeeBasisPoints Amount of transfer collected as fees, expressed as basis points of the transfer amount
- * @param maximumFee        Maximum fee assessed on transfers
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeTransferFeeConfigInstruction(
-    mint: PublicKey,
-    transferFeeConfigAuthority: PublicKey | null,
-    withdrawWithheldAuthority: PublicKey | null,
-    transferFeeBasisPoints: number,
-    maximumFee: bigint,
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeTransferFeeConfigInstructionData.span);
-    initializeTransferFeeConfigInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.InitializeTransferFeeConfig,
-            transferFeeConfigAuthority: transferFeeConfigAuthority,
-            withdrawWithheldAuthority: withdrawWithheldAuthority,
-            transferFeeBasisPoints: transferFeeBasisPoints,
-            maximumFee: maximumFee,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeTransferFeeConfig instruction */
-export interface DecodedInitializeTransferFeeConfigInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.InitializeTransferFeeConfig;
-        transferFeeConfigAuthority: PublicKey | null;
-        withdrawWithheldAuthority: PublicKey | null;
-        transferFeeBasisPoints: number;
-        maximumFee: bigint;
-    };
-}
-
-/**
- * Decode an InitializeTransferFeeConfig instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeTransferFeeConfigInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedInitializeTransferFeeConfigInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeTransferFeeConfigInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeInitializeTransferFeeConfigInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.InitializeTransferFeeConfig
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeTransferFeeConfig instruction */
-export interface DecodedInitializeTransferFeeConfigInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.InitializeTransferFeeConfig;
-        transferFeeConfigAuthority: PublicKey | null;
-        withdrawWithheldAuthority: PublicKey | null;
-        transferFeeBasisPoints: number;
-        maximumFee: bigint;
-    };
-}
-
-/**
- * Decode an InitializeTransferFeeConfig instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeTransferFeeConfigInstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedInitializeTransferFeeConfigInstructionUnchecked {
-    const {
-        instruction,
-        transferFeeInstruction,
-        transferFeeConfigAuthority,
-        withdrawWithheldAuthority,
-        transferFeeBasisPoints,
-        maximumFee,
-    } = initializeTransferFeeConfigInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-            transferFeeConfigAuthority,
-            withdrawWithheldAuthority,
-            transferFeeBasisPoints,
-            maximumFee,
-        },
-    };
-}
-
-// TransferCheckedWithFee
-export interface TransferCheckedWithFeeInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee;
-    amount: bigint;
-    decimals: number;
-    fee: bigint;
-}
-
-export const transferCheckedWithFeeInstructionData = struct<TransferCheckedWithFeeInstructionData>([
-    u8('instruction'),
-    u8('transferFeeInstruction'),
-    u64('amount'),
-    u8('decimals'),
-    u64('fee'),
-]);
-
-/**
- * Construct an TransferCheckedWithFee instruction
- *
- * @param source          The source account
- * @param mint            The token mint
- * @param destination     The destination account
- * @param authority       The source account's owner/delegate
- * @param signers         The signer account(s)
- * @param amount          The amount of tokens to transfer
- * @param decimals        The expected number of base 10 digits to the right of the decimal place
- * @param fee             The expected fee assesed on this transfer, calculated off-chain based on the transferFeeBasisPoints and maximumFee of the mint.
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createTransferCheckedWithFeeInstruction(
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    amount: bigint,
-    decimals: number,
-    fee: bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const data = Buffer.alloc(transferCheckedWithFeeInstructionData.span);
-    transferCheckedWithFeeInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee,
-            amount,
-            decimals,
-            fee,
-        },
-        data
-    );
-    const keys = addSigners(
-        [
-            { pubkey: source, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        multiSigners
-    );
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid TransferCheckedWithFee instruction */
-export interface DecodedTransferCheckedWithFeeInstruction {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta;
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee;
-        amount: bigint;
-        decimals: number;
-        fee: bigint;
-    };
-}
-
-/**
- * Decode a TransferCheckedWithFee instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeTransferCheckedWithFeeInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedTransferCheckedWithFeeInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== transferCheckedWithFeeInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { source, mint, destination, authority, signers },
-        data,
-    } = decodeTransferCheckedWithFeeInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.TransferCheckedWithFee
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            source,
-            mint,
-            destination,
-            authority,
-            signers: signers ? signers : null,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated TransferCheckedWithFees instruction */
-export interface DecodedTransferCheckedWithFeeInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta;
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | undefined;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee;
-        amount: bigint;
-        decimals: number;
-        fee: bigint;
-    };
-}
-
-/**
- * Decode a TransferCheckedWithFees instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeTransferCheckedWithFeeInstructionUnchecked({
-    programId,
-    keys: [source, mint, destination, authority, ...signers],
-    data,
-}: TransactionInstruction): DecodedTransferCheckedWithFeeInstructionUnchecked {
-    const { instruction, transferFeeInstruction, amount, decimals, fee } =
-        transferCheckedWithFeeInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            source,
-            mint,
-            destination,
-            authority,
-            signers,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-            amount,
-            decimals,
-            fee,
-        },
-    };
-}
-
-// WithdrawWithheldTokensFromMint
-export interface WithdrawWithheldTokensFromMintInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromMint;
-}
-
-export const withdrawWithheldTokensFromMintInstructionData = struct<WithdrawWithheldTokensFromMintInstructionData>([
-    u8('instruction'),
-    u8('transferFeeInstruction'),
-]);
-
-/**
- * Construct a WithdrawWithheldTokensFromMint instruction
- *
- * @param mint              The token mint
- * @param destination       The destination account
- * @param authority         The source account's owner/delegate
- * @param signers           The signer account(s)
- * @param programID         SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createWithdrawWithheldTokensFromMintInstruction(
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    signers: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const data = Buffer.alloc(withdrawWithheldTokensFromMintInstructionData.span);
-    withdrawWithheldTokensFromMintInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromMint,
-        },
-        data
-    );
-    const keys = addSigners(
-        [
-            { pubkey: mint, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        signers
-    );
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid WithdrawWithheldTokensFromMint instruction */
-export interface DecodedWithdrawWithheldTokensFromMintInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromMint;
-    };
-}
-
-/**
- * Decode a WithdrawWithheldTokensFromMint instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeWithdrawWithheldTokensFromMintInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedWithdrawWithheldTokensFromMintInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== withdrawWithheldTokensFromMintInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, destination, authority, signers },
-        data,
-    } = decodeWithdrawWithheldTokensFromMintInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.WithdrawWithheldTokensFromMint
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            signers: signers ? signers : null,
-        },
-        data,
-    };
-}
-
-/** A decoded, valid WithdrawWithheldTokensFromMint instruction */
-export interface DecodedWithdrawWithheldTokensFromMintInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromMint;
-    };
-}
-
-/**
- * Decode a WithdrawWithheldTokensFromMint instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeWithdrawWithheldTokensFromMintInstructionUnchecked({
-    programId,
-    keys: [mint, destination, authority, ...signers],
-    data,
-}: TransactionInstruction): DecodedWithdrawWithheldTokensFromMintInstructionUnchecked {
-    const { instruction, transferFeeInstruction } = withdrawWithheldTokensFromMintInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            signers,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-        },
-    };
-}
-
-// WithdrawWithheldTokensFromAccounts
-export interface WithdrawWithheldTokensFromAccountsInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromAccounts;
-    numTokenAccounts: number;
-}
-
-export const withdrawWithheldTokensFromAccountsInstructionData =
-    struct<WithdrawWithheldTokensFromAccountsInstructionData>([
-        u8('instruction'),
-        u8('transferFeeInstruction'),
-        u8('numTokenAccounts'),
-    ]);
-
-/**
- * Construct a WithdrawWithheldTokensFromAccounts instruction
- *
- * @param mint              The token mint
- * @param destination       The destination account
- * @param authority         The source account's owner/delegate
- * @param signers           The signer account(s)
- * @param sources           The source accounts to withdraw from
- * @param programID         SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createWithdrawWithheldTokensFromAccountsInstruction(
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    signers: (Signer | PublicKey)[],
-    sources: PublicKey[],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const data = Buffer.alloc(withdrawWithheldTokensFromAccountsInstructionData.span);
-    withdrawWithheldTokensFromAccountsInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromAccounts,
-            numTokenAccounts: sources.length,
-        },
-        data
-    );
-    const keys = addSigners(
-        [
-            { pubkey: mint, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        signers
-    );
-    for (const source of sources) {
-        keys.push({ pubkey: source, isSigner: false, isWritable: true });
-    }
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid WithdrawWithheldTokensFromAccounts instruction */
-export interface DecodedWithdrawWithheldTokensFromAccountsInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-        sources: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromAccounts;
-        numTokenAccounts: number;
-    };
-}
-
-/**
- * Decode a WithdrawWithheldTokensFromAccounts instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeWithdrawWithheldTokensFromAccountsInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedWithdrawWithheldTokensFromAccountsInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== withdrawWithheldTokensFromAccountsInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, destination, authority, signers, sources },
-        data,
-    } = decodeWithdrawWithheldTokensFromAccountsInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.WithdrawWithheldTokensFromAccounts
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            signers: signers ? signers : null,
-            sources: sources ? sources : null,
-        },
-        data,
-    };
-}
-
-/** A decoded, valid WithdrawWithheldTokensFromAccounts instruction */
-export interface DecodedWithdrawWithheldTokensFromAccountsInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-        sources: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.WithdrawWithheldTokensFromAccounts;
-        numTokenAccounts: number;
-    };
-}
-
-/**
- * Decode a WithdrawWithheldTokensFromAccount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeWithdrawWithheldTokensFromAccountsInstructionUnchecked({
-    programId,
-    keys,
-    data,
-}: TransactionInstruction): DecodedWithdrawWithheldTokensFromAccountsInstructionUnchecked {
-    const { instruction, transferFeeInstruction, numTokenAccounts } =
-        withdrawWithheldTokensFromAccountsInstructionData.decode(data);
-    const [mint, destination, authority, signers, sources] = [
-        keys[0],
-        keys[1],
-        keys[2],
-        keys.slice(3, 3 + numTokenAccounts),
-        keys.slice(-1 * numTokenAccounts),
-    ];
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            signers,
-            sources,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-            numTokenAccounts,
-        },
-    };
-}
-
-// HarvestWithheldTokensToMint
-
-export interface HarvestWithheldTokensToMintInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.HarvestWithheldTokensToMint;
-}
-
-export const harvestWithheldTokensToMintInstructionData = struct<HarvestWithheldTokensToMintInstructionData>([
-    u8('instruction'),
-    u8('transferFeeInstruction'),
-]);
-
-/**
- * Construct a HarvestWithheldTokensToMint instruction
- *
- * @param mint              The token mint
- * @param sources           The source accounts to withdraw from
- * @param programID         SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createHarvestWithheldTokensToMintInstruction(
-    mint: PublicKey,
-    sources: PublicKey[],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const data = Buffer.alloc(harvestWithheldTokensToMintInstructionData.span);
-    harvestWithheldTokensToMintInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.HarvestWithheldTokensToMint,
-        },
-        data
-    );
-    const keys: AccountMeta[] = [];
-    keys.push({ pubkey: mint, isSigner: false, isWritable: true });
-    for (const source of sources) {
-        keys.push({ pubkey: source, isSigner: false, isWritable: true });
-    }
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid HarvestWithheldTokensToMint instruction */
-export interface DecodedHarvestWithheldTokensToMintInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        sources: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.HarvestWithheldTokensToMint;
-    };
-}
-
-/**
- * Decode a HarvestWithheldTokensToMint instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeHarvestWithheldTokensToMintInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedHarvestWithheldTokensToMintInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== harvestWithheldTokensToMintInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, sources },
-        data,
-    } = decodeHarvestWithheldTokensToMintInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.HarvestWithheldTokensToMint
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-            sources,
-        },
-        data,
-    };
-}
-
-/** A decoded, valid HarvestWithheldTokensToMint instruction */
-export interface DecodedHarvestWithheldTokensToMintInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        sources: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.HarvestWithheldTokensToMint;
-    };
-}
-
-/**
- * Decode a HarvestWithheldTokensToMint instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeHarvestWithheldTokensToMintInstructionUnchecked({
-    programId,
-    keys: [mint, ...sources],
-    data,
-}: TransactionInstruction): DecodedHarvestWithheldTokensToMintInstructionUnchecked {
-    const { instruction, transferFeeInstruction } = harvestWithheldTokensToMintInstructionData.decode(data);
-    return {
-        programId,
-        keys: {
-            mint,
-            sources,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-        },
-    };
-}
-
-// SetTransferFee
-
-export interface SetTransferFeeInstructionData {
-    instruction: TokenInstruction.TransferFeeExtension;
-    transferFeeInstruction: TransferFeeInstruction.SetTransferFee;
-    transferFeeBasisPoints: number;
-    maximumFee: bigint;
-}
-
-export const setTransferFeeInstructionData = struct<SetTransferFeeInstructionData>([
-    u8('instruction'),
-    u8('transferFeeInstruction'),
-    u16('transferFeeBasisPoints'),
-    u64('maximumFee'),
-]);
-
-/**
- * Construct a SetTransferFeeInstruction instruction
- *
- * @param mint                      The token mint
- * @param authority                 The authority of the transfer fee
- * @param signers                   The signer account(s)
- * @param transferFeeBasisPoints    Amount of transfer collected as fees, expressed as basis points of the transfer amount
- * @param maximumFee                Maximum fee assessed on transfers
- * @param programID                 SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createSetTransferFeeInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    signers: (Signer | PublicKey)[],
-    transferFeeBasisPoints: number,
-    maximumFee: bigint,
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const data = Buffer.alloc(setTransferFeeInstructionData.span);
-    setTransferFeeInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferFeeExtension,
-            transferFeeInstruction: TransferFeeInstruction.SetTransferFee,
-            transferFeeBasisPoints: transferFeeBasisPoints,
-            maximumFee: maximumFee,
-        },
-        data
-    );
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], authority, signers);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid SetTransferFee instruction */
-export interface DecodedSetTransferFeeInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | null;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.SetTransferFee;
-        transferFeeBasisPoints: number;
-        maximumFee: bigint;
-    };
-}
-
-/**
- * Decode an SetTransferFee instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeSetTransferFeeInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedSetTransferFeeInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== setTransferFeeInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, authority, signers },
-        data,
-    } = decodeSetTransferFeeInstructionUnchecked(instruction);
-    if (
-        data.instruction !== TokenInstruction.TransferFeeExtension ||
-        data.transferFeeInstruction !== TransferFeeInstruction.SetTransferFee
-    )
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-            authority,
-            signers: signers ? signers : null,
-        },
-        data,
-    };
-}
-
-/** A decoded, valid SetTransferFee instruction */
-export interface DecodedSetTransferFeeInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        authority: AccountMeta;
-        signers: AccountMeta[] | undefined;
-    };
-    data: {
-        instruction: TokenInstruction.TransferFeeExtension;
-        transferFeeInstruction: TransferFeeInstruction.SetTransferFee;
-        transferFeeBasisPoints: number;
-        maximumFee: bigint;
-    };
-}
-
-/**
- * Decode a SetTransferFee instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeSetTransferFeeInstructionUnchecked({
-    programId,
-    keys: [mint, authority, ...signers],
-    data,
-}: TransactionInstruction): DecodedSetTransferFeeInstructionUnchecked {
-    const { instruction, transferFeeInstruction, transferFeeBasisPoints, maximumFee } =
-        setTransferFeeInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-            authority,
-            signers,
-        },
-        data: {
-            instruction,
-            transferFeeInstruction,
-            transferFeeBasisPoints,
-            maximumFee,
-        },
-    };
-}
diff --git a/token/js/src/extensions/transferFee/state.ts b/token/js/src/extensions/transferFee/state.ts
deleted file mode 100644
index bef4e9a7d89..00000000000
--- a/token/js/src/extensions/transferFee/state.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import type { Layout } from '@solana/buffer-layout';
-import { struct, u16 } from '@solana/buffer-layout';
-import { publicKey, u64 } from '@solana/buffer-layout-utils';
-import type { PublicKey } from '@solana/web3.js';
-import type { Account } from '../../state/account.js';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-
-export const MAX_FEE_BASIS_POINTS = 10000;
-export const ONE_IN_BASIS_POINTS = BigInt(MAX_FEE_BASIS_POINTS);
-
-/** TransferFeeConfig as stored by the program */
-export interface TransferFee {
-    /** First epoch where the transfer fee takes effect */
-    epoch: bigint;
-    /** Maximum fee assessed on transfers, expressed as an amount of tokens */
-    maximumFee: bigint;
-    /**
-     * Amount of transfer collected as fees, expressed as basis points of the
-     * transfer amount, ie. increments of 0.01%
-     */
-    transferFeeBasisPoints: number;
-}
-
-/** Transfer fee extension data for mints. */
-export interface TransferFeeConfig {
-    /** Optional authority to set the fee */
-    transferFeeConfigAuthority: PublicKey;
-    /** Withdraw from mint instructions must be signed by this key */
-    withdrawWithheldAuthority: PublicKey;
-    /** Withheld transfer fee tokens that have been moved to the mint for withdrawal */
-    withheldAmount: bigint;
-    /** Older transfer fee, used if the current epoch < newerTransferFee.epoch */
-    olderTransferFee: TransferFee;
-    /** Newer transfer fee, used if the current epoch >= newerTransferFee.epoch */
-    newerTransferFee: TransferFee;
-}
-
-/** Buffer layout for de/serializing a transfer fee */
-export function transferFeeLayout(property?: string): Layout<TransferFee> {
-    return struct<TransferFee>([u64('epoch'), u64('maximumFee'), u16('transferFeeBasisPoints')], property);
-}
-
-/** Calculate the transfer fee */
-export function calculateFee(transferFee: TransferFee, preFeeAmount: bigint): bigint {
-    const transferFeeBasisPoints = transferFee.transferFeeBasisPoints;
-    if (transferFeeBasisPoints === 0 || preFeeAmount === BigInt(0)) {
-        return BigInt(0);
-    } else {
-        const numerator = preFeeAmount * BigInt(transferFeeBasisPoints);
-        const rawFee = (numerator + ONE_IN_BASIS_POINTS - BigInt(1)) / ONE_IN_BASIS_POINTS;
-        const fee = rawFee > transferFee.maximumFee ? transferFee.maximumFee : rawFee;
-        return BigInt(fee);
-    }
-}
-
-/** Buffer layout for de/serializing a transfer fee config extension */
-export const TransferFeeConfigLayout = struct<TransferFeeConfig>([
-    publicKey('transferFeeConfigAuthority'),
-    publicKey('withdrawWithheldAuthority'),
-    u64('withheldAmount'),
-    transferFeeLayout('olderTransferFee'),
-    transferFeeLayout('newerTransferFee'),
-]);
-
-export const TRANSFER_FEE_CONFIG_SIZE = TransferFeeConfigLayout.span;
-
-/** Get the fee for given epoch */
-export function getEpochFee(transferFeeConfig: TransferFeeConfig, epoch: bigint): TransferFee {
-    if (epoch >= transferFeeConfig.newerTransferFee.epoch) {
-        return transferFeeConfig.newerTransferFee;
-    } else {
-        return transferFeeConfig.olderTransferFee;
-    }
-}
-
-/** Calculate the fee for the given epoch and input amount */
-export function calculateEpochFee(transferFeeConfig: TransferFeeConfig, epoch: bigint, preFeeAmount: bigint): bigint {
-    const transferFee = getEpochFee(transferFeeConfig, epoch);
-    return calculateFee(transferFee, preFeeAmount);
-}
-
-/** Transfer fee amount data for accounts. */
-export interface TransferFeeAmount {
-    /** Withheld transfer fee tokens that can be claimed by the fee authority */
-    withheldAmount: bigint;
-}
-/** Buffer layout for de/serializing */
-export const TransferFeeAmountLayout = struct<TransferFeeAmount>([u64('withheldAmount')]);
-export const TRANSFER_FEE_AMOUNT_SIZE = TransferFeeAmountLayout.span;
-
-export function getTransferFeeConfig(mint: Mint): TransferFeeConfig | null {
-    const extensionData = getExtensionData(ExtensionType.TransferFeeConfig, mint.tlvData);
-    if (extensionData !== null) {
-        return TransferFeeConfigLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
-
-export function getTransferFeeAmount(account: Account): TransferFeeAmount | null {
-    const extensionData = getExtensionData(ExtensionType.TransferFeeAmount, account.tlvData);
-    if (extensionData !== null) {
-        return TransferFeeAmountLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
diff --git a/token/js/src/extensions/transferHook/actions.ts b/token/js/src/extensions/transferHook/actions.ts
deleted file mode 100644
index c14b01631d7..00000000000
--- a/token/js/src/extensions/transferHook/actions.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-import type { ConfirmOptions, Connection, Signer, TransactionSignature } from '@solana/web3.js';
-import type { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Transaction } from '@solana/web3.js';
-import { getSigners } from '../../actions/internal.js';
-import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../../constants.js';
-import {
-    createInitializeTransferHookInstruction,
-    createTransferCheckedWithFeeAndTransferHookInstruction,
-    createTransferCheckedWithTransferHookInstruction,
-    createUpdateTransferHookInstruction,
-} from './instructions.js';
-
-/**
- * Initialize a transfer hook on a mint
- *
- * @param connection            Connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint to initialize with extension
- * @param authority             Transfer hook authority account
- * @param transferHookProgramId The transfer hook program account
- * @param confirmOptions        Options for confirming the transaction
- * @param programId             SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function initializeTransferHook(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    authority: PublicKey,
-    transferHookProgramId: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const transaction = new Transaction().add(
-        createInitializeTransferHookInstruction(mint, authority, transferHookProgramId, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
-}
-
-/**
- * Update the transfer hook program on a mint
- *
- * @param connection            Connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint to modify
- * @param transferHookProgramId New transfer hook program account
- * @param authority             Transfer hook update authority
- * @param multiSigners          Signing accounts if `freezeAuthority` is a multisig
- * @param confirmOptions        Options for confirming the transaction
- * @param programId             SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function updateTransferHook(
-    connection: Connection,
-    payer: Signer,
-    mint: PublicKey,
-    transferHookProgramId: PublicKey,
-    authority: Signer | PublicKey,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_2022_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        createUpdateTransferHookInstruction(mint, authorityPublicKey, transferHookProgramId, signers, programId)
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Transfer tokens from one account to another, asserting the token mint, and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param source         Source account
- * @param mint           Mint for the account
- * @param destination    Destination account
- * @param authority      Authority of the source account
- * @param amount         Number of tokens to transfer
- * @param decimals       Number of decimals in transfer amount
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function transferCheckedWithTransferHook(
-    connection: Connection,
-    payer: Signer,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: bigint,
-    decimals: number,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        await createTransferCheckedWithTransferHookInstruction(
-            connection,
-            source,
-            mint,
-            destination,
-            authorityPublicKey,
-            amount,
-            decimals,
-            signers,
-            confirmOptions?.commitment,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
-
-/**
- * Transfer tokens from one account to another, asserting the transfer fee, token mint, and decimals
- *
- * @param connection     Connection to use
- * @param payer          Payer of the transaction fees
- * @param source         Source account
- * @param mint           Mint for the account
- * @param destination    Destination account
- * @param authority      Authority of the source account
- * @param amount         Number of tokens to transfer
- * @param decimals       Number of decimals in transfer amount
- * @param fee            The calculated fee for the transfer fee extension
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param confirmOptions Options for confirming the transaction
- * @param programId      SPL Token program account
- *
- * @return Signature of the confirmed transaction
- */
-export async function transferCheckedWithFeeAndTransferHook(
-    connection: Connection,
-    payer: Signer,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: bigint,
-    decimals: number,
-    fee: bigint,
-    multiSigners: Signer[] = [],
-    confirmOptions?: ConfirmOptions,
-    programId = TOKEN_PROGRAM_ID
-): Promise<TransactionSignature> {
-    const [authorityPublicKey, signers] = getSigners(authority, multiSigners);
-
-    const transaction = new Transaction().add(
-        await createTransferCheckedWithFeeAndTransferHookInstruction(
-            connection,
-            source,
-            mint,
-            destination,
-            authorityPublicKey,
-            amount,
-            decimals,
-            fee,
-            signers,
-            confirmOptions?.commitment,
-            programId
-        )
-    );
-
-    return await sendAndConfirmTransaction(connection, transaction, [payer, ...signers], confirmOptions);
-}
diff --git a/token/js/src/extensions/transferHook/index.ts b/token/js/src/extensions/transferHook/index.ts
deleted file mode 100644
index b788b0de4ad..00000000000
--- a/token/js/src/extensions/transferHook/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './actions.js';
-export * from './instructions.js';
-export * from './seeds.js';
-export * from './state.js';
diff --git a/token/js/src/extensions/transferHook/instructions.ts b/token/js/src/extensions/transferHook/instructions.ts
deleted file mode 100644
index ffdf2296b57..00000000000
--- a/token/js/src/extensions/transferHook/instructions.ts
+++ /dev/null
@@ -1,364 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, Commitment, Connection, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../../constants.js';
-import { TokenUnsupportedInstructionError } from '../../errors.js';
-import { addSigners } from '../../instructions/internal.js';
-import { TokenInstruction } from '../../instructions/types.js';
-import { publicKey } from '@solana/buffer-layout-utils';
-import { createTransferCheckedInstruction } from '../../instructions/transferChecked.js';
-import { createTransferCheckedWithFeeInstruction } from '../transferFee/instructions.js';
-import { getMint } from '../../state/mint.js';
-import { getExtraAccountMetaAddress, getExtraAccountMetas, getTransferHook, resolveExtraAccountMeta } from './state.js';
-
-export enum TransferHookInstruction {
-    Initialize = 0,
-    Update = 1,
-}
-
-/** Deserialized instruction for the initiation of an transfer hook */
-export interface InitializeTransferHookInstructionData {
-    instruction: TokenInstruction.TransferHookExtension;
-    transferHookInstruction: TransferHookInstruction.Initialize;
-    authority: PublicKey;
-    transferHookProgramId: PublicKey;
-}
-
-/** The struct that represents the instruction data as it is read by the program */
-export const initializeTransferHookInstructionData = struct<InitializeTransferHookInstructionData>([
-    u8('instruction'),
-    u8('transferHookInstruction'),
-    publicKey('authority'),
-    publicKey('transferHookProgramId'),
-]);
-
-/**
- * Construct an InitializeTransferHook instruction
- *
- * @param mint                  Token mint account
- * @param authority             Transfer hook authority account
- * @param transferHookProgramId Transfer hook program account
- * @param programId             SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeTransferHookInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    transferHookProgramId: PublicKey,
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeTransferHookInstructionData.span);
-    initializeTransferHookInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferHookExtension,
-            transferHookInstruction: TransferHookInstruction.Initialize,
-            authority,
-            transferHookProgramId,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** Deserialized instruction for the initiation of an transfer hook */
-export interface UpdateTransferHookInstructionData {
-    instruction: TokenInstruction.TransferHookExtension;
-    transferHookInstruction: TransferHookInstruction.Update;
-    transferHookProgramId: PublicKey;
-}
-
-/** The struct that represents the instruction data as it is read by the program */
-export const updateTransferHookInstructionData = struct<UpdateTransferHookInstructionData>([
-    u8('instruction'),
-    u8('transferHookInstruction'),
-    publicKey('transferHookProgramId'),
-]);
-
-/**
- * Construct an UpdateTransferHook instruction
- *
- * @param mint                  Mint to update
- * @param authority             The mint's transfer hook authority
- * @param transferHookProgramId The new transfer hook program account
- * @param signers               The signer account(s) for a multisig
- * @param tokenProgramId        SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createUpdateTransferHookInstruction(
-    mint: PublicKey,
-    authority: PublicKey,
-    transferHookProgramId: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-
-    const keys = addSigners([{ pubkey: mint, isSigner: false, isWritable: true }], authority, multiSigners);
-    const data = Buffer.alloc(updateTransferHookInstructionData.span);
-    updateTransferHookInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferHookExtension,
-            transferHookInstruction: TransferHookInstruction.Update,
-            transferHookProgramId,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-function deEscalateAccountMeta(accountMeta: AccountMeta, accountMetas: AccountMeta[]): AccountMeta {
-    const maybeHighestPrivileges = accountMetas
-        .filter((x) => x.pubkey.equals(accountMeta.pubkey))
-        .reduce<{ isSigner: boolean; isWritable: boolean } | undefined>((acc, x) => {
-            if (!acc) return { isSigner: x.isSigner, isWritable: x.isWritable };
-            return { isSigner: acc.isSigner || x.isSigner, isWritable: acc.isWritable || x.isWritable };
-        }, undefined);
-    if (maybeHighestPrivileges) {
-        const { isSigner, isWritable } = maybeHighestPrivileges;
-        if (!isSigner && isSigner !== accountMeta.isSigner) {
-            accountMeta.isSigner = false;
-        }
-        if (!isWritable && isWritable !== accountMeta.isWritable) {
-            accountMeta.isWritable = false;
-        }
-    }
-    return accountMeta;
-}
-
-/**
- * Construct an `ExecuteInstruction` for a transfer hook program, without the
- * additional accounts
- *
- * @param programId             The program ID of the transfer hook program
- * @param source                The source account
- * @param mint                  The mint account
- * @param destination           The destination account
- * @param owner                 Owner of the source account
- * @param validateStatePubkey   The validate state pubkey
- * @param amount                The amount of tokens to transfer
- * @returns Instruction to add to a transaction
- */
-export function createExecuteInstruction(
-    programId: PublicKey,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    validateStatePubkey: PublicKey,
-    amount: bigint
-): TransactionInstruction {
-    const keys = [source, mint, destination, owner, validateStatePubkey].map((pubkey) => ({
-        pubkey,
-        isSigner: false,
-        isWritable: false,
-    }));
-
-    const data = Buffer.alloc(16);
-    data.set(Buffer.from([105, 37, 101, 197, 75, 251, 102, 26]), 0); // `ExecuteInstruction` discriminator
-    data.writeBigUInt64LE(BigInt(amount), 8);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/**
- * Adds all the extra accounts needed for a transfer hook to an instruction.
- *
- * Note this will modify the instruction passed in.
- *
- * @param connection            Connection to use
- * @param instruction           The instruction to add accounts to
- * @param programId             Transfer hook program ID
- * @param source                The source account
- * @param mint                  The mint account
- * @param destination           The destination account
- * @param owner                 Owner of the source account
- * @param amount                The amount of tokens to transfer
- * @param commitment            Commitment to use
- */
-export async function addExtraAccountMetasForExecute(
-    connection: Connection,
-    instruction: TransactionInstruction,
-    programId: PublicKey,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    commitment?: Commitment
-) {
-    const validateStatePubkey = getExtraAccountMetaAddress(mint, programId);
-    const validateStateAccount = await connection.getAccountInfo(validateStatePubkey, commitment);
-    if (validateStateAccount == null) {
-        return instruction;
-    }
-    const validateStateData = getExtraAccountMetas(validateStateAccount);
-
-    // Check to make sure the provided keys are in the instruction
-    if (![source, mint, destination, owner].every((key) => instruction.keys.some((meta) => meta.pubkey.equals(key)))) {
-        throw new Error('Missing required account in instruction');
-    }
-
-    const executeInstruction = createExecuteInstruction(
-        programId,
-        source,
-        mint,
-        destination,
-        owner,
-        validateStatePubkey,
-        BigInt(amount)
-    );
-
-    for (const extraAccountMeta of validateStateData) {
-        executeInstruction.keys.push(
-            deEscalateAccountMeta(
-                await resolveExtraAccountMeta(
-                    connection,
-                    extraAccountMeta,
-                    executeInstruction.keys,
-                    executeInstruction.data,
-                    executeInstruction.programId
-                ),
-                executeInstruction.keys
-            )
-        );
-    }
-
-    // Add only the extra accounts resolved from the validation state
-    instruction.keys.push(...executeInstruction.keys.slice(5));
-
-    // Add the transfer hook program ID and the validation state account
-    instruction.keys.push({ pubkey: programId, isSigner: false, isWritable: false });
-    instruction.keys.push({ pubkey: validateStatePubkey, isSigner: false, isWritable: false });
-}
-
-/**
- * Construct an transferChecked instruction with extra accounts for transfer hook
- *
- * @param connection            Connection to use
- * @param source                Source account
- * @param mint                  Mint to update
- * @param destination           Destination account
- * @param owner                 Owner of the source account
- * @param amount                The amount of tokens to transfer
- * @param decimals              Number of decimals in transfer amount
- * @param multiSigners          The signer account(s) for a multisig
- * @param commitment            Commitment to use
- * @param programId             SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export async function createTransferCheckedWithTransferHookInstruction(
-    connection: Connection,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: bigint,
-    decimals: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-) {
-    const instruction = createTransferCheckedInstruction(
-        source,
-        mint,
-        destination,
-        owner,
-        amount,
-        decimals,
-        multiSigners,
-        programId
-    );
-
-    const mintInfo = await getMint(connection, mint, commitment, programId);
-    const transferHook = getTransferHook(mintInfo);
-
-    if (transferHook) {
-        await addExtraAccountMetasForExecute(
-            connection,
-            instruction,
-            transferHook.programId,
-            source,
-            mint,
-            destination,
-            owner,
-            amount,
-            commitment
-        );
-    }
-
-    return instruction;
-}
-
-/**
- * Construct an transferChecked instruction with extra accounts for transfer hook
- *
- * @param connection            Connection to use
- * @param source                Source account
- * @param mint                  Mint to update
- * @param destination           Destination account
- * @param owner                 Owner of the source account
- * @param amount                The amount of tokens to transfer
- * @param decimals              Number of decimals in transfer amount
- * @param fee                   The calculated fee for the transfer fee extension
- * @param multiSigners          The signer account(s) for a multisig
- * @param commitment            Commitment to use
- * @param programId             SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export async function createTransferCheckedWithFeeAndTransferHookInstruction(
-    connection: Connection,
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: bigint,
-    decimals: number,
-    fee: bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-) {
-    const instruction = createTransferCheckedWithFeeInstruction(
-        source,
-        mint,
-        destination,
-        owner,
-        amount,
-        decimals,
-        fee,
-        multiSigners,
-        programId
-    );
-
-    const mintInfo = await getMint(connection, mint, commitment, programId);
-    const transferHook = getTransferHook(mintInfo);
-
-    if (transferHook) {
-        await addExtraAccountMetasForExecute(
-            connection,
-            instruction,
-            transferHook.programId,
-            source,
-            mint,
-            destination,
-            owner,
-            amount,
-            commitment
-        );
-    }
-
-    return instruction;
-}
diff --git a/token/js/src/extensions/transferHook/seeds.ts b/token/js/src/extensions/transferHook/seeds.ts
deleted file mode 100644
index 5530b0a4826..00000000000
--- a/token/js/src/extensions/transferHook/seeds.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-import type { AccountMeta, Connection } from '@solana/web3.js';
-import { TokenTransferHookAccountDataNotFound, TokenTransferHookInvalidSeed } from '../../errors.js';
-
-interface Seed {
-    data: Buffer;
-    packedLength: number;
-}
-
-const DISCRIMINATOR_SPAN = 1;
-const LITERAL_LENGTH_SPAN = 1;
-const INSTRUCTION_ARG_OFFSET_SPAN = 1;
-const INSTRUCTION_ARG_LENGTH_SPAN = 1;
-const ACCOUNT_KEY_INDEX_SPAN = 1;
-const ACCOUNT_DATA_ACCOUNT_INDEX_SPAN = 1;
-const ACCOUNT_DATA_OFFSET_SPAN = 1;
-const ACCOUNT_DATA_LENGTH_SPAN = 1;
-
-function unpackSeedLiteral(seeds: Uint8Array): Seed {
-    if (seeds.length < 1) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    const [length, ...rest] = seeds;
-    if (rest.length < length) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    return {
-        data: Buffer.from(rest.slice(0, length)),
-        packedLength: DISCRIMINATOR_SPAN + LITERAL_LENGTH_SPAN + length,
-    };
-}
-
-function unpackSeedInstructionArg(seeds: Uint8Array, instructionData: Buffer): Seed {
-    if (seeds.length < 2) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    const [index, length] = seeds;
-    if (instructionData.length < length + index) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    return {
-        data: instructionData.subarray(index, index + length),
-        packedLength: DISCRIMINATOR_SPAN + INSTRUCTION_ARG_OFFSET_SPAN + INSTRUCTION_ARG_LENGTH_SPAN,
-    };
-}
-
-function unpackSeedAccountKey(seeds: Uint8Array, previousMetas: AccountMeta[]): Seed {
-    if (seeds.length < 1) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    const [index] = seeds;
-    if (previousMetas.length <= index) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    return {
-        data: previousMetas[index].pubkey.toBuffer(),
-        packedLength: DISCRIMINATOR_SPAN + ACCOUNT_KEY_INDEX_SPAN,
-    };
-}
-
-async function unpackSeedAccountData(
-    seeds: Uint8Array,
-    previousMetas: AccountMeta[],
-    connection: Connection
-): Promise<Seed> {
-    if (seeds.length < 3) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    const [accountIndex, dataIndex, length] = seeds;
-    if (previousMetas.length <= accountIndex) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    const accountInfo = await connection.getAccountInfo(previousMetas[accountIndex].pubkey);
-    if (accountInfo == null) {
-        throw new TokenTransferHookAccountDataNotFound();
-    }
-    if (accountInfo.data.length < dataIndex + length) {
-        throw new TokenTransferHookInvalidSeed();
-    }
-    return {
-        data: accountInfo.data.subarray(dataIndex, dataIndex + length),
-        packedLength:
-            DISCRIMINATOR_SPAN + ACCOUNT_DATA_ACCOUNT_INDEX_SPAN + ACCOUNT_DATA_OFFSET_SPAN + ACCOUNT_DATA_LENGTH_SPAN,
-    };
-}
-
-async function unpackFirstSeed(
-    seeds: Uint8Array,
-    previousMetas: AccountMeta[],
-    instructionData: Buffer,
-    connection: Connection
-): Promise<Seed | null> {
-    const [discriminator, ...rest] = seeds;
-    const remaining = new Uint8Array(rest);
-    switch (discriminator) {
-        case 0:
-            return null;
-        case 1:
-            return unpackSeedLiteral(remaining);
-        case 2:
-            return unpackSeedInstructionArg(remaining, instructionData);
-        case 3:
-            return unpackSeedAccountKey(remaining, previousMetas);
-        case 4:
-            return unpackSeedAccountData(remaining, previousMetas, connection);
-        default:
-            throw new TokenTransferHookInvalidSeed();
-    }
-}
-
-export async function unpackSeeds(
-    seeds: Uint8Array,
-    previousMetas: AccountMeta[],
-    instructionData: Buffer,
-    connection: Connection
-): Promise<Buffer[]> {
-    const unpackedSeeds: Buffer[] = [];
-    let i = 0;
-    while (i < 32) {
-        const seed = await unpackFirstSeed(seeds.slice(i), previousMetas, instructionData, connection);
-        if (seed == null) {
-            break;
-        }
-        unpackedSeeds.push(seed.data);
-        i += seed.packedLength;
-    }
-    return unpackedSeeds;
-}
diff --git a/token/js/src/extensions/transferHook/state.ts b/token/js/src/extensions/transferHook/state.ts
deleted file mode 100644
index f436a4213b1..00000000000
--- a/token/js/src/extensions/transferHook/state.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-import { blob, greedy, seq, struct, u32, u8 } from '@solana/buffer-layout';
-import type { Mint } from '../../state/mint.js';
-import { ExtensionType, getExtensionData } from '../extensionType.js';
-import type { AccountInfo, AccountMeta, Connection } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { bool, publicKey, u64 } from '@solana/buffer-layout-utils';
-import type { Account } from '../../state/account.js';
-import { TokenTransferHookAccountNotFound } from '../../errors.js';
-import { unpackSeeds } from './seeds.js';
-
-/** TransferHook as stored by the program */
-export interface TransferHook {
-    /** The transfer hook update authority */
-    authority: PublicKey;
-    /** The transfer hook program account */
-    programId: PublicKey;
-}
-
-/** Buffer layout for de/serializing a transfer hook extension */
-export const TransferHookLayout = struct<TransferHook>([publicKey('authority'), publicKey('programId')]);
-
-export const TRANSFER_HOOK_SIZE = TransferHookLayout.span;
-
-export function getTransferHook(mint: Mint): TransferHook | null {
-    const extensionData = getExtensionData(ExtensionType.TransferHook, mint.tlvData);
-    if (extensionData !== null) {
-        return TransferHookLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
-
-/** TransferHookAccount as stored by the program */
-export interface TransferHookAccount {
-    /**
-     * Whether or not this account is currently transferring tokens
-     * True during the transfer hook cpi, otherwise false
-     */
-    transferring: boolean;
-}
-
-/** Buffer layout for de/serializing a transfer hook account extension */
-export const TransferHookAccountLayout = struct<TransferHookAccount>([bool('transferring')]);
-
-export const TRANSFER_HOOK_ACCOUNT_SIZE = TransferHookAccountLayout.span;
-
-export function getTransferHookAccount(account: Account): TransferHookAccount | null {
-    const extensionData = getExtensionData(ExtensionType.TransferHookAccount, account.tlvData);
-    if (extensionData !== null) {
-        return TransferHookAccountLayout.decode(extensionData);
-    } else {
-        return null;
-    }
-}
-
-export function getExtraAccountMetaAddress(mint: PublicKey, programId: PublicKey): PublicKey {
-    const seeds = [Buffer.from('extra-account-metas'), mint.toBuffer()];
-    return PublicKey.findProgramAddressSync(seeds, programId)[0];
-}
-
-/** ExtraAccountMeta as stored by the transfer hook program */
-export interface ExtraAccountMeta {
-    discriminator: number;
-    addressConfig: Uint8Array;
-    isSigner: boolean;
-    isWritable: boolean;
-}
-
-/** Buffer layout for de/serializing an ExtraAccountMeta */
-export const ExtraAccountMetaLayout = struct<ExtraAccountMeta>([
-    u8('discriminator'),
-    blob(32, 'addressConfig'),
-    bool('isSigner'),
-    bool('isWritable'),
-]);
-
-export interface ExtraAccountMetaList {
-    count: number;
-    extraAccounts: ExtraAccountMeta[];
-}
-
-/** Buffer layout for de/serializing a list of ExtraAccountMeta prefixed by a u32 length */
-export const ExtraAccountMetaListLayout = struct<ExtraAccountMetaList>([
-    u32('count'),
-    seq<ExtraAccountMeta>(ExtraAccountMetaLayout, greedy(ExtraAccountMetaLayout.span), 'extraAccounts'),
-]);
-
-/** Buffer layout for de/serializing a list of ExtraAccountMetaAccountData prefixed by a u32 length */
-export interface ExtraAccountMetaAccountData {
-    instructionDiscriminator: bigint;
-    length: number;
-    extraAccountsList: ExtraAccountMetaList;
-}
-
-/** Buffer layout for de/serializing an ExtraAccountMetaAccountData */
-export const ExtraAccountMetaAccountDataLayout = struct<ExtraAccountMetaAccountData>([
-    u64('instructionDiscriminator'),
-    u32('length'),
-    ExtraAccountMetaListLayout.replicate('extraAccountsList'),
-]);
-
-/** Unpack an extra account metas account and parse the data into a list of ExtraAccountMetas */
-export function getExtraAccountMetas(account: AccountInfo<Buffer>): ExtraAccountMeta[] {
-    const extraAccountsList = ExtraAccountMetaAccountDataLayout.decode(account.data).extraAccountsList;
-    return extraAccountsList.extraAccounts.slice(0, extraAccountsList.count);
-}
-
-/** Take an ExtraAccountMeta and construct that into an actual AccountMeta */
-export async function resolveExtraAccountMeta(
-    connection: Connection,
-    extraMeta: ExtraAccountMeta,
-    previousMetas: AccountMeta[],
-    instructionData: Buffer,
-    transferHookProgramId: PublicKey
-): Promise<AccountMeta> {
-    if (extraMeta.discriminator === 0) {
-        return {
-            pubkey: new PublicKey(extraMeta.addressConfig),
-            isSigner: extraMeta.isSigner,
-            isWritable: extraMeta.isWritable,
-        };
-    }
-
-    let programId = PublicKey.default;
-
-    if (extraMeta.discriminator === 1) {
-        programId = transferHookProgramId;
-    } else {
-        const accountIndex = extraMeta.discriminator - (1 << 7);
-        if (previousMetas.length <= accountIndex) {
-            throw new TokenTransferHookAccountNotFound();
-        }
-        programId = previousMetas[accountIndex].pubkey;
-    }
-
-    const seeds = await unpackSeeds(extraMeta.addressConfig, previousMetas, instructionData, connection);
-    const pubkey = PublicKey.findProgramAddressSync(seeds, programId)[0];
-
-    return { pubkey, isSigner: extraMeta.isSigner, isWritable: extraMeta.isWritable };
-}
diff --git a/token/js/src/index.ts b/token/js/src/index.ts
deleted file mode 100644
index b63e805e44e..00000000000
--- a/token/js/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export * from './actions/index.js';
-export * from './constants.js';
-export * from './errors.js';
-export * from './extensions/index.js';
-export * from './instructions/index.js';
-export * from './state/index.js';
diff --git a/token/js/src/instructions/amountToUiAmount.ts b/token/js/src/instructions/amountToUiAmount.ts
deleted file mode 100644
index 6a180ee7fb0..00000000000
--- a/token/js/src/instructions/amountToUiAmount.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface AmountToUiAmountInstructionData {
-    instruction: TokenInstruction.AmountToUiAmount;
-    amount: bigint;
-}
-
-/** TODO: docs */
-export const amountToUiAmountInstructionData = struct<AmountToUiAmountInstructionData>([
-    u8('instruction'),
-    u64('amount'),
-]);
-
-/**
- * Construct a AmountToUiAmount instruction
- *
- * @param mint         Public key of the mint
- * @param amount       Amount of tokens to be converted to UiAmount
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createAmountToUiAmountInstruction(
-    mint: PublicKey,
-    amount: number | bigint,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: false }];
-
-    const data = Buffer.alloc(amountToUiAmountInstructionData.span);
-    amountToUiAmountInstructionData.encode(
-        {
-            instruction: TokenInstruction.AmountToUiAmount,
-            amount: BigInt(amount),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid AmountToUiAmount instruction */
-export interface DecodedAmountToUiAmountInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.AmountToUiAmount;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a AmountToUiAmount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeAmountToUiAmountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedAmountToUiAmountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== amountToUiAmountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeAmountToUiAmountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.AmountToUiAmount) throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated AmountToUiAmount instruction */
-export interface DecodedAmountToUiAmountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a AmountToUiAmount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeAmountToUiAmountInstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedAmountToUiAmountInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: amountToUiAmountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/approve.ts b/token/js/src/instructions/approve.ts
deleted file mode 100644
index 188925c50fc..00000000000
--- a/token/js/src/instructions/approve.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface ApproveInstructionData {
-    instruction: TokenInstruction.Approve;
-    amount: bigint;
-}
-
-/** TODO: docs */
-export const approveInstructionData = struct<ApproveInstructionData>([u8('instruction'), u64('amount')]);
-
-/**
- * Construct an Approve instruction
- *
- * @param account      Account to set the delegate for
- * @param delegate     Account authorized to transfer tokens from the account
- * @param owner        Owner of the account
- * @param amount       Maximum number of tokens the delegate may transfer
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createApproveInstruction(
-    account: PublicKey,
-    delegate: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: delegate, isSigner: false, isWritable: false },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(approveInstructionData.span);
-    approveInstructionData.encode(
-        {
-            instruction: TokenInstruction.Approve,
-            amount: BigInt(amount),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid Approve instruction */
-export interface DecodedApproveInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        delegate: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.Approve;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode an Approve instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeApproveInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedApproveInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== approveInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, delegate, owner, multiSigners },
-        data,
-    } = decodeApproveInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.Approve) throw new TokenInvalidInstructionTypeError();
-    if (!account || !delegate || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            delegate,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated Approve instruction */
-export interface DecodedApproveInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        delegate: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode an Approve instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeApproveInstructionUnchecked({
-    programId,
-    keys: [account, delegate, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedApproveInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            delegate,
-            owner,
-            multiSigners,
-        },
-        data: approveInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/approveChecked.ts b/token/js/src/instructions/approveChecked.ts
deleted file mode 100644
index e7895a8d12e..00000000000
--- a/token/js/src/instructions/approveChecked.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface ApproveCheckedInstructionData {
-    instruction: TokenInstruction.ApproveChecked;
-    amount: bigint;
-    decimals: number;
-}
-
-/** TODO: docs */
-export const approveCheckedInstructionData = struct<ApproveCheckedInstructionData>([
-    u8('instruction'),
-    u64('amount'),
-    u8('decimals'),
-]);
-
-/**
- * Construct an ApproveChecked instruction
- *
- * @param account      Account to set the delegate for
- * @param mint         Mint account
- * @param delegate     Account authorized to transfer of tokens from the account
- * @param owner        Owner of the account
- * @param amount       Maximum number of tokens the delegate may transfer
- * @param decimals     Number of decimals in approve amount
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createApproveCheckedInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    delegate: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-            { pubkey: delegate, isSigner: false, isWritable: false },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(approveCheckedInstructionData.span);
-    approveCheckedInstructionData.encode(
-        {
-            instruction: TokenInstruction.ApproveChecked,
-            amount: BigInt(amount),
-            decimals,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid ApproveChecked instruction */
-export interface DecodedApproveCheckedInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        delegate: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.ApproveChecked;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode an ApproveChecked instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeApproveCheckedInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedApproveCheckedInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== approveCheckedInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, delegate, owner, multiSigners },
-        data,
-    } = decodeApproveCheckedInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.ApproveChecked) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !delegate || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            delegate,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated ApproveChecked instruction */
-export interface DecodedApproveCheckedInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        delegate: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode an ApproveChecked instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeApproveCheckedInstructionUnchecked({
-    programId,
-    keys: [account, mint, delegate, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedApproveCheckedInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            delegate,
-            owner,
-            multiSigners,
-        },
-        data: approveCheckedInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/associatedTokenAccount.ts b/token/js/src/instructions/associatedTokenAccount.ts
deleted file mode 100644
index 0b10c30da58..00000000000
--- a/token/js/src/instructions/associatedTokenAccount.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import type { PublicKey } from '@solana/web3.js';
-import { SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-
-/**
- * Construct a CreateAssociatedTokenAccount instruction
- *
- * @param payer                    Payer of the initialization fees
- * @param associatedToken          New associated token account
- * @param owner                    Owner of the new account
- * @param mint                     Token mint account
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createAssociatedTokenAccountInstruction(
-    payer: PublicKey,
-    associatedToken: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    return buildAssociatedTokenAccountInstruction(
-        payer,
-        associatedToken,
-        owner,
-        mint,
-        Buffer.alloc(0),
-        programId,
-        associatedTokenProgramId
-    );
-}
-
-/**
- * Construct a CreateAssociatedTokenAccountIdempotent instruction
- *
- * @param payer                    Payer of the initialization fees
- * @param associatedToken          New associated token account
- * @param owner                    Owner of the new account
- * @param mint                     Token mint account
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createAssociatedTokenAccountIdempotentInstruction(
-    payer: PublicKey,
-    associatedToken: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    return buildAssociatedTokenAccountInstruction(
-        payer,
-        associatedToken,
-        owner,
-        mint,
-        Buffer.from([1]),
-        programId,
-        associatedTokenProgramId
-    );
-}
-
-function buildAssociatedTokenAccountInstruction(
-    payer: PublicKey,
-    associatedToken: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    instructionData: Buffer,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: payer, isSigner: true, isWritable: true },
-        { pubkey: associatedToken, isSigner: false, isWritable: true },
-        { pubkey: owner, isSigner: false, isWritable: false },
-        { pubkey: mint, isSigner: false, isWritable: false },
-        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-        { pubkey: programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-        keys,
-        programId: associatedTokenProgramId,
-        data: instructionData,
-    });
-}
-
-/**
- * Construct a RecoverNested instruction
- *
- * @param nestedAssociatedToken             Nested associated token account (must be owned by `ownerAssociatedToken`)
- * @param nestedMint                        Token mint for the nested associated token account
- * @param destinationAssociatedToken        Wallet's associated token account
- * @param ownerAssociatedToken              Owner associated token account address (must be owned by `owner`)
- * @param ownerMint                         Token mint for the owner associated token account
- * @param owner                             Wallet address for the owner associated token account
- * @param programId                         SPL Token program account
- * @param associatedTokenProgramId          SPL Associated Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createRecoverNestedInstruction(
-    nestedAssociatedToken: PublicKey,
-    nestedMint: PublicKey,
-    destinationAssociatedToken: PublicKey,
-    ownerAssociatedToken: PublicKey,
-    ownerMint: PublicKey,
-    owner: PublicKey,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: nestedAssociatedToken, isSigner: false, isWritable: true },
-        { pubkey: nestedMint, isSigner: false, isWritable: false },
-        { pubkey: destinationAssociatedToken, isSigner: false, isWritable: true },
-        { pubkey: ownerAssociatedToken, isSigner: false, isWritable: true },
-        { pubkey: ownerMint, isSigner: false, isWritable: false },
-        { pubkey: owner, isSigner: true, isWritable: true },
-        { pubkey: programId, isSigner: false, isWritable: false },
-    ];
-
-    return new TransactionInstruction({
-        keys,
-        programId: associatedTokenProgramId,
-        data: Buffer.from([2]),
-    });
-}
diff --git a/token/js/src/instructions/burn.ts b/token/js/src/instructions/burn.ts
deleted file mode 100644
index e9ee079c44f..00000000000
--- a/token/js/src/instructions/burn.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface BurnInstructionData {
-    instruction: TokenInstruction.Burn;
-    amount: bigint;
-}
-
-/** TODO: docs */
-export const burnInstructionData = struct<BurnInstructionData>([u8('instruction'), u64('amount')]);
-
-/**
- * Construct a Burn instruction
- *
- * @param account      Account to burn tokens from
- * @param mint         Mint for the account
- * @param owner        Owner of the account
- * @param amount       Number of tokens to burn
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createBurnInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: true },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(burnInstructionData.span);
-    burnInstructionData.encode(
-        {
-            instruction: TokenInstruction.Burn,
-            amount: BigInt(amount),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid Burn instruction */
-export interface DecodedBurnInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.Burn;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a Burn instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeBurnInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedBurnInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== burnInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, owner, multiSigners },
-        data,
-    } = decodeBurnInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.Burn) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated Burn instruction */
-export interface DecodedBurnInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a Burn instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeBurnInstructionUnchecked({
-    programId,
-    keys: [account, mint, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedBurnInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            multiSigners,
-        },
-        data: burnInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/burnChecked.ts b/token/js/src/instructions/burnChecked.ts
deleted file mode 100644
index 190f60b537e..00000000000
--- a/token/js/src/instructions/burnChecked.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface BurnCheckedInstructionData {
-    instruction: TokenInstruction.BurnChecked;
-    amount: bigint;
-    decimals: number;
-}
-
-/** TODO: docs */
-export const burnCheckedInstructionData = struct<BurnCheckedInstructionData>([
-    u8('instruction'),
-    u64('amount'),
-    u8('decimals'),
-]);
-
-/**
- * Construct a BurnChecked instruction
- *
- * @param mint         Mint for the account
- * @param account      Account to burn tokens from
- * @param owner        Owner of the account
- * @param amount       Number of tokens to burn
- * @param decimals     Number of decimals in burn amount
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createBurnCheckedInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: true },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(burnCheckedInstructionData.span);
-    burnCheckedInstructionData.encode(
-        {
-            instruction: TokenInstruction.BurnChecked,
-            amount: BigInt(amount),
-            decimals,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid BurnChecked instruction */
-export interface DecodedBurnCheckedInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.BurnChecked;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a BurnChecked instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeBurnCheckedInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedBurnCheckedInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== burnCheckedInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, owner, multiSigners },
-        data,
-    } = decodeBurnCheckedInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.BurnChecked) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated BurnChecked instruction */
-export interface DecodedBurnCheckedInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a BurnChecked instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeBurnCheckedInstructionUnchecked({
-    programId,
-    keys: [account, mint, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedBurnCheckedInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            multiSigners,
-        },
-        data: burnCheckedInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/closeAccount.ts b/token/js/src/instructions/closeAccount.ts
deleted file mode 100644
index 9615925b0bb..00000000000
--- a/token/js/src/instructions/closeAccount.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface CloseAccountInstructionData {
-    instruction: TokenInstruction.CloseAccount;
-}
-
-/** TODO: docs */
-export const closeAccountInstructionData = struct<CloseAccountInstructionData>([u8('instruction')]);
-
-/**
- * Construct a CloseAccount instruction
- *
- * @param account      Account to close
- * @param destination  Account to receive the remaining balance of the closed account
- * @param authority    Account close authority
- * @param multiSigners Signing accounts if `authority` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createCloseAccountInstruction(
-    account: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(closeAccountInstructionData.span);
-    closeAccountInstructionData.encode({ instruction: TokenInstruction.CloseAccount }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid CloseAccount instruction */
-export interface DecodedCloseAccountInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.CloseAccount;
-    };
-}
-
-/**
- * Decode a CloseAccount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeCloseAccountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedCloseAccountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== closeAccountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, destination, authority, multiSigners },
-        data,
-    } = decodeCloseAccountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.CloseAccount) throw new TokenInvalidInstructionTypeError();
-    if (!account || !destination || !authority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated CloseAccount instruction */
-export interface DecodedCloseAccountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        destination: AccountMeta | undefined;
-        authority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode a CloseAccount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeCloseAccountInstructionUnchecked({
-    programId,
-    keys: [account, destination, authority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedCloseAccountInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data: closeAccountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/createNativeMint.ts b/token/js/src/instructions/createNativeMint.ts
deleted file mode 100644
index 57f535aa2d1..00000000000
--- a/token/js/src/instructions/createNativeMint.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { PublicKey } from '@solana/web3.js';
-import { SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { NATIVE_MINT_2022, programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../constants.js';
-import { TokenUnsupportedInstructionError } from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface CreateNativeMintInstructionData {
-    instruction: TokenInstruction.CreateNativeMint;
-}
-
-/** TODO: docs */
-export const createNativeMintInstructionData = struct<CreateNativeMintInstructionData>([u8('instruction')]);
-
-/**
- * Construct a CreateNativeMint instruction
- *
- * @param account   New token account
- * @param mint      Mint account
- * @param owner     Owner of the new account
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createCreateNativeMintInstruction(
-    payer: PublicKey,
-    nativeMintId = NATIVE_MINT_2022,
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [
-        { pubkey: payer, isSigner: true, isWritable: true },
-        { pubkey: nativeMintId, isSigner: false, isWritable: true },
-        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-    ];
-
-    const data = Buffer.alloc(createNativeMintInstructionData.span);
-    createNativeMintInstructionData.encode({ instruction: TokenInstruction.CreateNativeMint }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/instructions/decode.ts b/token/js/src/instructions/decode.ts
deleted file mode 100644
index 6dd469ee7c5..00000000000
--- a/token/js/src/instructions/decode.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-import { u8 } from '@solana/buffer-layout';
-import type { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { TokenInvalidInstructionDataError, TokenInvalidInstructionTypeError } from '../errors.js';
-import type { DecodedAmountToUiAmountInstruction } from './amountToUiAmount.js';
-import { decodeAmountToUiAmountInstruction } from './amountToUiAmount.js';
-import type { DecodedApproveInstruction } from './approve.js';
-import { decodeApproveInstruction } from './approve.js';
-import type { DecodedApproveCheckedInstruction } from './approveChecked.js';
-import { decodeApproveCheckedInstruction } from './approveChecked.js';
-import type { DecodedBurnInstruction } from './burn.js';
-import { decodeBurnInstruction } from './burn.js';
-import type { DecodedBurnCheckedInstruction } from './burnChecked.js';
-import { decodeBurnCheckedInstruction } from './burnChecked.js';
-import type { DecodedCloseAccountInstruction } from './closeAccount.js';
-import { decodeCloseAccountInstruction } from './closeAccount.js';
-import type { DecodedFreezeAccountInstruction } from './freezeAccount.js';
-import { decodeFreezeAccountInstruction } from './freezeAccount.js';
-import type { DecodedInitializeAccountInstruction } from './initializeAccount.js';
-import { decodeInitializeAccountInstruction } from './initializeAccount.js';
-import type { DecodedInitializeAccount2Instruction } from './initializeAccount2.js';
-import { decodeInitializeAccount2Instruction } from './initializeAccount2.js';
-import type { DecodedInitializeAccount3Instruction } from './initializeAccount3.js';
-import { decodeInitializeAccount3Instruction } from './initializeAccount3.js';
-import type { DecodedInitializeMintInstruction } from './initializeMint.js';
-import { decodeInitializeMintInstruction } from './initializeMint.js';
-import type { DecodedInitializeMint2Instruction } from './initializeMint2.js';
-import { decodeInitializeMint2Instruction } from './initializeMint2.js';
-import type { DecodedInitializeMultisigInstruction } from './initializeMultisig.js';
-import { decodeInitializeMultisigInstruction } from './initializeMultisig.js';
-import type { DecodedMintToInstruction } from './mintTo.js';
-import { decodeMintToInstruction } from './mintTo.js';
-import type { DecodedMintToCheckedInstruction } from './mintToChecked.js';
-import { decodeMintToCheckedInstruction } from './mintToChecked.js';
-import type { DecodedRevokeInstruction } from './revoke.js';
-import { decodeRevokeInstruction } from './revoke.js';
-import type { DecodedSetAuthorityInstruction } from './setAuthority.js';
-import { decodeSetAuthorityInstruction } from './setAuthority.js';
-import type { DecodedSyncNativeInstruction } from './syncNative.js';
-import { decodeSyncNativeInstruction } from './syncNative.js';
-import type { DecodedThawAccountInstruction } from './thawAccount.js';
-import { decodeThawAccountInstruction } from './thawAccount.js';
-import type { DecodedTransferInstruction } from './transfer.js';
-import { decodeTransferInstruction } from './transfer.js';
-import type { DecodedTransferCheckedInstruction } from './transferChecked.js';
-import { decodeTransferCheckedInstruction } from './transferChecked.js';
-import { TokenInstruction } from './types.js';
-import type { DecodedUiAmountToAmountInstruction } from './uiAmountToAmount.js';
-import { decodeUiAmountToAmountInstruction } from './uiAmountToAmount.js';
-
-/** TODO: docs */
-export type DecodedInstruction =
-    | DecodedInitializeMintInstruction
-    | DecodedInitializeAccountInstruction
-    | DecodedInitializeMultisigInstruction
-    | DecodedTransferInstruction
-    | DecodedApproveInstruction
-    | DecodedRevokeInstruction
-    | DecodedSetAuthorityInstruction
-    | DecodedMintToInstruction
-    | DecodedBurnInstruction
-    | DecodedCloseAccountInstruction
-    | DecodedFreezeAccountInstruction
-    | DecodedThawAccountInstruction
-    | DecodedTransferCheckedInstruction
-    | DecodedApproveCheckedInstruction
-    | DecodedMintToCheckedInstruction
-    | DecodedBurnCheckedInstruction
-    | DecodedInitializeAccount2Instruction
-    | DecodedSyncNativeInstruction
-    | DecodedInitializeAccount3Instruction
-    | DecodedInitializeMint2Instruction
-    | DecodedAmountToUiAmountInstruction
-    | DecodedUiAmountToAmountInstruction
-    // | DecodedInitializeMultisig2Instruction
-    // TODO: implement ^ and remove `never`
-    | never;
-
-/** TODO: docs */
-export function decodeInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInstruction {
-    if (!instruction.data.length) throw new TokenInvalidInstructionDataError();
-
-    const type = u8().decode(instruction.data);
-    if (type === TokenInstruction.InitializeMint) return decodeInitializeMintInstruction(instruction, programId);
-    if (type === TokenInstruction.InitializeAccount) return decodeInitializeAccountInstruction(instruction, programId);
-    if (type === TokenInstruction.InitializeMultisig)
-        return decodeInitializeMultisigInstruction(instruction, programId);
-    if (type === TokenInstruction.Transfer) return decodeTransferInstruction(instruction, programId);
-    if (type === TokenInstruction.Approve) return decodeApproveInstruction(instruction, programId);
-    if (type === TokenInstruction.Revoke) return decodeRevokeInstruction(instruction, programId);
-    if (type === TokenInstruction.SetAuthority) return decodeSetAuthorityInstruction(instruction, programId);
-    if (type === TokenInstruction.MintTo) return decodeMintToInstruction(instruction, programId);
-    if (type === TokenInstruction.Burn) return decodeBurnInstruction(instruction, programId);
-    if (type === TokenInstruction.CloseAccount) return decodeCloseAccountInstruction(instruction, programId);
-    if (type === TokenInstruction.FreezeAccount) return decodeFreezeAccountInstruction(instruction, programId);
-    if (type === TokenInstruction.ThawAccount) return decodeThawAccountInstruction(instruction, programId);
-    if (type === TokenInstruction.TransferChecked) return decodeTransferCheckedInstruction(instruction, programId);
-    if (type === TokenInstruction.ApproveChecked) return decodeApproveCheckedInstruction(instruction, programId);
-    if (type === TokenInstruction.MintToChecked) return decodeMintToCheckedInstruction(instruction, programId);
-    if (type === TokenInstruction.BurnChecked) return decodeBurnCheckedInstruction(instruction, programId);
-    if (type === TokenInstruction.InitializeAccount2)
-        return decodeInitializeAccount2Instruction(instruction, programId);
-    if (type === TokenInstruction.SyncNative) return decodeSyncNativeInstruction(instruction, programId);
-    if (type === TokenInstruction.InitializeAccount3)
-        return decodeInitializeAccount3Instruction(instruction, programId);
-    if (type === TokenInstruction.InitializeMint2) return decodeInitializeMint2Instruction(instruction, programId);
-    if (type === TokenInstruction.AmountToUiAmount) return decodeAmountToUiAmountInstruction(instruction, programId);
-    if (type === TokenInstruction.UiAmountToAmount) return decodeUiAmountToAmountInstruction(instruction, programId);
-    // TODO: implement
-    if (type === TokenInstruction.InitializeMultisig2) throw new TokenInvalidInstructionTypeError();
-
-    throw new TokenInvalidInstructionTypeError();
-}
-
-/** TODO: docs */
-export function isInitializeMintInstruction(decoded: DecodedInstruction): decoded is DecodedInitializeMintInstruction {
-    return decoded.data.instruction === TokenInstruction.InitializeMint;
-}
-
-/** TODO: docs */
-export function isInitializeAccountInstruction(
-    decoded: DecodedInstruction
-): decoded is DecodedInitializeAccountInstruction {
-    return decoded.data.instruction === TokenInstruction.InitializeAccount;
-}
-
-/** TODO: docs */
-export function isInitializeMultisigInstruction(
-    decoded: DecodedInstruction
-): decoded is DecodedInitializeMultisigInstruction {
-    return decoded.data.instruction === TokenInstruction.InitializeMultisig;
-}
-
-/** TODO: docs */
-export function isTransferInstruction(decoded: DecodedInstruction): decoded is DecodedTransferInstruction {
-    return decoded.data.instruction === TokenInstruction.Transfer;
-}
-
-/** TODO: docs */
-export function isApproveInstruction(decoded: DecodedInstruction): decoded is DecodedApproveInstruction {
-    return decoded.data.instruction === TokenInstruction.Approve;
-}
-
-/** TODO: docs */
-export function isRevokeInstruction(decoded: DecodedInstruction): decoded is DecodedRevokeInstruction {
-    return decoded.data.instruction === TokenInstruction.Revoke;
-}
-
-/** TODO: docs */
-export function isSetAuthorityInstruction(decoded: DecodedInstruction): decoded is DecodedSetAuthorityInstruction {
-    return decoded.data.instruction === TokenInstruction.SetAuthority;
-}
-
-/** TODO: docs */
-export function isMintToInstruction(decoded: DecodedInstruction): decoded is DecodedMintToInstruction {
-    return decoded.data.instruction === TokenInstruction.MintTo;
-}
-
-/** TODO: docs */
-export function isBurnInstruction(decoded: DecodedInstruction): decoded is DecodedBurnInstruction {
-    return decoded.data.instruction === TokenInstruction.Burn;
-}
-
-/** TODO: docs */
-export function isCloseAccountInstruction(decoded: DecodedInstruction): decoded is DecodedCloseAccountInstruction {
-    return decoded.data.instruction === TokenInstruction.CloseAccount;
-}
-
-/** TODO: docs */
-export function isFreezeAccountInstruction(decoded: DecodedInstruction): decoded is DecodedFreezeAccountInstruction {
-    return decoded.data.instruction === TokenInstruction.FreezeAccount;
-}
-
-/** TODO: docs */
-export function isThawAccountInstruction(decoded: DecodedInstruction): decoded is DecodedThawAccountInstruction {
-    return decoded.data.instruction === TokenInstruction.ThawAccount;
-}
-
-/** TODO: docs */
-export function isTransferCheckedInstruction(
-    decoded: DecodedInstruction
-): decoded is DecodedTransferCheckedInstruction {
-    return decoded.data.instruction === TokenInstruction.TransferChecked;
-}
-
-/** TODO: docs */
-export function isApproveCheckedInstruction(decoded: DecodedInstruction): decoded is DecodedApproveCheckedInstruction {
-    return decoded.data.instruction === TokenInstruction.ApproveChecked;
-}
-
-/** TODO: docs */
-export function isMintToCheckedInstruction(decoded: DecodedInstruction): decoded is DecodedMintToCheckedInstruction {
-    return decoded.data.instruction === TokenInstruction.MintToChecked;
-}
-
-/** TODO: docs */
-export function isBurnCheckedInstruction(decoded: DecodedInstruction): decoded is DecodedBurnCheckedInstruction {
-    return decoded.data.instruction === TokenInstruction.BurnChecked;
-}
-
-/** TODO: docs */
-export function isInitializeAccount2Instruction(
-    decoded: DecodedInstruction
-): decoded is DecodedInitializeAccount2Instruction {
-    return decoded.data.instruction === TokenInstruction.InitializeAccount2;
-}
-
-/** TODO: docs */
-export function isSyncNativeInstruction(decoded: DecodedInstruction): decoded is DecodedSyncNativeInstruction {
-    return decoded.data.instruction === TokenInstruction.SyncNative;
-}
-
-/** TODO: docs */
-export function isInitializeAccount3Instruction(
-    decoded: DecodedInstruction
-): decoded is DecodedInitializeAccount3Instruction {
-    return decoded.data.instruction === TokenInstruction.InitializeAccount3;
-}
-
-/** TODO: docs, implement */
-// export function isInitializeMultisig2Instruction(
-//     decoded: DecodedInstruction
-// ): decoded is DecodedInitializeMultisig2Instruction {
-//     return decoded.data.instruction === TokenInstruction.InitializeMultisig2;
-// }
-
-/** TODO: docs */
-export function isInitializeMint2Instruction(
-    decoded: DecodedInstruction
-): decoded is DecodedInitializeMint2Instruction {
-    return decoded.data.instruction === TokenInstruction.InitializeMint2;
-}
-
-/** TODO: docs */
-export function isAmountToUiAmountInstruction(
-    decoded: DecodedInstruction
-): decoded is DecodedAmountToUiAmountInstruction {
-    return decoded.data.instruction === TokenInstruction.AmountToUiAmount;
-}
-
-/** TODO: docs */
-export function isUiamountToAmountInstruction(
-    decoded: DecodedInstruction
-): decoded is DecodedUiAmountToAmountInstruction {
-    return decoded.data.instruction === TokenInstruction.UiAmountToAmount;
-}
diff --git a/token/js/src/instructions/freezeAccount.ts b/token/js/src/instructions/freezeAccount.ts
deleted file mode 100644
index 299301b7f7f..00000000000
--- a/token/js/src/instructions/freezeAccount.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface FreezeAccountInstructionData {
-    instruction: TokenInstruction.FreezeAccount;
-}
-
-/** TODO: docs */
-export const freezeAccountInstructionData = struct<FreezeAccountInstructionData>([u8('instruction')]);
-
-/**
- * Construct a FreezeAccount instruction
- *
- * @param account      Account to freeze
- * @param mint         Mint account
- * @param authority    Mint freeze authority
- * @param multiSigners Signing accounts if `authority` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createFreezeAccountInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-        ],
-        authority,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(freezeAccountInstructionData.span);
-    freezeAccountInstructionData.encode({ instruction: TokenInstruction.FreezeAccount }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid FreezeAccount instruction */
-export interface DecodedFreezeAccountInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        authority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.FreezeAccount;
-    };
-}
-
-/**
- * Decode a FreezeAccount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeFreezeAccountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedFreezeAccountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== freezeAccountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, authority, multiSigners },
-        data,
-    } = decodeFreezeAccountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.FreezeAccount) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !authority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            authority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated FreezeAccount instruction */
-export interface DecodedFreezeAccountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        authority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode a FreezeAccount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeFreezeAccountInstructionUnchecked({
-    programId,
-    keys: [account, mint, authority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedFreezeAccountInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            authority,
-            multiSigners,
-        },
-        data: freezeAccountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/index.ts b/token/js/src/instructions/index.ts
deleted file mode 100644
index 9ceabb71b64..00000000000
--- a/token/js/src/instructions/index.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-export {
-    createInitializeInstruction,
-    createUpdateFieldInstruction,
-    createRemoveKeyInstruction,
-    createUpdateAuthorityInstruction,
-    createEmitInstruction,
-} from '@solana/spl-token-metadata';
-export {
-    createInitializeGroupInstruction,
-    createUpdateGroupMaxSizeInstruction,
-    createUpdateGroupAuthorityInstruction,
-    createInitializeMemberInstruction,
-} from '@solana/spl-token-group';
-
-export * from './associatedTokenAccount.js';
-export * from './decode.js';
-export * from './types.js';
-
-export * from './initializeMint.js'; //                 0
-export * from './initializeAccount.js'; //              1
-export * from './initializeMultisig.js'; //             2
-export * from './transfer.js'; //                       3
-export * from './approve.js'; //                        4
-export * from './revoke.js'; //                         5
-export * from './setAuthority.js'; //                   6
-export * from './mintTo.js'; //                         7
-export * from './burn.js'; //                           8
-export * from './closeAccount.js'; //                   9
-export * from './freezeAccount.js'; //                 10
-export * from './thawAccount.js'; //                   11
-export * from './transferChecked.js'; //               12
-export * from './approveChecked.js'; //                13
-export * from './mintToChecked.js'; //                 14
-export * from './burnChecked.js'; //                   15
-export * from './initializeAccount2.js'; //            16
-export * from './syncNative.js'; //                    17
-export * from './initializeAccount3.js'; //            18
-export * from './initializeMultisig2.js'; //           19
-export * from './initializeMint2.js'; //               20
-export * from './initializeImmutableOwner.js'; //      22
-export * from './amountToUiAmount.js'; //              23
-export * from './uiAmountToAmount.js'; //              24
-export * from './initializeMintCloseAuthority.js'; //  25
-export * from './reallocate.js'; //                    29
-export * from './createNativeMint.js'; //              31
-export * from './initializeNonTransferableMint.js'; // 32
-export * from './initializePermanentDelegate.js'; //   35
diff --git a/token/js/src/instructions/initializeAccount.ts b/token/js/src/instructions/initializeAccount.ts
deleted file mode 100644
index f4ce5bd2fb6..00000000000
--- a/token/js/src/instructions/initializeAccount.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface InitializeAccountInstructionData {
-    instruction: TokenInstruction.InitializeAccount;
-}
-
-/** TODO: docs */
-export const initializeAccountInstructionData = struct<InitializeAccountInstructionData>([u8('instruction')]);
-
-/**
- * Construct an InitializeAccount instruction
- *
- * @param account   New token account
- * @param mint      Mint account
- * @param owner     Owner of the new account
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeAccountInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    owner: PublicKey,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: mint, isSigner: false, isWritable: false },
-        { pubkey: owner, isSigner: false, isWritable: false },
-        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-    ];
-
-    const data = Buffer.alloc(initializeAccountInstructionData.span);
-    initializeAccountInstructionData.encode({ instruction: TokenInstruction.InitializeAccount }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeAccount instruction */
-export interface DecodedInitializeAccountInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        owner: AccountMeta;
-        rent: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeAccount;
-    };
-}
-
-/**
- * Decode an InitializeAccount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeAccountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeAccountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeAccountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, owner, rent },
-        data,
-    } = decodeInitializeAccountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeAccount) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !owner || !rent) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            rent,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeAccount instruction */
-export interface DecodedInitializeAccountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        rent: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode an InitializeAccount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeAccountInstructionUnchecked({
-    programId,
-    keys: [account, mint, owner, rent],
-    data,
-}: TransactionInstruction): DecodedInitializeAccountInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            owner,
-            rent,
-        },
-        data: initializeAccountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/initializeAccount2.ts b/token/js/src/instructions/initializeAccount2.ts
deleted file mode 100644
index 66893c12fe3..00000000000
--- a/token/js/src/instructions/initializeAccount2.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-export interface InitializeAccount2InstructionData {
-    instruction: TokenInstruction.InitializeAccount2;
-    owner: PublicKey;
-}
-
-export const initializeAccount2InstructionData = struct<InitializeAccount2InstructionData>([
-    u8('instruction'),
-    publicKey('owner'),
-]);
-
-/**
- * Construct an InitializeAccount2 instruction
- *
- * @param account   New token account
- * @param mint      Mint account
- * @param owner     New account's owner/multisignature
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeAccount2Instruction(
-    account: PublicKey,
-    mint: PublicKey,
-    owner: PublicKey,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: mint, isSigner: false, isWritable: false },
-        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-    ];
-    const data = Buffer.alloc(initializeAccount2InstructionData.span);
-    initializeAccount2InstructionData.encode({ instruction: TokenInstruction.InitializeAccount2, owner }, data);
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeAccount2 instruction */
-export interface DecodedInitializeAccount2Instruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        rent: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeAccount2;
-        owner: PublicKey;
-    };
-}
-
-/**
- * Decode an InitializeAccount2 instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeAccount2Instruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeAccount2Instruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeAccount2InstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, rent },
-        data,
-    } = decodeInitializeAccount2InstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeAccount2) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !rent) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            rent,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeAccount2 instruction */
-export interface DecodedInitializeAccount2InstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        rent: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        owner: PublicKey;
-    };
-}
-
-/**
- * Decode an InitializeAccount2 instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeAccount2InstructionUnchecked({
-    programId,
-    keys: [account, mint, rent],
-    data,
-}: TransactionInstruction): DecodedInitializeAccount2InstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            rent,
-        },
-        data: initializeAccount2InstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/initializeAccount3.ts b/token/js/src/instructions/initializeAccount3.ts
deleted file mode 100644
index 66ef3d9c644..00000000000
--- a/token/js/src/instructions/initializeAccount3.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-export interface InitializeAccount3InstructionData {
-    instruction: TokenInstruction.InitializeAccount3;
-    owner: PublicKey;
-}
-
-export const initializeAccount3InstructionData = struct<InitializeAccount3InstructionData>([
-    u8('instruction'),
-    publicKey('owner'),
-]);
-
-/**
- * Construct an InitializeAccount3 instruction
- *
- * @param account   New token account
- * @param mint      Mint account
- * @param owner     New account's owner/multisignature
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeAccount3Instruction(
-    account: PublicKey,
-    mint: PublicKey,
-    owner: PublicKey,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: mint, isSigner: false, isWritable: false },
-    ];
-    const data = Buffer.alloc(initializeAccount3InstructionData.span);
-    initializeAccount3InstructionData.encode({ instruction: TokenInstruction.InitializeAccount3, owner }, data);
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeAccount3 instruction */
-export interface DecodedInitializeAccount3Instruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeAccount3;
-        owner: PublicKey;
-    };
-}
-
-/**
- * Decode an InitializeAccount3 instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeAccount3Instruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeAccount3Instruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeAccount3InstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint },
-        data,
-    } = decodeInitializeAccount3InstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeAccount3) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeAccount3 instruction */
-export interface DecodedInitializeAccount3InstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        owner: PublicKey;
-    };
-}
-
-/**
- * Decode an InitializeAccount3 instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeAccount3InstructionUnchecked({
-    programId,
-    keys: [account, mint],
-    data,
-}: TransactionInstruction): DecodedInitializeAccount3InstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-        },
-        data: initializeAccount3InstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/initializeImmutableOwner.ts b/token/js/src/instructions/initializeImmutableOwner.ts
deleted file mode 100644
index 14c8591f2d0..00000000000
--- a/token/js/src/instructions/initializeImmutableOwner.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** Deserialized instruction for the initiation of an immutable owner account */
-export interface InitializeImmutableOwnerInstructionData {
-    instruction: TokenInstruction.InitializeImmutableOwner;
-}
-
-/** The struct that represents the instruction data as it is read by the program */
-export const initializeImmutableOwnerInstructionData = struct<InitializeImmutableOwnerInstructionData>([
-    u8('instruction'),
-]);
-
-/**
- * Construct an InitializeImmutableOwner instruction
- *
- * @param account           Immutable Owner Account
- * @param programId         SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeImmutableOwnerInstruction(
-    account: PublicKey,
-    programId: PublicKey
-): TransactionInstruction {
-    const keys = [{ pubkey: account, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeImmutableOwnerInstructionData.span);
-    initializeImmutableOwnerInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeImmutableOwner,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeImmutableOwner instruction */
-export interface DecodedInitializeImmutableOwnerInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeImmutableOwner;
-    };
-}
-
-/**
- * Decode an InitializeImmutableOwner instruction and validate it
- *
- * @param instruction InitializeImmutableOwner instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeImmutableOwnerInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedInitializeImmutableOwnerInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeImmutableOwnerInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account },
-        data,
-    } = decodeInitializeImmutableOwnerInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeImmutableOwner) throw new TokenInvalidInstructionTypeError();
-    if (!account) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            account,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeImmutableOwner instruction */
-export interface DecodedInitializeImmutableOwnerInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode an InitializeImmutableOwner instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeImmutableOwnerInstructionUnchecked({
-    programId,
-    keys: [account],
-    data,
-}: TransactionInstruction): DecodedInitializeImmutableOwnerInstructionUnchecked {
-    const { instruction } = initializeImmutableOwnerInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            account: account,
-        },
-        data: {
-            instruction,
-        },
-    };
-}
diff --git a/token/js/src/instructions/initializeMint.ts b/token/js/src/instructions/initializeMint.ts
deleted file mode 100644
index b1382dc4968..00000000000
--- a/token/js/src/instructions/initializeMint.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-import { COptionPublicKeyLayout } from '../serialization.js';
-
-/** TODO: docs */
-export interface InitializeMintInstructionData {
-    instruction: TokenInstruction.InitializeMint;
-    decimals: number;
-    mintAuthority: PublicKey;
-    freezeAuthority: PublicKey | null;
-}
-
-/** TODO: docs */
-export const initializeMintInstructionData = struct<InitializeMintInstructionData>([
-    u8('instruction'),
-    u8('decimals'),
-    publicKey('mintAuthority'),
-    new COptionPublicKeyLayout('freezeAuthority'),
-]);
-
-/**
- * Construct an InitializeMint instruction
- *
- * @param mint            Token mint account
- * @param decimals        Number of decimals in token account amounts
- * @param mintAuthority   Minting authority
- * @param freezeAuthority Optional authority that can freeze token accounts
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeMintInstruction(
-    mint: PublicKey,
-    decimals: number,
-    mintAuthority: PublicKey,
-    freezeAuthority: PublicKey | null,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: mint, isSigner: false, isWritable: true },
-        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-    ];
-
-    const data = Buffer.alloc(initializeMintInstructionData.span);
-    initializeMintInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeMint,
-            decimals,
-            mintAuthority,
-            freezeAuthority,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeMint instruction */
-export interface DecodedInitializeMintInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        rent: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeMint;
-        decimals: number;
-        mintAuthority: PublicKey;
-        freezeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMint instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeMintInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeMintInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeMintInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, rent },
-        data,
-    } = decodeInitializeMintInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeMint) throw new TokenInvalidInstructionTypeError();
-    if (!mint || !rent) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            mint,
-            rent,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeMint instruction */
-export interface DecodedInitializeMintInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-        rent: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        decimals: number;
-        mintAuthority: PublicKey;
-        freezeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMint instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeMintInstructionUnchecked({
-    programId,
-    keys: [mint, rent],
-    data,
-}: TransactionInstruction): DecodedInitializeMintInstructionUnchecked {
-    const { instruction, decimals, mintAuthority, freezeAuthority } = initializeMintInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-            rent,
-        },
-        data: {
-            instruction,
-            decimals,
-            mintAuthority,
-            freezeAuthority,
-        },
-    };
-}
diff --git a/token/js/src/instructions/initializeMint2.ts b/token/js/src/instructions/initializeMint2.ts
deleted file mode 100644
index 6d34aa28970..00000000000
--- a/token/js/src/instructions/initializeMint2.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-import { COptionPublicKeyLayout } from '../serialization.js';
-
-/** TODO: docs */
-export interface InitializeMint2InstructionData {
-    instruction: TokenInstruction.InitializeMint2;
-    decimals: number;
-    mintAuthority: PublicKey;
-    freezeAuthority: PublicKey | null;
-}
-
-/** TODO: docs */
-export const initializeMint2InstructionData = struct<InitializeMint2InstructionData>([
-    u8('instruction'),
-    u8('decimals'),
-    publicKey('mintAuthority'),
-    new COptionPublicKeyLayout('freezeAuthority'),
-]);
-
-/**
- * Construct an InitializeMint2 instruction
- *
- * @param mint            Token mint account
- * @param decimals        Number of decimals in token account amounts
- * @param mintAuthority   Minting authority
- * @param freezeAuthority Optional authority that can freeze token accounts
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeMint2Instruction(
-    mint: PublicKey,
-    decimals: number,
-    mintAuthority: PublicKey,
-    freezeAuthority: PublicKey | null,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeMint2InstructionData.span);
-    initializeMint2InstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeMint2,
-            decimals,
-            mintAuthority,
-            freezeAuthority,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeMint2 instruction */
-export interface DecodedInitializeMint2Instruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeMint2;
-        decimals: number;
-        mintAuthority: PublicKey;
-        freezeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMint2 instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeMint2Instruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeMint2Instruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeMint2InstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeInitializeMint2InstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeMint2) throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeMint2 instruction */
-export interface DecodedInitializeMint2InstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        decimals: number;
-        mintAuthority: PublicKey;
-        freezeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMint2 instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeMint2InstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedInitializeMint2InstructionUnchecked {
-    const { instruction, decimals, mintAuthority, freezeAuthority } = initializeMint2InstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: {
-            instruction,
-            decimals,
-            mintAuthority,
-            freezeAuthority,
-        },
-    };
-}
diff --git a/token/js/src/instructions/initializeMintCloseAuthority.ts b/token/js/src/instructions/initializeMintCloseAuthority.ts
deleted file mode 100644
index bb26bb382aa..00000000000
--- a/token/js/src/instructions/initializeMintCloseAuthority.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-    TokenUnsupportedInstructionError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-import { COptionPublicKeyLayout } from '../serialization.js';
-
-/** TODO: docs */
-export interface InitializeMintCloseAuthorityInstructionData {
-    instruction: TokenInstruction.InitializeMintCloseAuthority;
-    closeAuthority: PublicKey | null;
-}
-
-/** TODO: docs */
-export const initializeMintCloseAuthorityInstructionData = struct<InitializeMintCloseAuthorityInstructionData>([
-    u8('instruction'),
-    new COptionPublicKeyLayout('closeAuthority'),
-]);
-
-/**
- * Construct an InitializeMintCloseAuthority instruction
- *
- * @param mint            Token mint account
- * @param closeAuthority  Optional authority that can close the mint
- * @param programId       SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeMintCloseAuthorityInstruction(
-    mint: PublicKey,
-    closeAuthority: PublicKey | null,
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeMintCloseAuthorityInstructionData.span);
-    initializeMintCloseAuthorityInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeMintCloseAuthority,
-            closeAuthority,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeMintCloseAuthority instruction */
-export interface DecodedInitializeMintCloseAuthorityInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializeMintCloseAuthority;
-        closeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMintCloseAuthority instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeMintCloseAuthorityInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedInitializeMintCloseAuthorityInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeMintCloseAuthorityInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeInitializeMintCloseAuthorityInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeMintCloseAuthority)
-        throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeMintCloseAuthority instruction */
-export interface DecodedInitializeMintCloseAuthorityInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        closeAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializeMintCloseAuthority instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeMintCloseAuthorityInstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedInitializeMintCloseAuthorityInstructionUnchecked {
-    const { instruction, closeAuthority } = initializeMintCloseAuthorityInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: {
-            instruction,
-            closeAuthority,
-        },
-    };
-}
diff --git a/token/js/src/instructions/initializeMultisig.ts b/token/js/src/instructions/initializeMultisig.ts
deleted file mode 100644
index af10c421ea7..00000000000
--- a/token/js/src/instructions/initializeMultisig.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, Signer } from '@solana/web3.js';
-import { PublicKey, SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface InitializeMultisigInstructionData {
-    instruction: TokenInstruction.InitializeMultisig;
-    m: number;
-}
-
-/** TODO: docs */
-export const initializeMultisigInstructionData = struct<InitializeMultisigInstructionData>([
-    u8('instruction'),
-    u8('m'),
-]);
-
-/**
- * Construct an InitializeMultisig instruction
- *
- * @param account   Multisig account
- * @param signers   Full set of signers
- * @param m         Number of required signatures
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeMultisigInstruction(
-    account: PublicKey,
-    signers: (Signer | PublicKey)[],
-    m: number,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
-    ];
-    for (const signer of signers) {
-        keys.push({
-            pubkey: signer instanceof PublicKey ? signer : signer.publicKey,
-            isSigner: false,
-            isWritable: false,
-        });
-    }
-
-    const data = Buffer.alloc(initializeMultisigInstructionData.span);
-    initializeMultisigInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeMultisig,
-            m,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializeMultisig instruction */
-export interface DecodedInitializeMultisigInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        rent: AccountMeta;
-        signers: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.InitializeMultisig;
-        m: number;
-    };
-}
-
-/**
- * Decode an InitializeMultisig instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializeMultisigInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedInitializeMultisigInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializeMultisigInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, rent, signers },
-        data,
-    } = decodeInitializeMultisigInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializeMultisig) throw new TokenInvalidInstructionTypeError();
-    if (!account || !rent || !signers.length) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            rent,
-            signers,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializeMultisig instruction */
-export interface DecodedInitializeMultisigInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        rent: AccountMeta | undefined;
-        signers: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        m: number;
-    };
-}
-
-/**
- * Decode an InitializeMultisig instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializeMultisigInstructionUnchecked({
-    programId,
-    keys: [account, rent, ...signers],
-    data,
-}: TransactionInstruction): DecodedInitializeMultisigInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            rent,
-            signers,
-        },
-        data: initializeMultisigInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/initializeMultisig2.ts b/token/js/src/instructions/initializeMultisig2.ts
deleted file mode 100644
index 434426c176f..00000000000
--- a/token/js/src/instructions/initializeMultisig2.ts
+++ /dev/null
@@ -1 +0,0 @@
-export {}; // TODO: implement
diff --git a/token/js/src/instructions/initializeNonTransferableMint.ts b/token/js/src/instructions/initializeNonTransferableMint.ts
deleted file mode 100644
index b9f62ae360f..00000000000
--- a/token/js/src/instructions/initializeNonTransferableMint.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions } from '../constants.js';
-import { TokenUnsupportedInstructionError } from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** Deserialized instruction for the initiation of an immutable owner account */
-export interface InitializeNonTransferableMintInstructionData {
-    instruction: TokenInstruction.InitializeNonTransferableMint;
-}
-
-/** The struct that represents the instruction data as it is read by the program */
-export const initializeNonTransferableMintInstructionData = struct<InitializeNonTransferableMintInstructionData>([
-    u8('instruction'),
-]);
-
-/**
- * Construct an InitializeNonTransferableMint instruction
- *
- * @param mint           Mint Account to make non-transferable
- * @param programId         SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializeNonTransferableMintInstruction(
-    mint: PublicKey,
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializeNonTransferableMintInstructionData.span);
-    initializeNonTransferableMintInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializeNonTransferableMint,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/instructions/initializePermanentDelegate.ts b/token/js/src/instructions/initializePermanentDelegate.ts
deleted file mode 100644
index 50bcb4fa439..00000000000
--- a/token/js/src/instructions/initializePermanentDelegate.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-    TokenUnsupportedInstructionError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface InitializePermanentDelegateInstructionData {
-    instruction: TokenInstruction.InitializePermanentDelegate;
-    delegate: PublicKey;
-}
-
-/** TODO: docs */
-export const initializePermanentDelegateInstructionData = struct<InitializePermanentDelegateInstructionData>([
-    u8('instruction'),
-    publicKey('delegate'),
-]);
-
-/**
- * Construct an InitializePermanentDelegate instruction
- *
- * @param mint               Token mint account
- * @param permanentDelegate  Authority that may sign for `Transfer`s and `Burn`s on any account
- * @param programId          SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createInitializePermanentDelegateInstruction(
-    mint: PublicKey,
-    permanentDelegate: PublicKey | null,
-    programId: PublicKey
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(initializePermanentDelegateInstructionData.span);
-    initializePermanentDelegateInstructionData.encode(
-        {
-            instruction: TokenInstruction.InitializePermanentDelegate,
-            delegate: permanentDelegate || new PublicKey(0),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid InitializePermanentDelegate instruction */
-export interface DecodedInitializePermanentDelegateInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.InitializePermanentDelegate;
-        delegate: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializePermanentDelegate instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeInitializePermanentDelegateInstruction(
-    instruction: TransactionInstruction,
-    programId: PublicKey
-): DecodedInitializePermanentDelegateInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== initializePermanentDelegateInstructionData.span)
-        throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeInitializePermanentDelegateInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.InitializePermanentDelegate) throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated InitializePermanentDelegate instruction */
-export interface DecodedInitializePermanentDelegateInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        delegate: PublicKey | null;
-    };
-}
-
-/**
- * Decode an InitializePermanentDelegate instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeInitializePermanentDelegateInstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedInitializePermanentDelegateInstructionUnchecked {
-    const { instruction, delegate } = initializePermanentDelegateInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: {
-            instruction,
-            delegate,
-        },
-    };
-}
diff --git a/token/js/src/instructions/internal.ts b/token/js/src/instructions/internal.ts
deleted file mode 100644
index 7255fa2f7e7..00000000000
--- a/token/js/src/instructions/internal.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { AccountMeta, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-
-/** @internal */
-export function addSigners(
-    keys: AccountMeta[],
-    ownerOrAuthority: PublicKey,
-    multiSigners: (Signer | PublicKey)[]
-): AccountMeta[] {
-    if (multiSigners.length) {
-        keys.push({ pubkey: ownerOrAuthority, isSigner: false, isWritable: false });
-        for (const signer of multiSigners) {
-            keys.push({
-                pubkey: signer instanceof PublicKey ? signer : signer.publicKey,
-                isSigner: true,
-                isWritable: false,
-            });
-        }
-    } else {
-        keys.push({ pubkey: ownerOrAuthority, isSigner: true, isWritable: false });
-    }
-    return keys;
-}
diff --git a/token/js/src/instructions/mintTo.ts b/token/js/src/instructions/mintTo.ts
deleted file mode 100644
index 5b4f6c4467d..00000000000
--- a/token/js/src/instructions/mintTo.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface MintToInstructionData {
-    instruction: TokenInstruction.MintTo;
-    amount: bigint;
-}
-
-/** TODO: docs */
-export const mintToInstructionData = struct<MintToInstructionData>([u8('instruction'), u64('amount')]);
-
-/**
- * Construct a MintTo instruction
- *
- * @param mint         Public key of the mint
- * @param destination  Address of the token account to mint to
- * @param authority    The mint authority
- * @param amount       Amount to mint
- * @param multiSigners Signing accounts if `authority` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createMintToInstruction(
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    amount: number | bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: mint, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(mintToInstructionData.span);
-    mintToInstructionData.encode(
-        {
-            instruction: TokenInstruction.MintTo,
-            amount: BigInt(amount),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid MintTo instruction */
-export interface DecodedMintToInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.MintTo;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a MintTo instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeMintToInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedMintToInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== mintToInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, destination, authority, multiSigners },
-        data,
-    } = decodeMintToInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.MintTo) throw new TokenInvalidInstructionTypeError();
-    if (!mint || !destination || !authority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated MintTo instruction */
-export interface DecodedMintToInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-        destination: AccountMeta | undefined;
-        authority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a MintTo instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeMintToInstructionUnchecked({
-    programId,
-    keys: [mint, destination, authority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedMintToInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data: mintToInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/mintToChecked.ts b/token/js/src/instructions/mintToChecked.ts
deleted file mode 100644
index 3c306a4f135..00000000000
--- a/token/js/src/instructions/mintToChecked.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface MintToCheckedInstructionData {
-    instruction: TokenInstruction.MintToChecked;
-    amount: bigint;
-    decimals: number;
-}
-
-/** TODO: docs */
-export const mintToCheckedInstructionData = struct<MintToCheckedInstructionData>([
-    u8('instruction'),
-    u64('amount'),
-    u8('decimals'),
-]);
-
-/**
- * Construct a MintToChecked instruction
- *
- * @param mint         Public key of the mint
- * @param destination  Address of the token account to mint to
- * @param authority    The mint authority
- * @param amount       Amount to mint
- * @param decimals     Number of decimals in amount to mint
- * @param multiSigners Signing accounts if `authority` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createMintToCheckedInstruction(
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: mint, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        authority,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(mintToCheckedInstructionData.span);
-    mintToCheckedInstructionData.encode(
-        {
-            instruction: TokenInstruction.MintToChecked,
-            amount: BigInt(amount),
-            decimals,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid MintToChecked instruction */
-export interface DecodedMintToCheckedInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-        destination: AccountMeta;
-        authority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.MintToChecked;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a MintToChecked instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeMintToCheckedInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedMintToCheckedInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== mintToCheckedInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint, destination, authority, multiSigners },
-        data,
-    } = decodeMintToCheckedInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.MintToChecked) throw new TokenInvalidInstructionTypeError();
-    if (!mint || !destination || !authority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated MintToChecked instruction */
-export interface DecodedMintToCheckedInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-        destination: AccountMeta | undefined;
-        authority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a MintToChecked instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeMintToCheckedInstructionUnchecked({
-    programId,
-    keys: [mint, destination, authority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedMintToCheckedInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            mint,
-            destination,
-            authority,
-            multiSigners,
-        },
-        data: mintToCheckedInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/reallocate.ts b/token/js/src/instructions/reallocate.ts
deleted file mode 100644
index 21a03ce346c..00000000000
--- a/token/js/src/instructions/reallocate.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { seq, struct, u16, u8 } from '@solana/buffer-layout';
-import type { PublicKey, Signer } from '@solana/web3.js';
-import { SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { programSupportsExtensions, TOKEN_2022_PROGRAM_ID } from '../constants.js';
-import { TokenUnsupportedInstructionError } from '../errors.js';
-import type { ExtensionType } from '../extensions/extensionType.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface ReallocateInstructionData {
-    instruction: TokenInstruction.Reallocate;
-    extensionTypes: ExtensionType[];
-}
-
-/**
- * Construct a Reallocate instruction
- *
- * @param account        Address of the token account
- * @param payer          Address paying for the reallocation
- * @param extensionTypes Extensions to reallocate for
- * @param owner          Owner of the account
- * @param multiSigners   Signing accounts if `owner` is a multisig
- * @param programId      SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createReallocateInstruction(
-    account: PublicKey,
-    payer: PublicKey,
-    extensionTypes: ExtensionType[],
-    owner: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_2022_PROGRAM_ID
-): TransactionInstruction {
-    if (!programSupportsExtensions(programId)) {
-        throw new TokenUnsupportedInstructionError();
-    }
-    const baseKeys = [
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: payer, isSigner: true, isWritable: true },
-        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-    ];
-    const keys = addSigners(baseKeys, owner, multiSigners);
-
-    const reallocateInstructionData = struct<ReallocateInstructionData>([
-        u8('instruction'),
-        seq(u16(), extensionTypes.length, 'extensionTypes'),
-    ]);
-    const data = Buffer.alloc(reallocateInstructionData.span);
-    reallocateInstructionData.encode({ instruction: TokenInstruction.Reallocate, extensionTypes }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
diff --git a/token/js/src/instructions/revoke.ts b/token/js/src/instructions/revoke.ts
deleted file mode 100644
index e298113ebc9..00000000000
--- a/token/js/src/instructions/revoke.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface RevokeInstructionData {
-    instruction: TokenInstruction.Revoke;
-}
-
-/** TODO: docs */
-export const revokeInstructionData = struct<RevokeInstructionData>([u8('instruction')]);
-
-/**
- * Construct a Revoke instruction
- *
- * @param account      Address of the token account
- * @param owner        Owner of the account
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createRevokeInstruction(
-    account: PublicKey,
-    owner: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners([{ pubkey: account, isSigner: false, isWritable: true }], owner, multiSigners);
-
-    const data = Buffer.alloc(revokeInstructionData.span);
-    revokeInstructionData.encode({ instruction: TokenInstruction.Revoke }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid Revoke instruction */
-export interface DecodedRevokeInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.Revoke;
-    };
-}
-
-/**
- * Decode a Revoke instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeRevokeInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedRevokeInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== revokeInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, owner, multiSigners },
-        data,
-    } = decodeRevokeInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.Revoke) throw new TokenInvalidInstructionTypeError();
-    if (!account || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated Revoke instruction */
-export interface DecodedRevokeInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode a Revoke instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeRevokeInstructionUnchecked({
-    programId,
-    keys: [account, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedRevokeInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            owner,
-            multiSigners,
-        },
-        data: revokeInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/setAuthority.ts b/token/js/src/instructions/setAuthority.ts
deleted file mode 100644
index 58ef8e271f7..00000000000
--- a/token/js/src/instructions/setAuthority.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { AccountMeta, Signer, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-import { COptionPublicKeyLayout } from '../serialization.js';
-
-/** Authority types defined by the program */
-export enum AuthorityType {
-    MintTokens = 0,
-    FreezeAccount = 1,
-    AccountOwner = 2,
-    CloseAccount = 3,
-    TransferFeeConfig = 4,
-    WithheldWithdraw = 5,
-    CloseMint = 6,
-    InterestRate = 7,
-    PermanentDelegate = 8,
-    ConfidentialTransferMint = 9,
-    TransferHookProgramId = 10,
-    ConfidentialTransferFeeConfig = 11,
-    MetadataPointer = 12,
-    GroupPointer = 13,
-    GroupMemberPointer = 14,
-}
-
-/** TODO: docs */
-export interface SetAuthorityInstructionData {
-    instruction: TokenInstruction.SetAuthority;
-    authorityType: AuthorityType;
-    newAuthority: PublicKey | null;
-}
-
-/** TODO: docs */
-export const setAuthorityInstructionData = struct<SetAuthorityInstructionData>([
-    u8('instruction'),
-    u8('authorityType'),
-    new COptionPublicKeyLayout('newAuthority'),
-]);
-
-/**
- * Construct a SetAuthority instruction
- *
- * @param account          Address of the token account
- * @param currentAuthority Current authority of the specified type
- * @param authorityType    Type of authority to set
- * @param newAuthority     New authority of the account
- * @param multiSigners     Signing accounts if `currentAuthority` is a multisig
- * @param programId        SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createSetAuthorityInstruction(
-    account: PublicKey,
-    currentAuthority: PublicKey,
-    authorityType: AuthorityType,
-    newAuthority: PublicKey | null,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners([{ pubkey: account, isSigner: false, isWritable: true }], currentAuthority, multiSigners);
-
-    const data = Buffer.alloc(setAuthorityInstructionData.span);
-    setAuthorityInstructionData.encode(
-        {
-            instruction: TokenInstruction.SetAuthority,
-            authorityType,
-            newAuthority,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid SetAuthority instruction */
-export interface DecodedSetAuthorityInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        currentAuthority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.SetAuthority;
-        authorityType: AuthorityType;
-        newAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode a SetAuthority instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeSetAuthorityInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedSetAuthorityInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== setAuthorityInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, currentAuthority, multiSigners },
-        data,
-    } = decodeSetAuthorityInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.SetAuthority) throw new TokenInvalidInstructionTypeError();
-    if (!account || !currentAuthority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            currentAuthority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated SetAuthority instruction */
-export interface DecodedSetAuthorityInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        currentAuthority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        authorityType: AuthorityType;
-        newAuthority: PublicKey | null;
-    };
-}
-
-/**
- * Decode a SetAuthority instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeSetAuthorityInstructionUnchecked({
-    programId,
-    keys: [account, currentAuthority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedSetAuthorityInstructionUnchecked {
-    const { instruction, authorityType, newAuthority } = setAuthorityInstructionData.decode(data);
-
-    return {
-        programId,
-        keys: {
-            account,
-            currentAuthority,
-            multiSigners,
-        },
-        data: {
-            instruction,
-            authorityType,
-            newAuthority,
-        },
-    };
-}
diff --git a/token/js/src/instructions/syncNative.ts b/token/js/src/instructions/syncNative.ts
deleted file mode 100644
index 4c4ec5efb0e..00000000000
--- a/token/js/src/instructions/syncNative.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface SyncNativeInstructionData {
-    instruction: TokenInstruction.SyncNative;
-}
-
-/** TODO: docs */
-export const syncNativeInstructionData = struct<SyncNativeInstructionData>([u8('instruction')]);
-
-/**
- * Construct a SyncNative instruction
- *
- * @param account   Native account to sync lamports from
- * @param programId SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createSyncNativeInstruction(account: PublicKey, programId = TOKEN_PROGRAM_ID): TransactionInstruction {
-    const keys = [{ pubkey: account, isSigner: false, isWritable: true }];
-
-    const data = Buffer.alloc(syncNativeInstructionData.span);
-    syncNativeInstructionData.encode({ instruction: TokenInstruction.SyncNative }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid SyncNative instruction */
-export interface DecodedSyncNativeInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.SyncNative;
-    };
-}
-
-/**
- * Decode a SyncNative instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeSyncNativeInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedSyncNativeInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== syncNativeInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account },
-        data,
-    } = decodeSyncNativeInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.SyncNative) throw new TokenInvalidInstructionTypeError();
-    if (!account) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated SyncNative instruction */
-export interface DecodedSyncNativeInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode a SyncNative instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeSyncNativeInstructionUnchecked({
-    programId,
-    keys: [account],
-    data,
-}: TransactionInstruction): DecodedSyncNativeInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-        },
-        data: syncNativeInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/thawAccount.ts b/token/js/src/instructions/thawAccount.ts
deleted file mode 100644
index e91a412c995..00000000000
--- a/token/js/src/instructions/thawAccount.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface ThawAccountInstructionData {
-    instruction: TokenInstruction.ThawAccount;
-}
-
-/** TODO: docs */
-export const thawAccountInstructionData = struct<ThawAccountInstructionData>([u8('instruction')]);
-
-/**
- * Construct a ThawAccount instruction
- *
- * @param account      Account to thaw
- * @param mint         Mint account
- * @param authority    Mint freeze authority
- * @param multiSigners Signing accounts if `authority` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createThawAccountInstruction(
-    account: PublicKey,
-    mint: PublicKey,
-    authority: PublicKey,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: account, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-        ],
-        authority,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(thawAccountInstructionData.span);
-    thawAccountInstructionData.encode({ instruction: TokenInstruction.ThawAccount }, data);
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid ThawAccount instruction */
-export interface DecodedThawAccountInstruction {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta;
-        mint: AccountMeta;
-        authority: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.ThawAccount;
-    };
-}
-
-/**
- * Decode a ThawAccount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeThawAccountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedThawAccountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== thawAccountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { account, mint, authority, multiSigners },
-        data,
-    } = decodeThawAccountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.ThawAccount) throw new TokenInvalidInstructionTypeError();
-    if (!account || !mint || !authority) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            authority,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated ThawAccount instruction */
-export interface DecodedThawAccountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        account: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        authority: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-    };
-}
-
-/**
- * Decode a ThawAccount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeThawAccountInstructionUnchecked({
-    programId,
-    keys: [account, mint, authority, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedThawAccountInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            account,
-            mint,
-            authority,
-            multiSigners,
-        },
-        data: thawAccountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/transfer.ts b/token/js/src/instructions/transfer.ts
deleted file mode 100644
index a31921ad88d..00000000000
--- a/token/js/src/instructions/transfer.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface TransferInstructionData {
-    instruction: TokenInstruction.Transfer;
-    amount: bigint;
-}
-
-/** TODO: docs */
-export const transferInstructionData = struct<TransferInstructionData>([u8('instruction'), u64('amount')]);
-
-/**
- * Construct a Transfer instruction
- *
- * @param source       Source account
- * @param destination  Destination account
- * @param owner        Owner of the source account
- * @param amount       Number of tokens to transfer
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createTransferInstruction(
-    source: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: source, isSigner: false, isWritable: true },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(transferInstructionData.span);
-    transferInstructionData.encode(
-        {
-            instruction: TokenInstruction.Transfer,
-            amount: BigInt(amount),
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid Transfer instruction */
-export interface DecodedTransferInstruction {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta;
-        destination: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.Transfer;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a Transfer instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeTransferInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedTransferInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== transferInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { source, destination, owner, multiSigners },
-        data,
-    } = decodeTransferInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.Transfer) throw new TokenInvalidInstructionTypeError();
-    if (!source || !destination || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            source,
-            destination,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated Transfer instruction */
-export interface DecodedTransferInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta | undefined;
-        destination: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-    };
-}
-
-/**
- * Decode a Transfer instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeTransferInstructionUnchecked({
-    programId,
-    keys: [source, destination, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedTransferInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            source,
-            destination,
-            owner,
-            multiSigners,
-        },
-        data: transferInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/transferChecked.ts b/token/js/src/instructions/transferChecked.ts
deleted file mode 100644
index e9717f8e031..00000000000
--- a/token/js/src/instructions/transferChecked.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
-import type { AccountMeta, PublicKey, Signer } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { addSigners } from './internal.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface TransferCheckedInstructionData {
-    instruction: TokenInstruction.TransferChecked;
-    amount: bigint;
-    decimals: number;
-}
-
-/** TODO: docs */
-export const transferCheckedInstructionData = struct<TransferCheckedInstructionData>([
-    u8('instruction'),
-    u64('amount'),
-    u8('decimals'),
-]);
-
-/**
- * Construct a TransferChecked instruction
- *
- * @param source       Source account
- * @param mint         Mint account
- * @param destination  Destination account
- * @param owner        Owner of the source account
- * @param amount       Number of tokens to transfer
- * @param decimals     Number of decimals in transfer amount
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createTransferCheckedInstruction(
-    source: PublicKey,
-    mint: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    decimals: number,
-    multiSigners: (Signer | PublicKey)[] = [],
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = addSigners(
-        [
-            { pubkey: source, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-            { pubkey: destination, isSigner: false, isWritable: true },
-        ],
-        owner,
-        multiSigners
-    );
-
-    const data = Buffer.alloc(transferCheckedInstructionData.span);
-    transferCheckedInstructionData.encode(
-        {
-            instruction: TokenInstruction.TransferChecked,
-            amount: BigInt(amount),
-            decimals,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid TransferChecked instruction */
-export interface DecodedTransferCheckedInstruction {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta;
-        mint: AccountMeta;
-        destination: AccountMeta;
-        owner: AccountMeta;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: TokenInstruction.TransferChecked;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a TransferChecked instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeTransferCheckedInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedTransferCheckedInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    if (instruction.data.length !== transferCheckedInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { source, mint, destination, owner, multiSigners },
-        data,
-    } = decodeTransferCheckedInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.TransferChecked) throw new TokenInvalidInstructionTypeError();
-    if (!source || !mint || !destination || !owner) throw new TokenInvalidInstructionKeysError();
-
-    // TODO: key checks?
-
-    return {
-        programId,
-        keys: {
-            source,
-            mint,
-            destination,
-            owner,
-            multiSigners,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated TransferChecked instruction */
-export interface DecodedTransferCheckedInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        source: AccountMeta | undefined;
-        mint: AccountMeta | undefined;
-        destination: AccountMeta | undefined;
-        owner: AccountMeta | undefined;
-        multiSigners: AccountMeta[];
-    };
-    data: {
-        instruction: number;
-        amount: bigint;
-        decimals: number;
-    };
-}
-
-/**
- * Decode a TransferChecked instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeTransferCheckedInstructionUnchecked({
-    programId,
-    keys: [source, mint, destination, owner, ...multiSigners],
-    data,
-}: TransactionInstruction): DecodedTransferCheckedInstructionUnchecked {
-    return {
-        programId,
-        keys: {
-            source,
-            mint,
-            destination,
-            owner,
-            multiSigners,
-        },
-        data: transferCheckedInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/instructions/types.ts b/token/js/src/instructions/types.ts
deleted file mode 100644
index ca17645205c..00000000000
--- a/token/js/src/instructions/types.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/** Instructions defined by the program */
-export enum TokenInstruction {
-    InitializeMint = 0,
-    InitializeAccount = 1,
-    InitializeMultisig = 2,
-    Transfer = 3,
-    Approve = 4,
-    Revoke = 5,
-    SetAuthority = 6,
-    MintTo = 7,
-    Burn = 8,
-    CloseAccount = 9,
-    FreezeAccount = 10,
-    ThawAccount = 11,
-    TransferChecked = 12,
-    ApproveChecked = 13,
-    MintToChecked = 14,
-    BurnChecked = 15,
-    InitializeAccount2 = 16,
-    SyncNative = 17,
-    InitializeAccount3 = 18,
-    InitializeMultisig2 = 19,
-    InitializeMint2 = 20,
-    GetAccountDataSize = 21,
-    InitializeImmutableOwner = 22,
-    AmountToUiAmount = 23,
-    UiAmountToAmount = 24,
-    InitializeMintCloseAuthority = 25,
-    TransferFeeExtension = 26,
-    ConfidentialTransferExtension = 27,
-    DefaultAccountStateExtension = 28,
-    Reallocate = 29,
-    MemoTransferExtension = 30,
-    CreateNativeMint = 31,
-    InitializeNonTransferableMint = 32,
-    InterestBearingMintExtension = 33,
-    CpiGuardExtension = 34,
-    InitializePermanentDelegate = 35,
-    TransferHookExtension = 36,
-    // ConfidentialTransferFeeExtension = 37,
-    // WithdrawalExcessLamports = 38,
-    MetadataPointerExtension = 39,
-    GroupPointerExtension = 40,
-    GroupMemberPointerExtension = 41,
-}
diff --git a/token/js/src/instructions/uiAmountToAmount.ts b/token/js/src/instructions/uiAmountToAmount.ts
deleted file mode 100644
index 1c129d9976f..00000000000
--- a/token/js/src/instructions/uiAmountToAmount.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { blob, struct, u8 } from '@solana/buffer-layout';
-import type { AccountMeta, PublicKey } from '@solana/web3.js';
-import { TransactionInstruction } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenInvalidInstructionDataError,
-    TokenInvalidInstructionKeysError,
-    TokenInvalidInstructionProgramError,
-    TokenInvalidInstructionTypeError,
-} from '../errors.js';
-import { TokenInstruction } from './types.js';
-
-/** TODO: docs */
-export interface UiAmountToAmountInstructionData {
-    instruction: TokenInstruction.UiAmountToAmount;
-    amount: Uint8Array;
-}
-
-/** TODO: docs */
-
-/**
- * Construct a UiAmountToAmount instruction
- *
- * @param mint         Public key of the mint
- * @param amount       UiAmount of tokens to be converted to Amount
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-export function createUiAmountToAmountInstruction(
-    mint: PublicKey,
-    amount: string,
-    programId = TOKEN_PROGRAM_ID
-): TransactionInstruction {
-    const keys = [{ pubkey: mint, isSigner: false, isWritable: false }];
-    const buf = Buffer.from(amount, 'utf8');
-    const uiAmountToAmountInstructionData = struct<UiAmountToAmountInstructionData>([
-        u8('instruction'),
-        blob(buf.length, 'amount'),
-    ]);
-
-    const data = Buffer.alloc(uiAmountToAmountInstructionData.span);
-    uiAmountToAmountInstructionData.encode(
-        {
-            instruction: TokenInstruction.UiAmountToAmount,
-            amount: buf,
-        },
-        data
-    );
-
-    return new TransactionInstruction({ keys, programId, data });
-}
-
-/** A decoded, valid UiAmountToAmount instruction */
-export interface DecodedUiAmountToAmountInstruction {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta;
-    };
-    data: {
-        instruction: TokenInstruction.UiAmountToAmount;
-        amount: Uint8Array;
-    };
-}
-
-/**
- * Decode a UiAmountToAmount instruction and validate it
- *
- * @param instruction Transaction instruction to decode
- * @param programId   SPL Token program account
- *
- * @return Decoded, valid instruction
- */
-export function decodeUiAmountToAmountInstruction(
-    instruction: TransactionInstruction,
-    programId = TOKEN_PROGRAM_ID
-): DecodedUiAmountToAmountInstruction {
-    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
-    const uiAmountToAmountInstructionData = struct<UiAmountToAmountInstructionData>([
-        u8('instruction'),
-        blob(instruction.data.length - 1, 'amount'),
-    ]);
-    if (instruction.data.length !== uiAmountToAmountInstructionData.span) throw new TokenInvalidInstructionDataError();
-
-    const {
-        keys: { mint },
-        data,
-    } = decodeUiAmountToAmountInstructionUnchecked(instruction);
-    if (data.instruction !== TokenInstruction.UiAmountToAmount) throw new TokenInvalidInstructionTypeError();
-    if (!mint) throw new TokenInvalidInstructionKeysError();
-
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data,
-    };
-}
-
-/** A decoded, non-validated UiAmountToAmount instruction */
-export interface DecodedUiAmountToAmountInstructionUnchecked {
-    programId: PublicKey;
-    keys: {
-        mint: AccountMeta | undefined;
-    };
-    data: {
-        instruction: number;
-        amount: Uint8Array;
-    };
-}
-
-/**
- * Decode a UiAmountToAmount instruction without validating it
- *
- * @param instruction Transaction instruction to decode
- *
- * @return Decoded, non-validated instruction
- */
-export function decodeUiAmountToAmountInstructionUnchecked({
-    programId,
-    keys: [mint],
-    data,
-}: TransactionInstruction): DecodedUiAmountToAmountInstructionUnchecked {
-    const uiAmountToAmountInstructionData = struct<UiAmountToAmountInstructionData>([
-        u8('instruction'),
-        blob(data.length - 1, 'amount'),
-    ]);
-    return {
-        programId,
-        keys: {
-            mint,
-        },
-        data: uiAmountToAmountInstructionData.decode(data),
-    };
-}
diff --git a/token/js/src/serialization.ts b/token/js/src/serialization.ts
deleted file mode 100644
index 57d426baa7f..00000000000
--- a/token/js/src/serialization.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { Layout } from '@solana/buffer-layout';
-import { publicKey } from '@solana/buffer-layout-utils';
-import type { PublicKey } from '@solana/web3.js';
-
-export class COptionPublicKeyLayout extends Layout<PublicKey | null> {
-    private publicKeyLayout: Layout<PublicKey>;
-
-    constructor(property?: string | undefined) {
-        super(-1, property);
-        this.publicKeyLayout = publicKey();
-    }
-
-    decode(buffer: Uint8Array, offset: number = 0): PublicKey | null {
-        const option = buffer[offset];
-        if (option === 0) {
-            return null;
-        }
-        return this.publicKeyLayout.decode(buffer, offset + 1);
-    }
-
-    encode(src: PublicKey | null, buffer: Uint8Array, offset: number = 0): number {
-        if (src === null) {
-            buffer[offset] = 0;
-            return 1;
-        } else {
-            buffer[offset] = 1;
-            this.publicKeyLayout.encode(src, buffer, offset + 1);
-            return 33;
-        }
-    }
-
-    getSpan(buffer?: Uint8Array, offset: number = 0): number {
-        if (buffer) {
-            const option = buffer[offset];
-            return option === 0 ? 1 : 1 + this.publicKeyLayout.span;
-        }
-        return 1 + this.publicKeyLayout.span;
-    }
-}
diff --git a/token/js/src/state/account.ts b/token/js/src/state/account.ts
deleted file mode 100644
index 361548201d3..00000000000
--- a/token/js/src/state/account.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { struct, u32, u8 } from '@solana/buffer-layout';
-import { publicKey, u64 } from '@solana/buffer-layout-utils';
-import type { AccountInfo, Commitment, Connection, PublicKey } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenAccountNotFoundError,
-    TokenInvalidAccountError,
-    TokenInvalidAccountOwnerError,
-    TokenInvalidAccountSizeError,
-} from '../errors.js';
-import { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';
-import type { ExtensionType } from '../extensions/extensionType.js';
-import { getAccountLen } from '../extensions/extensionType.js';
-import { MULTISIG_SIZE } from './multisig.js';
-
-/** Information about a token account */
-export interface Account {
-    /** Address of the account */
-    address: PublicKey;
-    /** Mint associated with the account */
-    mint: PublicKey;
-    /** Owner of the account */
-    owner: PublicKey;
-    /** Number of tokens the account holds */
-    amount: bigint;
-    /** Authority that can transfer tokens from the account */
-    delegate: PublicKey | null;
-    /** Number of tokens the delegate is authorized to transfer */
-    delegatedAmount: bigint;
-    /** True if the account is initialized */
-    isInitialized: boolean;
-    /** True if the account is frozen */
-    isFrozen: boolean;
-    /** True if the account is a native token account */
-    isNative: boolean;
-    /**
-     * If the account is a native token account, it must be rent-exempt. The rent-exempt reserve is the amount that must
-     * remain in the balance until the account is closed.
-     */
-    rentExemptReserve: bigint | null;
-    /** Optional authority to close the account */
-    closeAuthority: PublicKey | null;
-    tlvData: Buffer;
-}
-
-/** Token account state as stored by the program */
-export enum AccountState {
-    Uninitialized = 0,
-    Initialized = 1,
-    Frozen = 2,
-}
-
-/** Token account as stored by the program */
-export interface RawAccount {
-    mint: PublicKey;
-    owner: PublicKey;
-    amount: bigint;
-    delegateOption: 1 | 0;
-    delegate: PublicKey;
-    state: AccountState;
-    isNativeOption: 1 | 0;
-    isNative: bigint;
-    delegatedAmount: bigint;
-    closeAuthorityOption: 1 | 0;
-    closeAuthority: PublicKey;
-}
-
-/** Buffer layout for de/serializing a token account */
-export const AccountLayout = struct<RawAccount>([
-    publicKey('mint'),
-    publicKey('owner'),
-    u64('amount'),
-    u32('delegateOption'),
-    publicKey('delegate'),
-    u8('state'),
-    u32('isNativeOption'),
-    u64('isNative'),
-    u64('delegatedAmount'),
-    u32('closeAuthorityOption'),
-    publicKey('closeAuthority'),
-]);
-
-/** Byte length of a token account */
-export const ACCOUNT_SIZE = AccountLayout.span;
-
-/**
- * Retrieve information about a token account
- *
- * @param connection Connection to use
- * @param address    Token account
- * @param commitment Desired level of commitment for querying the state
- * @param programId  SPL Token program account
- *
- * @return Token account information
- */
-export async function getAccount(
-    connection: Connection,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-): Promise<Account> {
-    const info = await connection.getAccountInfo(address, commitment);
-    return unpackAccount(address, info, programId);
-}
-
-/**
- * Retrieve information about multiple token accounts in a single RPC call
- *
- * @param connection Connection to use
- * @param addresses  Token accounts
- * @param commitment Desired level of commitment for querying the state
- * @param programId  SPL Token program account
- *
- * @return Token account information
- */
-export async function getMultipleAccounts(
-    connection: Connection,
-    addresses: PublicKey[],
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-): Promise<Account[]> {
-    const infos = await connection.getMultipleAccountsInfo(addresses, commitment);
-    return addresses.map((address, i) => unpackAccount(address, infos[i], programId));
-}
-
-/** Get the minimum lamport balance for a base token account to be rent exempt
- *
- * @param connection Connection to use
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Amount of lamports required
- */
-export async function getMinimumBalanceForRentExemptAccount(
-    connection: Connection,
-    commitment?: Commitment
-): Promise<number> {
-    return await getMinimumBalanceForRentExemptAccountWithExtensions(connection, [], commitment);
-}
-
-/** Get the minimum lamport balance for a rent-exempt token account with extensions
- *
- * @param connection Connection to use
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Amount of lamports required
- */
-export async function getMinimumBalanceForRentExemptAccountWithExtensions(
-    connection: Connection,
-    extensions: ExtensionType[],
-    commitment?: Commitment
-): Promise<number> {
-    const accountLen = getAccountLen(extensions);
-    return await connection.getMinimumBalanceForRentExemption(accountLen, commitment);
-}
-
-/**
- * Unpack a token account
- *
- * @param address   Token account
- * @param info      Token account data
- * @param programId SPL Token program account
- *
- * @return Unpacked token account
- */
-export function unpackAccount(
-    address: PublicKey,
-    info: AccountInfo<Buffer> | null,
-    programId = TOKEN_PROGRAM_ID
-): Account {
-    if (!info) throw new TokenAccountNotFoundError();
-    if (!info.owner.equals(programId)) throw new TokenInvalidAccountOwnerError();
-    if (info.data.length < ACCOUNT_SIZE) throw new TokenInvalidAccountSizeError();
-
-    const rawAccount = AccountLayout.decode(info.data.slice(0, ACCOUNT_SIZE));
-    let tlvData = Buffer.alloc(0);
-    if (info.data.length > ACCOUNT_SIZE) {
-        if (info.data.length === MULTISIG_SIZE) throw new TokenInvalidAccountSizeError();
-        if (info.data[ACCOUNT_SIZE] != AccountType.Account) throw new TokenInvalidAccountError();
-        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
-    }
-
-    return {
-        address,
-        mint: rawAccount.mint,
-        owner: rawAccount.owner,
-        amount: rawAccount.amount,
-        delegate: rawAccount.delegateOption ? rawAccount.delegate : null,
-        delegatedAmount: rawAccount.delegatedAmount,
-        isInitialized: rawAccount.state !== AccountState.Uninitialized,
-        isFrozen: rawAccount.state === AccountState.Frozen,
-        isNative: !!rawAccount.isNativeOption,
-        rentExemptReserve: rawAccount.isNativeOption ? rawAccount.isNative : null,
-        closeAuthority: rawAccount.closeAuthorityOption ? rawAccount.closeAuthority : null,
-        tlvData,
-    };
-}
diff --git a/token/js/src/state/index.ts b/token/js/src/state/index.ts
deleted file mode 100644
index bcf6d756eef..00000000000
--- a/token/js/src/state/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './account.js';
-export * from './mint.js';
-export * from './multisig.js';
diff --git a/token/js/src/state/mint.ts b/token/js/src/state/mint.ts
deleted file mode 100644
index 69bd98cc3cf..00000000000
--- a/token/js/src/state/mint.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { struct, u32, u8 } from '@solana/buffer-layout';
-import { bool, publicKey, u64 } from '@solana/buffer-layout-utils';
-import type { AccountInfo, Commitment, Connection } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js';
-import {
-    TokenAccountNotFoundError,
-    TokenInvalidAccountOwnerError,
-    TokenInvalidAccountSizeError,
-    TokenInvalidMintError,
-    TokenOwnerOffCurveError,
-} from '../errors.js';
-import { ACCOUNT_TYPE_SIZE, AccountType } from '../extensions/accountType.js';
-import type { ExtensionType } from '../extensions/extensionType.js';
-import { getMintLen } from '../extensions/extensionType.js';
-import { ACCOUNT_SIZE } from './account.js';
-import { MULTISIG_SIZE } from './multisig.js';
-
-/** Information about a mint */
-export interface Mint {
-    /** Address of the mint */
-    address: PublicKey;
-    /**
-     * Optional authority used to mint new tokens. The mint authority may only be provided during mint creation.
-     * If no mint authority is present then the mint has a fixed supply and no further tokens may be minted.
-     */
-    mintAuthority: PublicKey | null;
-    /** Total supply of tokens */
-    supply: bigint;
-    /** Number of base 10 digits to the right of the decimal place */
-    decimals: number;
-    /** Is this mint initialized */
-    isInitialized: boolean;
-    /** Optional authority to freeze token accounts */
-    freezeAuthority: PublicKey | null;
-    /** Additional data for extension */
-    tlvData: Buffer;
-}
-
-/** Mint as stored by the program */
-export interface RawMint {
-    mintAuthorityOption: 1 | 0;
-    mintAuthority: PublicKey;
-    supply: bigint;
-    decimals: number;
-    isInitialized: boolean;
-    freezeAuthorityOption: 1 | 0;
-    freezeAuthority: PublicKey;
-}
-
-/** Buffer layout for de/serializing a mint */
-export const MintLayout = struct<RawMint>([
-    u32('mintAuthorityOption'),
-    publicKey('mintAuthority'),
-    u64('supply'),
-    u8('decimals'),
-    bool('isInitialized'),
-    u32('freezeAuthorityOption'),
-    publicKey('freezeAuthority'),
-]);
-
-/** Byte length of a mint */
-export const MINT_SIZE = MintLayout.span;
-
-/**
- * Retrieve information about a mint
- *
- * @param connection Connection to use
- * @param address    Mint account
- * @param commitment Desired level of commitment for querying the state
- * @param programId  SPL Token program account
- *
- * @return Mint information
- */
-export async function getMint(
-    connection: Connection,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-): Promise<Mint> {
-    const info = await connection.getAccountInfo(address, commitment);
-    return unpackMint(address, info, programId);
-}
-
-/**
- * Unpack a mint
- *
- * @param address   Mint account
- * @param info      Mint account data
- * @param programId SPL Token program account
- *
- * @return Unpacked mint
- */
-export function unpackMint(address: PublicKey, info: AccountInfo<Buffer> | null, programId = TOKEN_PROGRAM_ID): Mint {
-    if (!info) throw new TokenAccountNotFoundError();
-    if (!info.owner.equals(programId)) throw new TokenInvalidAccountOwnerError();
-    if (info.data.length < MINT_SIZE) throw new TokenInvalidAccountSizeError();
-
-    const rawMint = MintLayout.decode(info.data.slice(0, MINT_SIZE));
-    let tlvData = Buffer.alloc(0);
-    if (info.data.length > MINT_SIZE) {
-        if (info.data.length <= ACCOUNT_SIZE) throw new TokenInvalidAccountSizeError();
-        if (info.data.length === MULTISIG_SIZE) throw new TokenInvalidAccountSizeError();
-        if (info.data[ACCOUNT_SIZE] != AccountType.Mint) throw new TokenInvalidMintError();
-        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
-    }
-
-    return {
-        address,
-        mintAuthority: rawMint.mintAuthorityOption ? rawMint.mintAuthority : null,
-        supply: rawMint.supply,
-        decimals: rawMint.decimals,
-        isInitialized: rawMint.isInitialized,
-        freezeAuthority: rawMint.freezeAuthorityOption ? rawMint.freezeAuthority : null,
-        tlvData,
-    };
-}
-
-/** Get the minimum lamport balance for a mint to be rent exempt
- *
- * @param connection Connection to use
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Amount of lamports required
- */
-export async function getMinimumBalanceForRentExemptMint(
-    connection: Connection,
-    commitment?: Commitment
-): Promise<number> {
-    return await getMinimumBalanceForRentExemptMintWithExtensions(connection, [], commitment);
-}
-
-/** Get the minimum lamport balance for a rent-exempt mint with extensions
- *
- * @param connection Connection to use
- * @param extensions Extension types included in the mint
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Amount of lamports required
- */
-export async function getMinimumBalanceForRentExemptMintWithExtensions(
-    connection: Connection,
-    extensions: ExtensionType[],
-    commitment?: Commitment
-): Promise<number> {
-    const mintLen = getMintLen(extensions);
-    return await connection.getMinimumBalanceForRentExemption(mintLen, commitment);
-}
-
-/**
- * Async version of getAssociatedTokenAddressSync
- * For backwards compatibility
- *
- * @param mint                     Token mint account
- * @param owner                    Owner of the new account
- * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Promise containing the address of the associated token account
- */
-export async function getAssociatedTokenAddress(
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve = false,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<PublicKey> {
-    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer())) throw new TokenOwnerOffCurveError();
-
-    const [address] = await PublicKey.findProgramAddress(
-        [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
-        associatedTokenProgramId
-    );
-
-    return address;
-}
-
-/**
- * Get the address of the associated token account for a given mint and owner
- *
- * @param mint                     Token mint account
- * @param owner                    Owner of the new account
- * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Address of the associated token account
- */
-export function getAssociatedTokenAddressSync(
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve = false,
-    programId = TOKEN_PROGRAM_ID,
-    associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): PublicKey {
-    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer())) throw new TokenOwnerOffCurveError();
-
-    const [address] = PublicKey.findProgramAddressSync(
-        [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
-        associatedTokenProgramId
-    );
-
-    return address;
-}
diff --git a/token/js/src/state/multisig.ts b/token/js/src/state/multisig.ts
deleted file mode 100644
index f821d7f9c4c..00000000000
--- a/token/js/src/state/multisig.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import { struct, u8 } from '@solana/buffer-layout';
-import { bool, publicKey } from '@solana/buffer-layout-utils';
-import type { AccountInfo, Commitment, Connection, PublicKey } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../constants.js';
-import { TokenAccountNotFoundError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError } from '../errors.js';
-
-/** Information about a multisig */
-export interface Multisig {
-    /** Address of the multisig */
-    address: PublicKey;
-    /** Number of signers required */
-    m: number;
-    /** Number of possible signers, corresponds to the number of `signers` that are valid */
-    n: number;
-    /** Is this mint initialized */
-    isInitialized: boolean;
-    /** Full set of signers, of which `n` are valid */
-    signer1: PublicKey;
-    signer2: PublicKey;
-    signer3: PublicKey;
-    signer4: PublicKey;
-    signer5: PublicKey;
-    signer6: PublicKey;
-    signer7: PublicKey;
-    signer8: PublicKey;
-    signer9: PublicKey;
-    signer10: PublicKey;
-    signer11: PublicKey;
-}
-
-/** Multisig as stored by the program */
-export type RawMultisig = Omit<Multisig, 'address'>;
-
-/** Buffer layout for de/serializing a multisig */
-export const MultisigLayout = struct<RawMultisig>([
-    u8('m'),
-    u8('n'),
-    bool('isInitialized'),
-    publicKey('signer1'),
-    publicKey('signer2'),
-    publicKey('signer3'),
-    publicKey('signer4'),
-    publicKey('signer5'),
-    publicKey('signer6'),
-    publicKey('signer7'),
-    publicKey('signer8'),
-    publicKey('signer9'),
-    publicKey('signer10'),
-    publicKey('signer11'),
-]);
-
-/** Byte length of a multisig */
-export const MULTISIG_SIZE = MultisigLayout.span;
-
-/**
- * Retrieve information about a multisig
- *
- * @param connection Connection to use
- * @param address    Multisig account
- * @param commitment Desired level of commitment for querying the state
- * @param programId  SPL Token program account
- *
- * @return Multisig information
- */
-export async function getMultisig(
-    connection: Connection,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId = TOKEN_PROGRAM_ID
-): Promise<Multisig> {
-    const info = await connection.getAccountInfo(address, commitment);
-    return unpackMultisig(address, info, programId);
-}
-
-/**
- * Unpack a multisig
- *
- * @param address   Multisig account
- * @param info      Multisig account data
- * @param programId SPL Token program account
- *
- * @return Unpacked multisig
- */
-export function unpackMultisig(
-    address: PublicKey,
-    info: AccountInfo<Buffer> | null,
-    programId = TOKEN_PROGRAM_ID
-): Multisig {
-    if (!info) throw new TokenAccountNotFoundError();
-    if (!info.owner.equals(programId)) throw new TokenInvalidAccountOwnerError();
-    if (info.data.length != MULTISIG_SIZE) throw new TokenInvalidAccountSizeError();
-
-    const multisig = MultisigLayout.decode(info.data);
-
-    return { address, ...multisig };
-}
-
-/** Get the minimum lamport balance for a multisig to be rent exempt
- *
- * @param connection Connection to use
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Amount of lamports required
- */
-export async function getMinimumBalanceForRentExemptMultisig(
-    connection: Connection,
-    commitment?: Commitment
-): Promise<number> {
-    return await connection.getMinimumBalanceForRentExemption(MULTISIG_SIZE, commitment);
-}
diff --git a/token/js/test/common.ts b/token/js/test/common.ts
deleted file mode 100644
index 06ff1ef7ebf..00000000000
--- a/token/js/test/common.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import type { Signer } from '@solana/web3.js';
-import { PublicKey, Keypair, Connection } from '@solana/web3.js';
-import { TOKEN_PROGRAM_ID } from '../src';
-
-export async function newAccountWithLamports(connection: Connection, lamports = 1000000): Promise<Signer> {
-    const account = Keypair.generate();
-    const signature = await connection.requestAirdrop(account.publicKey, lamports);
-    await connection.confirmTransaction(signature);
-    return account;
-}
-
-export async function getConnection(): Promise<Connection> {
-    const url = 'http://127.0.0.1:8899';
-    const connection = new Connection(url, 'confirmed');
-    return connection;
-}
-
-export const TEST_PROGRAM_ID = process.env.TEST_PROGRAM_ID
-    ? new PublicKey(process.env.TEST_PROGRAM_ID)
-    : TOKEN_PROGRAM_ID;
-
-export const TRANSFER_HOOK_TEST_PROGRAM_ID = new PublicKey('TokenHookExampLe8smaVNrxTBezWTRbEwxwb1Zykrb');
diff --git a/token/js/test/e2e-2022/closeMint.test.ts b/token/js/test/e2e-2022/closeMint.test.ts
deleted file mode 100644
index 0fabd6506fd..00000000000
--- a/token/js/test/e2e-2022/closeMint.test.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createAccount,
-    createInitializeMintInstruction,
-    createInitializeMintCloseAuthorityInstruction,
-    closeAccount,
-    mintTo,
-    getMintLen,
-    ExtensionType,
-    AuthorityType,
-    getMint,
-    setAuthority,
-    getMintCloseAuthority,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.MintCloseAuthority];
-describe('closeMint', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let closeAuthority: Keypair;
-    let account: PublicKey;
-    let destination: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        closeAuthority = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMintCloseAuthorityInstruction(mint, closeAuthority.publicKey, TEST_PROGRAM_ID),
-            createInitializeMintInstruction(mint, TEST_TOKEN_DECIMALS, mintAuthority.publicKey, null, TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-    });
-    it('failsWithNonZeroAmount', async () => {
-        const owner = Keypair.generate();
-        destination = Keypair.generate().publicKey;
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-        const amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-        expect(closeAccount(connection, payer, mint, destination, closeAuthority, [], undefined, TEST_PROGRAM_ID)).to.be
-            .rejected;
-    });
-    it('works', async () => {
-        destination = Keypair.generate().publicKey;
-        const accountInfo = await connection.getAccountInfo(mint);
-        let rentExemptAmount;
-        expect(accountInfo).to.not.be.null;
-        if (accountInfo !== null) {
-            rentExemptAmount = accountInfo.lamports;
-        }
-
-        await closeAccount(connection, payer, mint, destination, closeAuthority, [], undefined, TEST_PROGRAM_ID);
-
-        const closedInfo = await connection.getAccountInfo(mint);
-        expect(closedInfo).to.be.null;
-
-        const destinationInfo = await connection.getAccountInfo(destination);
-        expect(destinationInfo).to.not.be.null;
-        if (destinationInfo !== null) {
-            expect(destinationInfo.lamports).to.eql(rentExemptAmount);
-        }
-    });
-    it('authority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            closeAuthority,
-            AuthorityType.CloseMint,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const mintCloseAuthority = getMintCloseAuthority(mintInfo);
-        expect(mintCloseAuthority).to.not.be.null;
-        if (mintCloseAuthority !== null) {
-            expect(mintCloseAuthority.closeAuthority).to.eql(PublicKey.default);
-        }
-    });
-});
diff --git a/token/js/test/e2e-2022/cpiGuard.test.ts b/token/js/test/e2e-2022/cpiGuard.test.ts
deleted file mode 100644
index 3a0e8be3d80..00000000000
--- a/token/js/test/e2e-2022/cpiGuard.test.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createAccount,
-    createMint,
-    createEnableCpiGuardInstruction,
-    createDisableCpiGuardInstruction,
-    createInitializeAccountInstruction,
-    getAccount,
-    getCpiGuard,
-    enableCpiGuard,
-    disableCpiGuard,
-    getAccountLen,
-    ExtensionType,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const TRANSFER_AMOUNT = 1_000;
-const EXTENSIONS = [ExtensionType.CpiGuard];
-describe('cpiGuard', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let account: PublicKey;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        owner = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        const mintAuthority = Keypair.generate();
-        const accountKeypair = Keypair.generate();
-        account = accountKeypair.publicKey;
-        const accountLen = getAccountLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-        const mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: account,
-                space: accountLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeAccountInstruction(account, mint, owner.publicKey, TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, accountKeypair], undefined);
-    });
-
-    it('enable/disable via instruction', async () => {
-        let accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        let cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.be.null;
-
-        let transaction = new Transaction().add(
-            createEnableCpiGuardInstruction(account, owner.publicKey, [], TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, owner], undefined);
-
-        accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.not.be.null;
-        if (cpiGuard !== null) {
-            expect(cpiGuard.lockCpi).to.be.true;
-        }
-
-        transaction = new Transaction().add(
-            createDisableCpiGuardInstruction(account, owner.publicKey, [], TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, owner], undefined);
-
-        accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.not.be.null;
-        if (cpiGuard !== null) {
-            expect(cpiGuard.lockCpi).to.be.false;
-        }
-    });
-
-    it('enable/disable via command', async () => {
-        let accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        let cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.be.null;
-
-        await enableCpiGuard(connection, payer, account, owner, [], undefined, TEST_PROGRAM_ID);
-
-        accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.not.be.null;
-        if (cpiGuard !== null) {
-            expect(cpiGuard.lockCpi).to.be.true;
-        }
-
-        await disableCpiGuard(connection, payer, account, owner, [], undefined, TEST_PROGRAM_ID);
-
-        accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        cpiGuard = getCpiGuard(accountInfo);
-
-        expect(cpiGuard).to.not.be.null;
-        if (cpiGuard !== null) {
-            expect(cpiGuard.lockCpi).to.be.false;
-        }
-    });
-});
diff --git a/token/js/test/e2e-2022/defaultAccountState.test.ts b/token/js/test/e2e-2022/defaultAccountState.test.ts
deleted file mode 100644
index f0118adbc8c..00000000000
--- a/token/js/test/e2e-2022/defaultAccountState.test.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    AccountState,
-    createAccount,
-    createInitializeMintInstruction,
-    createInitializeDefaultAccountStateInstruction,
-    getAccount,
-    getDefaultAccountState,
-    getMint,
-    getMintLen,
-    updateDefaultAccountState,
-    ExtensionType,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_STATE = AccountState.Frozen;
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.DefaultAccountState];
-describe('defaultAccountState', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let freezeAuthority: Keypair;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        freezeAuthority = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeDefaultAccountStateInstruction(mint, TEST_STATE, TEST_PROGRAM_ID),
-            createInitializeMintInstruction(
-                mint,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                freezeAuthority.publicKey,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-    });
-    it('defaults to frozen', async () => {
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const defaultAccountState = getDefaultAccountState(mintInfo);
-        expect(defaultAccountState).to.not.be.null;
-        if (defaultAccountState !== null) {
-            expect(defaultAccountState.state).to.eql(TEST_STATE);
-        }
-        const owner = Keypair.generate();
-        const account = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner.publicKey,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.isFrozen).to.be.true;
-        expect(accountInfo.isInitialized).to.be.true;
-    });
-    it('defaults to initialized after update', async () => {
-        await updateDefaultAccountState(
-            connection,
-            payer,
-            mint,
-            AccountState.Initialized,
-            freezeAuthority,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const owner = Keypair.generate();
-        const account = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner.publicKey,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.isFrozen).to.be.false;
-        expect(accountInfo.isInitialized).to.be.true;
-    });
-});
diff --git a/token/js/test/e2e-2022/groupMemberPointer.test.ts b/token/js/test/e2e-2022/groupMemberPointer.test.ts
deleted file mode 100644
index 7111787e115..00000000000
--- a/token/js/test/e2e-2022/groupMemberPointer.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-
-import {
-    AuthorityType,
-    ExtensionType,
-    createInitializeGroupMemberPointerInstruction,
-    createInitializeMintInstruction,
-    createSetAuthorityInstruction,
-    createUpdateGroupMemberPointerInstruction,
-    getGroupMemberPointerState,
-    getMint,
-    getMintLen,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.GroupMemberPointer];
-
-describe('GroupMember pointer', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: Keypair;
-    let mintAuthority: Keypair;
-    let memberAddress: PublicKey;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        mint = Keypair.generate();
-        memberAddress = PublicKey.unique();
-
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint.publicKey,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeGroupMemberPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                memberAddress,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(
-                mint.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mint], undefined);
-    });
-
-    it('can successfully initialize', async () => {
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupMemberPointer = getGroupMemberPointerState(mintInfo);
-
-        expect(groupMemberPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            memberAddress,
-        });
-    });
-
-    it('can update to new address', async () => {
-        const newGroupMemberAddress = PublicKey.unique();
-        const transaction = new Transaction().add(
-            createUpdateGroupMemberPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                newGroupMemberAddress,
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupMemberPointer = getGroupMemberPointerState(mintInfo);
-
-        expect(groupMemberPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            memberAddress: newGroupMemberAddress,
-        });
-    });
-
-    it('can update authority', async () => {
-        const newAuthority = PublicKey.unique();
-        const transaction = new Transaction().add(
-            createSetAuthorityInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                AuthorityType.GroupMemberPointer,
-                newAuthority,
-                [],
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupMemberPointer = getGroupMemberPointerState(mintInfo);
-
-        expect(groupMemberPointer).to.deep.equal({
-            authority: newAuthority,
-            memberAddress,
-        });
-    });
-
-    it('can update authority to null', async () => {
-        const transaction = new Transaction().add(
-            createSetAuthorityInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                AuthorityType.GroupMemberPointer,
-                null,
-                [],
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupMemberPointer = getGroupMemberPointerState(mintInfo);
-
-        expect(groupMemberPointer).to.deep.equal({
-            authority: null,
-            memberAddress,
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/groupPointer.test.ts b/token/js/test/e2e-2022/groupPointer.test.ts
deleted file mode 100644
index 5375031d4fa..00000000000
--- a/token/js/test/e2e-2022/groupPointer.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-
-import {
-    AuthorityType,
-    ExtensionType,
-    createInitializeGroupPointerInstruction,
-    createInitializeMintInstruction,
-    createSetAuthorityInstruction,
-    createUpdateGroupPointerInstruction,
-    getGroupPointerState,
-    getMint,
-    getMintLen,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.GroupPointer];
-
-describe('Group pointer', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: Keypair;
-    let mintAuthority: Keypair;
-    let groupAddress: PublicKey;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        mint = Keypair.generate();
-        groupAddress = PublicKey.unique();
-
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint.publicKey,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeGroupPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                groupAddress,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(
-                mint.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mint], undefined);
-    });
-
-    it('can successfully initialize', async () => {
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupPointer = getGroupPointerState(mintInfo);
-
-        expect(groupPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            groupAddress,
-        });
-    });
-
-    it('can update to new address', async () => {
-        const newGroupAddress = PublicKey.unique();
-        const transaction = new Transaction().add(
-            createUpdateGroupPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                newGroupAddress,
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupPointer = getGroupPointerState(mintInfo);
-
-        expect(groupPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            groupAddress: newGroupAddress,
-        });
-    });
-
-    it('can update authority', async () => {
-        const newAuthority = PublicKey.unique();
-        const transaction = new Transaction().add(
-            createSetAuthorityInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                AuthorityType.GroupPointer,
-                newAuthority,
-                [],
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupPointer = getGroupPointerState(mintInfo);
-
-        expect(groupPointer).to.deep.equal({
-            authority: newAuthority,
-            groupAddress,
-        });
-    });
-
-    it('can update authority to null', async () => {
-        const transaction = new Transaction().add(
-            createSetAuthorityInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                AuthorityType.GroupPointer,
-                null,
-                [],
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const groupPointer = getGroupPointerState(mintInfo);
-
-        expect(groupPointer).to.deep.equal({
-            authority: null,
-            groupAddress,
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/immutableOwner.test.ts b/token/js/test/e2e-2022/immutableOwner.test.ts
deleted file mode 100644
index f45c924444c..00000000000
--- a/token/js/test/e2e-2022/immutableOwner.test.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, SystemProgram, Transaction, sendAndConfirmTransaction } from '@solana/web3.js';
-
-import {
-    AuthorityType,
-    setAuthority,
-    ExtensionType,
-    createInitializeImmutableOwnerInstruction,
-    createInitializeAccountInstruction,
-    createMint,
-    getAccountLen,
-} from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.ImmutableOwner];
-describe('immutableOwner', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let account: PublicKey;
-    let mint: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-    });
-    beforeEach(async () => {
-        const mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        owner = Keypair.generate();
-        const accountLen = getAccountLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-        const accountKeypair = Keypair.generate();
-        account = accountKeypair.publicKey;
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: account,
-                space: accountLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeImmutableOwnerInstruction(account, TEST_PROGRAM_ID),
-            createInitializeAccountInstruction(account, mint, owner.publicKey, TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, accountKeypair], undefined);
-    });
-    it('AccountOwner', async () => {
-        const newOwner = Keypair.generate();
-        expect(
-            setAuthority(
-                connection,
-                payer,
-                account,
-                newOwner,
-                AuthorityType.AccountOwner,
-                owner.publicKey,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        ).to.be.rejected;
-    });
-});
diff --git a/token/js/test/e2e-2022/interestBearingMint.test.ts b/token/js/test/e2e-2022/interestBearingMint.test.ts
deleted file mode 100644
index 94e9349dceb..00000000000
--- a/token/js/test/e2e-2022/interestBearingMint.test.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-import {
-    AuthorityType,
-    createInterestBearingMint,
-    getInterestBearingMintConfigState,
-    getMint,
-    setAuthority,
-    updateRateInterestBearingMint,
-} from '../../src';
-import { getConnection, newAccountWithLamports, TEST_PROGRAM_ID } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const TEST_RATE = 10;
-const TEST_UPDATE_RATE = 50;
-
-describe('interestBearingMint', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let rateAuthority: Keypair;
-    let mintAuthority: Keypair;
-    let freezeAuthority: Keypair;
-    let mintKeypair: Keypair;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        rateAuthority = Keypair.generate();
-        mintAuthority = Keypair.generate();
-        freezeAuthority = Keypair.generate();
-    });
-
-    it('initialize and update rate', async () => {
-        mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        await createInterestBearingMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            rateAuthority.publicKey,
-            TEST_RATE,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const interestBearingMintConfigState = getInterestBearingMintConfigState(mintInfo);
-        expect(interestBearingMintConfigState).to.not.be.null;
-        if (interestBearingMintConfigState !== null) {
-            expect(interestBearingMintConfigState.rateAuthority).to.eql(rateAuthority.publicKey);
-            expect(interestBearingMintConfigState.preUpdateAverageRate).to.eql(TEST_RATE);
-            expect(interestBearingMintConfigState.currentRate).to.eql(TEST_RATE);
-            expect(interestBearingMintConfigState.lastUpdateTimestamp).to.be.greaterThan(0);
-            expect(interestBearingMintConfigState.initializationTimestamp).to.be.greaterThan(0);
-        }
-
-        await updateRateInterestBearingMint(
-            connection,
-            payer,
-            mint,
-            rateAuthority,
-            TEST_UPDATE_RATE,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfoUpdatedRate = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const updatedRateConfigState = getInterestBearingMintConfigState(mintInfoUpdatedRate);
-
-        expect(updatedRateConfigState).to.not.be.null;
-        if (updatedRateConfigState !== null) {
-            expect(updatedRateConfigState.rateAuthority).to.eql(rateAuthority.publicKey);
-            expect(updatedRateConfigState.currentRate).to.eql(TEST_UPDATE_RATE);
-            expect(updatedRateConfigState.preUpdateAverageRate).to.eql(TEST_RATE);
-            expect(updatedRateConfigState.lastUpdateTimestamp).to.be.greaterThan(0);
-            expect(updatedRateConfigState.initializationTimestamp).to.be.greaterThan(0);
-        }
-    });
-    it('authority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            rateAuthority,
-            AuthorityType.InterestRate,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const rateConfigState = getInterestBearingMintConfigState(mintInfo);
-        expect(rateConfigState).to.not.be.null;
-        if (rateConfigState !== null) {
-            expect(rateConfigState.rateAuthority).to.eql(PublicKey.default);
-        }
-    });
-});
diff --git a/token/js/test/e2e-2022/memoTransfer.test.ts b/token/js/test/e2e-2022/memoTransfer.test.ts
deleted file mode 100644
index 2c78c2d08a1..00000000000
--- a/token/js/test/e2e-2022/memoTransfer.test.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import { createMemoInstruction } from '@solana/spl-memo';
-import {
-    createAccount,
-    createMint,
-    createEnableRequiredMemoTransfersInstruction,
-    createInitializeAccountInstruction,
-    createTransferInstruction,
-    getAccount,
-    getMemoTransfer,
-    disableRequiredMemoTransfers,
-    enableRequiredMemoTransfers,
-    mintTo,
-    transfer,
-    getAccountLen,
-    ExtensionType,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const TRANSFER_AMOUNT = 1_000;
-const EXTENSIONS = [ExtensionType.MemoTransfer];
-describe('memoTransfer', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let source: PublicKey;
-    let destination: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        owner = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        source = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner.publicKey,
-            undefined, // uses ATA by default
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const destinationKeypair = Keypair.generate();
-        destination = destinationKeypair.publicKey;
-        const accountLen = getAccountLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: destination,
-                space: accountLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeAccountInstruction(destination, mint, owner.publicKey, TEST_PROGRAM_ID),
-            createEnableRequiredMemoTransfersInstruction(destination, owner.publicKey, [], TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, owner, destinationKeypair], undefined);
-        await mintTo(
-            connection,
-            payer,
-            mint,
-            source,
-            mintAuthority,
-            TRANSFER_AMOUNT * 10,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    it('fails without memo when enabled', async () => {
-        const accountInfo = await getAccount(connection, destination, undefined, TEST_PROGRAM_ID);
-        const memoTransfer = getMemoTransfer(accountInfo);
-        expect(memoTransfer).to.not.be.null;
-        if (memoTransfer !== null) {
-            expect(memoTransfer.requireIncomingTransferMemos).to.be.true;
-        }
-        expect(transfer(connection, payer, source, destination, owner, TRANSFER_AMOUNT, [], undefined, TEST_PROGRAM_ID))
-            .to.be.rejected;
-    });
-    it('works without memo when disabled', async () => {
-        await disableRequiredMemoTransfers(connection, payer, destination, owner, [], undefined, TEST_PROGRAM_ID);
-        await transfer(connection, payer, source, destination, owner, TRANSFER_AMOUNT, [], undefined, TEST_PROGRAM_ID);
-        await enableRequiredMemoTransfers(connection, payer, destination, owner, [], undefined, TEST_PROGRAM_ID);
-        expect(transfer(connection, payer, source, destination, owner, TRANSFER_AMOUNT, [], undefined, TEST_PROGRAM_ID))
-            .to.be.rejected;
-    });
-    it('works with memo when enabled', async () => {
-        const transaction = new Transaction().add(
-            createMemoInstruction('transfer with a memo', [payer.publicKey, owner.publicKey]),
-            createTransferInstruction(source, destination, owner.publicKey, TRANSFER_AMOUNT, [], TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, owner], {
-            preflightCommitment: 'confirmed',
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/metadataPointer.test.ts b/token/js/test/e2e-2022/metadataPointer.test.ts
deleted file mode 100644
index 18eeeefa97c..00000000000
--- a/token/js/test/e2e-2022/metadataPointer.test.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMetadataPointerInstruction,
-    createInitializeMintInstruction,
-    createUpdateMetadataPointerInstruction,
-    getMetadataPointerState,
-    getMint,
-    getMintLen,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.MetadataPointer];
-
-describe('Metadata pointer', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: Keypair;
-    let mintAuthority: Keypair;
-    let metadataAddress: PublicKey;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        mint = Keypair.generate();
-        metadataAddress = PublicKey.unique();
-
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint.publicKey,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMetadataPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                metadataAddress,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(
-                mint.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mint], undefined);
-    });
-
-    it('can successfully initialize', async () => {
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const metadataPointer = getMetadataPointerState(mintInfo);
-
-        expect(metadataPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            metadataAddress,
-        });
-    });
-
-    it('can update to new address', async () => {
-        const newMetadataAddress = PublicKey.unique();
-        const transaction = new Transaction().add(
-            createUpdateMetadataPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                newMetadataAddress,
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintAuthority], undefined);
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const metadataPointer = getMetadataPointerState(mintInfo);
-
-        expect(metadataPointer).to.deep.equal({
-            authority: mintAuthority.publicKey,
-            metadataAddress: newMetadataAddress,
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/nonTransferableMint.test.ts b/token/js/test/e2e-2022/nonTransferableMint.test.ts
deleted file mode 100644
index 2d0698e28d3..00000000000
--- a/token/js/test/e2e-2022/nonTransferableMint.test.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createInitializeMintInstruction,
-    createInitializeNonTransferableMintInstruction,
-    createInitializeImmutableOwnerInstruction,
-    createInitializeAccountInstruction,
-    mintTo,
-    getAccountLen,
-    getMint,
-    getMintLen,
-    getNonTransferable,
-    transfer,
-    ExtensionType,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.NonTransferable];
-describe('nonTransferable', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeNonTransferableMintInstruction(mint, TEST_PROGRAM_ID),
-            createInitializeMintInstruction(mint, TEST_TOKEN_DECIMALS, mintAuthority.publicKey, null, TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-    });
-    it('fails transfer', async () => {
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const nonTransferable = getNonTransferable(mintInfo);
-        expect(nonTransferable).to.not.be.null;
-
-        const owner = Keypair.generate();
-        const accountLen = getAccountLen([ExtensionType.ImmutableOwner, ExtensionType.NonTransferableAccount]);
-        const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-        const sourceKeypair = Keypair.generate();
-        const source = sourceKeypair.publicKey;
-        let transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: source,
-                space: accountLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeImmutableOwnerInstruction(source, TEST_PROGRAM_ID),
-            createInitializeAccountInstruction(source, mint, owner.publicKey, TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, sourceKeypair], undefined);
-
-        const destinationKeypair = Keypair.generate();
-        const destination = destinationKeypair.publicKey;
-        transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: destination,
-                space: accountLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeImmutableOwnerInstruction(destination, TEST_PROGRAM_ID),
-            createInitializeAccountInstruction(destination, mint, owner.publicKey, TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, destinationKeypair], undefined);
-
-        const amount = BigInt(1000);
-        await mintTo(connection, payer, mint, source, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-
-        expect(transfer(connection, payer, source, destination, owner, amount, [], undefined, TEST_PROGRAM_ID)).to.be
-            .rejected;
-    });
-});
diff --git a/token/js/test/e2e-2022/permanentDelegate.test.ts b/token/js/test/e2e-2022/permanentDelegate.test.ts
deleted file mode 100644
index b6ac28eb6e1..00000000000
--- a/token/js/test/e2e-2022/permanentDelegate.test.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createAccount,
-    createInitializeMintInstruction,
-    mintTo,
-    getMintLen,
-    ExtensionType,
-    createInitializePermanentDelegateInstruction,
-    burn,
-    transferChecked,
-    AuthorityType,
-    getMint,
-    setAuthority,
-    getPermanentDelegate,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 0;
-const EXTENSIONS = [ExtensionType.PermanentDelegate];
-describe('permanentDelegate', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let permanentDelegate: Keypair;
-    let account: PublicKey;
-    let destination: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        permanentDelegate = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializePermanentDelegateInstruction(mint, permanentDelegate.publicKey, TEST_PROGRAM_ID),
-            createInitializeMintInstruction(mint, TEST_TOKEN_DECIMALS, mintAuthority.publicKey, null, TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-    });
-    it('burn tokens ', async () => {
-        const owner = Keypair.generate();
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-        await mintTo(connection, payer, mint, account, mintAuthority, 5, [], undefined, TEST_PROGRAM_ID);
-        await burn(connection, payer, account, mint, permanentDelegate, 2, undefined, undefined, TEST_PROGRAM_ID);
-        const info = await connection.getTokenAccountBalance(account);
-        expect(info).to.not.be.null;
-        if (info !== null) {
-            expect(info.value.uiAmount).to.eql(3);
-        }
-    });
-    it('transfer tokens', async () => {
-        const owner1 = Keypair.generate();
-        const owner2 = Keypair.generate();
-        destination = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner2.publicKey,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        account = await createAccount(connection, payer, mint, owner1.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-        await mintTo(connection, payer, mint, account, mintAuthority, 5, [], undefined, TEST_PROGRAM_ID);
-        await transferChecked(
-            connection,
-            payer,
-            account,
-            mint,
-            destination,
-            permanentDelegate,
-            2,
-            0,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const source_info = await connection.getTokenAccountBalance(account);
-        const destination_info = await connection.getTokenAccountBalance(destination);
-        expect(source_info).to.not.be.null;
-        expect(destination_info).to.not.be.null;
-        if (source_info !== null) {
-            expect(source_info.value.uiAmount).to.eql(3);
-        }
-        if (destination_info !== null) {
-            expect(destination_info.value.uiAmount).to.eql(2);
-        }
-    });
-    it('authority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            permanentDelegate,
-            AuthorityType.PermanentDelegate,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const permanentDelegateConfig = getPermanentDelegate(mintInfo);
-        expect(permanentDelegateConfig).to.not.be.null;
-        if (permanentDelegateConfig !== null) {
-            expect(permanentDelegateConfig.delegate).to.eql(PublicKey.default);
-        }
-    });
-});
diff --git a/token/js/test/e2e-2022/reallocate.test.ts b/token/js/test/e2e-2022/reallocate.test.ts
deleted file mode 100644
index d36563954c6..00000000000
--- a/token/js/test/e2e-2022/reallocate.test.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, Transaction, sendAndConfirmTransaction } from '@solana/web3.js';
-
-import { ExtensionType, createAccount, createMint, createReallocateInstruction, getAccountLen } from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.ImmutableOwner];
-describe('reallocate', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let account: PublicKey;
-    let mint: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-    });
-    beforeEach(async () => {
-        const mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        owner = Keypair.generate();
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-    });
-    it('works', async () => {
-        const transaction = new Transaction().add(
-            createReallocateInstruction(
-                account,
-                payer.publicKey,
-                EXTENSIONS,
-                owner.publicKey,
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, owner], undefined);
-        const info = await connection.getAccountInfo(account);
-        expect(info).to.not.be.null;
-        if (info !== null) {
-            const expectedAccountLen = getAccountLen(EXTENSIONS);
-            expect(info.data.length).to.eql(expectedAccountLen);
-        }
-    });
-});
diff --git a/token/js/test/e2e-2022/tlv.test.ts b/token/js/test/e2e-2022/tlv.test.ts
deleted file mode 100644
index a4bcc5e44eb..00000000000
--- a/token/js/test/e2e-2022/tlv.test.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-
-import type { Account, Mint } from '../../src';
-import {
-    createInitializeAccountInstruction,
-    getAccount,
-    getAccountLen,
-    createMint,
-    ExtensionType,
-    getExtensionData,
-    isAccountExtension,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 9;
-const ACCOUNT_EXTENSIONS = Object.values(ExtensionType)
-    .filter(Number.isInteger)
-    .filter((e: any): e is ExtensionType => isAccountExtension(e));
-
-describe('tlv test', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        owner = Keypair.generate();
-    });
-
-    // test that the parser gracefully handles accounts with arbitrary extra bytes
-    it('parse account with extra bytes', async () => {
-        const initTestAccount = async (extraBytes: number) => {
-            const mintKeypair = Keypair.generate();
-            const accountKeypair = Keypair.generate();
-            const account = accountKeypair.publicKey;
-            const accountLen = getAccountLen([]) + extraBytes;
-            const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
-
-            const mint = await createMint(
-                connection,
-                payer,
-                mintKeypair.publicKey,
-                mintKeypair.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintKeypair,
-                undefined,
-                TEST_PROGRAM_ID
-            );
-
-            const transaction = new Transaction().add(
-                SystemProgram.createAccount({
-                    fromPubkey: payer.publicKey,
-                    newAccountPubkey: account,
-                    space: accountLen,
-                    lamports,
-                    programId: TEST_PROGRAM_ID,
-                }),
-                createInitializeAccountInstruction(account, mint, owner.publicKey, TEST_PROGRAM_ID)
-            );
-
-            await sendAndConfirmTransaction(connection, transaction, [payer, accountKeypair], undefined);
-
-            return account;
-        };
-
-        const promises: Promise<[number, Account] | undefined>[] = [];
-        for (let i = 0; i < 16; i++) {
-            // trying to alloc exactly one extra byte causes an unpack failure in the program when initializing
-            if (i == 1) continue;
-
-            promises.push(
-                initTestAccount(i)
-                    .then((account: PublicKey) => getAccount(connection, account, undefined, TEST_PROGRAM_ID))
-                    .then((accountInfo: Account) => {
-                        for (const extension of ACCOUNT_EXTENSIONS) {
-                            // realistically this will never fail with a non-null value, it will just throw
-                            expect(
-                                getExtensionData(extension, accountInfo.tlvData),
-                                `account parse test failed: found ${ExtensionType[extension]}, but should not have. \
-                                test case: no extensions, ${i} extra bytes`
-                            ).to.be.null;
-                        }
-                        return Promise.resolve(undefined);
-                    })
-            );
-        }
-
-        await Promise.all(promises);
-    });
-});
diff --git a/token/js/test/e2e-2022/tokenGroup.test.ts b/token/js/test/e2e-2022/tokenGroup.test.ts
deleted file mode 100644
index 0b302b67095..00000000000
--- a/token/js/test/e2e-2022/tokenGroup.test.ts
+++ /dev/null
@@ -1,240 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import { packTokenGroup } from '@solana/spl-token-group';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    createInitializeGroupPointerInstruction,
-    tokenGroupInitializeGroup,
-    tokenGroupUpdateGroupMaxSize,
-    tokenGroupUpdateGroupAuthority,
-    getTokenGroupState,
-    getMint,
-    getMintLen,
-    tokenGroupInitializeGroupWithRentTransfer,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.GroupPointer];
-
-describe('tokenGroup', async () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: Keypair;
-    let mintAuthority: Keypair;
-    let updateAuthority: Keypair;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        updateAuthority = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        mint = Keypair.generate();
-
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint.publicKey,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeGroupPointerInstruction(
-                mint.publicKey,
-                mintAuthority.publicKey,
-                mint.publicKey,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(
-                mint.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mint], undefined);
-    });
-
-    it('can fetch un-initialized token group as null', async () => {
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(getTokenGroupState(mintInfo)).to.deep.equal(null);
-    });
-
-    it('can initialize', async () => {
-        const tokenGroup = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 10,
-        };
-
-        // Transfer the required amount for rent exemption
-        const lamports = await connection.getMinimumBalanceForRentExemption(packTokenGroup(tokenGroup).length);
-        const transaction = new Transaction().add(
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: mint.publicKey,
-                lamports,
-            })
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer], undefined);
-
-        await tokenGroupInitializeGroup(
-            connection,
-            payer,
-            mint.publicKey,
-            mintAuthority.publicKey,
-            tokenGroup.updateAuthority,
-            tokenGroup.maxSize,
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const group = getTokenGroupState(mintInfo);
-        expect(group).to.deep.equal(tokenGroup);
-    });
-
-    it('can initialize with rent transfer', async () => {
-        const tokenGroup = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 10,
-        };
-
-        await tokenGroupInitializeGroupWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            mintAuthority.publicKey,
-            tokenGroup.updateAuthority,
-            tokenGroup.maxSize,
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const group = getTokenGroupState(mintInfo);
-        expect(group).to.deep.equal(tokenGroup);
-    });
-
-    it('can update max size', async () => {
-        const tokenGroup = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 10,
-        };
-
-        // Transfer the required amount for rent exemption
-        const lamports = await connection.getMinimumBalanceForRentExemption(packTokenGroup(tokenGroup).length);
-        const transaction = new Transaction().add(
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: mint.publicKey,
-                lamports,
-            })
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer], undefined);
-
-        await tokenGroupInitializeGroup(
-            connection,
-            payer,
-            mint.publicKey,
-            mintAuthority.publicKey,
-            tokenGroup.updateAuthority,
-            tokenGroup.maxSize,
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        await tokenGroupUpdateGroupMaxSize(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            20,
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const group = getTokenGroupState(mintInfo);
-        expect(group).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 20,
-        });
-    });
-
-    it('can update authority', async () => {
-        const tokenGroup = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 10,
-        };
-
-        // Transfer the required amount for rent exemption
-        const lamports = await connection.getMinimumBalanceForRentExemption(packTokenGroup(tokenGroup).length);
-        const transaction = new Transaction().add(
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: mint.publicKey,
-                lamports,
-            })
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer], undefined);
-
-        await tokenGroupInitializeGroup(
-            connection,
-            payer,
-            mint.publicKey,
-            mintAuthority.publicKey,
-            tokenGroup.updateAuthority,
-            tokenGroup.maxSize,
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const newUpdateAuthority = Keypair.generate();
-        await tokenGroupUpdateGroupAuthority(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            newUpdateAuthority.publicKey,
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        const group = getTokenGroupState(mintInfo);
-        expect(group).to.deep.equal({
-            updateAuthority: newUpdateAuthority.publicKey,
-            mint: mint.publicKey,
-            size: 0,
-            maxSize: 10,
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/tokenGroupMember.test.ts b/token/js/test/e2e-2022/tokenGroupMember.test.ts
deleted file mode 100644
index 744cc312888..00000000000
--- a/token/js/test/e2e-2022/tokenGroupMember.test.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    createInitializeGroupInstruction,
-    getTokenGroupState,
-    getMint,
-    getMintLen,
-    createInitializeGroupMemberPointerInstruction,
-    createInitializeGroupPointerInstruction,
-    getTokenGroupMemberState,
-    tokenGroupInitializeGroupWithRentTransfer,
-    tokenGroupMemberInitializeWithRentTransfer,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-
-describe('tokenGroupMember', async () => {
-    let connection: Connection;
-    let payer: Signer;
-
-    let groupMint: Keypair;
-    let groupUpdateAuthority: Keypair;
-
-    let memberMint: Keypair;
-    let memberMintAuthority: Keypair;
-    let memberUpdateAuthority: Keypair;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-
-        groupMint = Keypair.generate();
-        const groupMintAuthority = Keypair.generate();
-        groupUpdateAuthority = Keypair.generate();
-
-        memberMint = Keypair.generate();
-        memberMintAuthority = Keypair.generate();
-        memberUpdateAuthority = Keypair.generate();
-
-        const groupMintLen = getMintLen([ExtensionType.GroupPointer]);
-        const groupMintLamports = await connection.getMinimumBalanceForRentExemption(groupMintLen);
-
-        const memberMintLen = getMintLen([ExtensionType.GroupMemberPointer]);
-        const memberMintLamports = await connection.getMinimumBalanceForRentExemption(memberMintLen);
-
-        // Create the group mint and initialize the group.
-        await sendAndConfirmTransaction(
-            connection,
-            new Transaction().add(
-                SystemProgram.createAccount({
-                    fromPubkey: payer.publicKey,
-                    newAccountPubkey: groupMint.publicKey,
-                    space: groupMintLen,
-                    lamports: groupMintLamports,
-                    programId: TEST_PROGRAM_ID,
-                }),
-                createInitializeGroupPointerInstruction(
-                    groupMint.publicKey,
-                    groupUpdateAuthority.publicKey,
-                    groupMint.publicKey,
-                    TEST_PROGRAM_ID
-                ),
-                createInitializeMintInstruction(
-                    groupMint.publicKey,
-                    TEST_TOKEN_DECIMALS,
-                    groupMintAuthority.publicKey,
-                    null,
-                    TEST_PROGRAM_ID
-                )
-            ),
-            [payer, groupMint],
-            undefined
-        );
-        await tokenGroupInitializeGroupWithRentTransfer(
-            connection,
-            payer,
-            groupMint.publicKey,
-            groupMintAuthority.publicKey,
-            groupUpdateAuthority.publicKey,
-            3,
-            [payer, groupMintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        // Create the member mint.
-        await sendAndConfirmTransaction(
-            connection,
-            new Transaction().add(
-                SystemProgram.createAccount({
-                    fromPubkey: payer.publicKey,
-                    newAccountPubkey: memberMint.publicKey,
-                    space: memberMintLen,
-                    lamports: memberMintLamports,
-                    programId: TEST_PROGRAM_ID,
-                }),
-                createInitializeGroupMemberPointerInstruction(
-                    memberMint.publicKey,
-                    memberUpdateAuthority.publicKey,
-                    memberMint.publicKey,
-                    TEST_PROGRAM_ID
-                ),
-                createInitializeMintInstruction(
-                    memberMint.publicKey,
-                    TEST_TOKEN_DECIMALS,
-                    memberMintAuthority.publicKey,
-                    null,
-                    TEST_PROGRAM_ID
-                )
-            ),
-            [payer, memberMint],
-            undefined
-        );
-    });
-
-    it('can initialize a group member', async () => {
-        const tokenGroupMember = {
-            mint: memberMint.publicKey,
-            group: groupMint.publicKey,
-            memberNumber: 1,
-        };
-
-        await tokenGroupMemberInitializeWithRentTransfer(
-            connection,
-            payer,
-            memberMint.publicKey,
-            memberMintAuthority.publicKey,
-            groupMint.publicKey,
-            groupUpdateAuthority.publicKey,
-            [memberMintAuthority, groupUpdateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, memberMint.publicKey, undefined, TEST_PROGRAM_ID);
-        const member = getTokenGroupMemberState(mintInfo);
-        expect(member).to.deep.equal(tokenGroupMember);
-    });
-});
diff --git a/token/js/test/e2e-2022/tokenMetadata.test.ts b/token/js/test/e2e-2022/tokenMetadata.test.ts
deleted file mode 100644
index b98bce9a233..00000000000
--- a/token/js/test/e2e-2022/tokenMetadata.test.ts
+++ /dev/null
@@ -1,524 +0,0 @@
-import { expect } from 'chai';
-import { getBase64Encoder } from '@solana/codecs-strings';
-import { createEmitInstruction, pack } from '@solana/spl-token-metadata';
-import {
-    type Connection,
-    sendAndConfirmTransaction,
-    Keypair,
-    type Signer,
-    SystemProgram,
-    Transaction,
-    VersionedTransaction,
-    TransactionMessage,
-} from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMetadataPointerInstruction,
-    createInitializeMintInstruction,
-    getMintLen,
-    getTokenMetadata,
-    tokenMetadataInitialize,
-    tokenMetadataInitializeWithRentTransfer,
-    tokenMetadataRemoveKey,
-    tokenMetadataUpdateAuthority,
-    tokenMetadataUpdateField,
-    tokenMetadataUpdateFieldWithRentTransfer,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.MetadataPointer];
-
-describe('tokenMetadata', async () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: Keypair;
-    let mintAuthority: Keypair;
-    let updateAuthority: Keypair;
-
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        updateAuthority = Keypair.generate();
-    });
-
-    beforeEach(async () => {
-        mint = Keypair.generate();
-
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint.publicKey,
-                space: mintLen,
-                lamports: lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMetadataPointerInstruction(
-                mint.publicKey,
-                updateAuthority.publicKey,
-                mint.publicKey,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(
-                mint.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority.publicKey,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mint], undefined);
-    });
-
-    it('can fetch un-initialized token metadata as null', async () => {
-        expect(await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID)).to.deep.equal(null);
-    });
-
-    it('can initialize', async () => {
-        const tokenMetadata = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        };
-
-        // Transfer the required amount for rent exemption
-        const lamports = await connection.getMinimumBalanceForRentExemption(pack(tokenMetadata).length);
-        const transaction = new Transaction().add(
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: mint.publicKey,
-                lamports,
-            })
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer], undefined);
-
-        await tokenMetadataInitialize(
-            connection,
-            payer,
-            mint.publicKey,
-            tokenMetadata.updateAuthority,
-            mintAuthority,
-            tokenMetadata.name,
-            tokenMetadata.symbol,
-            tokenMetadata.uri,
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can initialize with rent transfer', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can update an existing default field', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateField(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'name',
-            'TEST',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'TEST',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can update an existing default field with rent transfer', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'name',
-            'My Shiny New Token Metadata',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'My Shiny New Token Metadata',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can create a custom field with rent transfer', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'CUSTOM',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [['myCustomField', 'CUSTOM']],
-        });
-    });
-
-    it('can update a custom field', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'CUSTOM',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateField(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'test',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [['myCustomField', 'test']],
-        });
-    });
-
-    it('can update a custom field with rent transfer', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'CUSTOM',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'My Shiny Custom Field',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [['myCustomField', 'My Shiny Custom Field']],
-        });
-    });
-
-    it('can remove a custom field', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataUpdateFieldWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            'CUSTOM',
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataRemoveKey(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            true,
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can handle removal of a key that does not exist when idempotent is true', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        await tokenMetadataRemoveKey(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            'myCustomField',
-            true,
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can update the authority', async () => {
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            mintAuthority,
-            'name',
-            'symbol',
-            'uri',
-            [mintAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const newAuthority = Keypair.generate().publicKey;
-        await tokenMetadataUpdateAuthority(
-            connection,
-            payer,
-            mint.publicKey,
-            updateAuthority.publicKey,
-            newAuthority,
-            [updateAuthority],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const meta = await getTokenMetadata(connection, mint.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(meta).to.deep.equal({
-            updateAuthority: newAuthority,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        });
-    });
-
-    it('can emit part of a token metadata', async () => {
-        const tokenMetadata = {
-            updateAuthority: updateAuthority.publicKey,
-            mint: mint.publicKey,
-            name: 'name',
-            symbol: 'symbol',
-            uri: 'uri',
-            additionalMetadata: [],
-        };
-
-        await tokenMetadataInitializeWithRentTransfer(
-            connection,
-            payer,
-            mint.publicKey,
-            tokenMetadata.updateAuthority,
-            mintAuthority,
-            tokenMetadata.name,
-            tokenMetadata.symbol,
-            tokenMetadata.uri,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const payerKey = payer.publicKey;
-        const recentBlockhash = await connection.getLatestBlockhash().then((res) => res.blockhash);
-        const instructions = [
-            createEmitInstruction({
-                programId: TEST_PROGRAM_ID,
-                metadata: mint.publicKey,
-                start: 0n,
-                end: 32n,
-            }),
-        ];
-        const messageV0 = new TransactionMessage({
-            payerKey,
-            recentBlockhash,
-            instructions,
-        }).compileToV0Message();
-        const tx = new VersionedTransaction(messageV0);
-        tx.sign([payer]);
-
-        const returnDataBase64 = (await connection
-            .simulateTransaction(tx)
-            .then((res) => res.value.returnData?.data[0])) as string;
-        const returnData = getBase64Encoder().encode(returnDataBase64);
-
-        expect(returnData).to.deep.equal(tokenMetadata.updateAuthority.toBuffer());
-    });
-});
diff --git a/token/js/test/e2e-2022/transferFee.test.ts b/token/js/test/e2e-2022/transferFee.test.ts
deleted file mode 100644
index e7315f6538f..00000000000
--- a/token/js/test/e2e-2022/transferFee.test.ts
+++ /dev/null
@@ -1,373 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, Signer } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
-import { Keypair, SystemProgram, Transaction, sendAndConfirmTransaction } from '@solana/web3.js';
-
-import {
-    ExtensionType,
-    createInitializeMintInstruction,
-    getTransferFeeAmount,
-    getTransferFeeConfig,
-    mintTo,
-    transferChecked,
-    createAccount,
-    getAccount,
-    getMint,
-    getMintLen,
-    setAuthority,
-    AuthorityType,
-} from '../../src';
-
-import {
-    createInitializeTransferFeeConfigInstruction,
-    harvestWithheldTokensToMint,
-    transferCheckedWithFee,
-    withdrawWithheldTokensFromAccounts,
-    withdrawWithheldTokensFromMint,
-    setTransferFee,
-} from '../../src/extensions/transferFee/index';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-const TEST_TOKEN_DECIMALS = 2;
-const MINT_EXTENSIONS = [ExtensionType.TransferFeeConfig];
-const MINT_AMOUNT = BigInt(1_000_000_000);
-const TRANSFER_AMOUNT = BigInt(1_000_000);
-const FEE_BASIS_POINTS = 100;
-const MAX_FEE = BigInt(100_000);
-const FEE = (TRANSFER_AMOUNT * BigInt(FEE_BASIS_POINTS)) / BigInt(10_000);
-describe('transferFee', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let sourceAccount: PublicKey;
-    let destinationAccount: PublicKey;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-    });
-
-    async function setupTransferFeeMint(
-        transferFeeConfigAuthority: PublicKey | null,
-        withdrawWithheldAuthority: PublicKey | null
-    ) {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        mintAuthority = Keypair.generate();
-        const mintLen = getMintLen(MINT_EXTENSIONS);
-        const mintLamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-        const mintTransaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports: mintLamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeTransferFeeConfigInstruction(
-                mint,
-                transferFeeConfigAuthority,
-                withdrawWithheldAuthority,
-                FEE_BASIS_POINTS,
-                MAX_FEE,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(mint, TEST_TOKEN_DECIMALS, mintAuthority.publicKey, null, TEST_PROGRAM_ID)
-        );
-        await sendAndConfirmTransaction(connection, mintTransaction, [payer, mintKeypair], undefined);
-    }
-
-    describe('with authorities set', () => {
-        let transferFeeConfigAuthority: Keypair;
-        let withdrawWithheldAuthority: Keypair;
-        beforeEach(async () => {
-            transferFeeConfigAuthority = Keypair.generate();
-            withdrawWithheldAuthority = Keypair.generate();
-
-            await setupTransferFeeMint(transferFeeConfigAuthority.publicKey, withdrawWithheldAuthority.publicKey);
-
-            owner = Keypair.generate();
-            sourceAccount = await createAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                undefined,
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            await mintTo(
-                connection,
-                payer,
-                mint,
-                sourceAccount,
-                mintAuthority,
-                MINT_AMOUNT,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-
-            const accountKeypair = Keypair.generate();
-            destinationAccount = await createAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                accountKeypair,
-                undefined,
-                TEST_PROGRAM_ID
-            );
-
-            await transferChecked(
-                connection,
-                payer,
-                sourceAccount,
-                mint,
-                destinationAccount,
-                owner,
-                TRANSFER_AMOUNT,
-                TEST_TOKEN_DECIMALS,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-        });
-        it('initializes', async () => {
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(transferFeeConfigAuthority.publicKey);
-                expect(transferFeeConfig.withdrawWithheldAuthority).to.eql(withdrawWithheldAuthority.publicKey);
-                expect(transferFeeConfig.olderTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.olderTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.newerTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.newerTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.withheldAmount).to.eql(BigInt(0));
-            }
-
-            const accountInfo = await getAccount(connection, destinationAccount, undefined, TEST_PROGRAM_ID);
-            const transferFeeAmount = getTransferFeeAmount(accountInfo);
-            expect(transferFeeAmount).to.not.be.null;
-            if (transferFeeAmount !== null) {
-                expect(transferFeeAmount.withheldAmount).to.eql(FEE);
-            }
-        });
-        it('transferCheckedWithFee', async () => {
-            await transferCheckedWithFee(
-                connection,
-                payer,
-                sourceAccount,
-                mint,
-                destinationAccount,
-                owner,
-                TRANSFER_AMOUNT,
-                TEST_TOKEN_DECIMALS,
-                FEE,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const accountInfo = await getAccount(connection, destinationAccount, undefined, TEST_PROGRAM_ID);
-            const transferFeeAmount = getTransferFeeAmount(accountInfo);
-            expect(transferFeeAmount).to.not.be.null;
-            if (transferFeeAmount !== null) {
-                expect(transferFeeAmount.withheldAmount).to.eql(FEE * BigInt(2));
-            }
-        });
-        it('withdrawWithheldTokensFromAccounts', async () => {
-            await withdrawWithheldTokensFromAccounts(
-                connection,
-                payer,
-                mint,
-                destinationAccount,
-                withdrawWithheldAuthority,
-                [],
-                [destinationAccount],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const accountInfo = await getAccount(connection, destinationAccount, undefined, TEST_PROGRAM_ID);
-            expect(accountInfo.amount).to.eql(TRANSFER_AMOUNT);
-            const transferFeeAmount = getTransferFeeAmount(accountInfo);
-            expect(transferFeeAmount).to.not.be.null;
-            if (transferFeeAmount !== null) {
-                expect(transferFeeAmount.withheldAmount).to.eql(BigInt(0));
-            }
-        });
-        it('harvestWithheldTokensToMint', async () => {
-            await harvestWithheldTokensToMint(
-                connection,
-                payer,
-                mint,
-                [destinationAccount],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const accountInfo = await getAccount(connection, destinationAccount, undefined, TEST_PROGRAM_ID);
-            const transferFeeAmount = getTransferFeeAmount(accountInfo);
-            expect(transferFeeAmount).to.not.be.null;
-            if (transferFeeAmount !== null) {
-                expect(transferFeeAmount.withheldAmount).to.eql(BigInt(0));
-            }
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.withheldAmount).to.eql(FEE);
-            }
-        });
-        it('withdrawWithheldTokensFromMint', async () => {
-            await harvestWithheldTokensToMint(
-                connection,
-                payer,
-                mint,
-                [destinationAccount],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            await withdrawWithheldTokensFromMint(
-                connection,
-                payer,
-                mint,
-                destinationAccount,
-                withdrawWithheldAuthority,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const accountInfo = await getAccount(connection, destinationAccount, undefined, TEST_PROGRAM_ID);
-            expect(accountInfo.amount).to.eql(TRANSFER_AMOUNT);
-            const transferFeeAmount = getTransferFeeAmount(accountInfo);
-            expect(transferFeeAmount).to.not.be.null;
-            if (transferFeeAmount !== null) {
-                expect(transferFeeAmount.withheldAmount).to.eql(BigInt(0));
-            }
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.withheldAmount).to.eql(BigInt(0));
-            }
-        });
-        it('transferFeeConfigAuthority', async () => {
-            await setAuthority(
-                connection,
-                payer,
-                mint,
-                transferFeeConfigAuthority,
-                AuthorityType.TransferFeeConfig,
-                null,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(PublicKey.default);
-            }
-        });
-        it('withdrawWithheldAuthority', async () => {
-            await setAuthority(
-                connection,
-                payer,
-                mint,
-                withdrawWithheldAuthority,
-                AuthorityType.WithheldWithdraw,
-                null,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.withdrawWithheldAuthority).to.eql(PublicKey.default);
-            }
-        });
-        it('setTransferFee', async () => {
-            const UPDATED_FEE_BASIS_POINTS = 150;
-            const UPDATED_MAX_FEE = BigInt(150_000);
-
-            await setTransferFee(
-                connection,
-                payer,
-                mint,
-                transferFeeConfigAuthority,
-                [],
-                UPDATED_FEE_BASIS_POINTS,
-                UPDATED_MAX_FEE,
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(transferFeeConfigAuthority.publicKey);
-                expect(transferFeeConfig.olderTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.olderTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.newerTransferFee.transferFeeBasisPoints).to.eql(UPDATED_FEE_BASIS_POINTS);
-                expect(transferFeeConfig.newerTransferFee.maximumFee).to.eql(UPDATED_MAX_FEE);
-            }
-        });
-    });
-
-    describe('with null authorities', () => {
-        it('initializes with null transfer fee config authority', async () => {
-            const withdrawWithheldAuthority = Keypair.generate();
-            await setupTransferFeeMint(null, withdrawWithheldAuthority.publicKey);
-
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(PublicKey.default);
-                expect(transferFeeConfig.withdrawWithheldAuthority).to.eql(withdrawWithheldAuthority.publicKey);
-                expect(transferFeeConfig.olderTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.olderTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.newerTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.newerTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.withheldAmount).to.eql(BigInt(0));
-            }
-        });
-        it('initializes with null withdraw withheld authority', async () => {
-            const transferFeeConfigAuthority = Keypair.generate();
-            await setupTransferFeeMint(transferFeeConfigAuthority.publicKey, null);
-
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(transferFeeConfigAuthority.publicKey);
-                expect(transferFeeConfig.withdrawWithheldAuthority).to.eql(PublicKey.default);
-                expect(transferFeeConfig.olderTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.olderTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.newerTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.newerTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.withheldAmount).to.eql(BigInt(0));
-            }
-        });
-        it('initializes with both authorities null', async () => {
-            await setupTransferFeeMint(null, null);
-
-            const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-            const transferFeeConfig = getTransferFeeConfig(mintInfo);
-            expect(transferFeeConfig).to.not.be.null;
-            if (transferFeeConfig !== null) {
-                expect(transferFeeConfig.transferFeeConfigAuthority).to.eql(PublicKey.default);
-                expect(transferFeeConfig.withdrawWithheldAuthority).to.eql(PublicKey.default);
-                expect(transferFeeConfig.olderTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.olderTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.newerTransferFee.transferFeeBasisPoints).to.eql(FEE_BASIS_POINTS);
-                expect(transferFeeConfig.newerTransferFee.maximumFee).to.eql(MAX_FEE);
-                expect(transferFeeConfig.withheldAmount).to.eql(BigInt(0));
-            }
-        });
-    });
-});
diff --git a/token/js/test/e2e-2022/transferHook.test.ts b/token/js/test/e2e-2022/transferHook.test.ts
deleted file mode 100644
index 717c940335e..00000000000
--- a/token/js/test/e2e-2022/transferHook.test.ts
+++ /dev/null
@@ -1,221 +0,0 @@
-import { expect } from 'chai';
-import type { AccountMeta, Connection, Signer } from '@solana/web3.js';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { sendAndConfirmTransaction, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
-import {
-    createInitializeMintInstruction,
-    getMint,
-    getMintLen,
-    ExtensionType,
-    createInitializeTransferHookInstruction,
-    getTransferHook,
-    updateTransferHook,
-    AuthorityType,
-    setAuthority,
-    createAssociatedTokenAccountInstruction,
-    getAssociatedTokenAddressSync,
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    createMintToCheckedInstruction,
-    getExtraAccountMetaAddress,
-    ExtraAccountMetaListLayout,
-    ExtraAccountMetaLayout,
-    transferCheckedWithTransferHook,
-    createAssociatedTokenAccountIdempotent,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection, TRANSFER_HOOK_TEST_PROGRAM_ID } from '../common';
-import { createHash } from 'crypto';
-
-const TEST_TOKEN_DECIMALS = 2;
-const EXTENSIONS = [ExtensionType.TransferHook];
-describe('transferHook', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let payerAta: PublicKey;
-    let destinationAuthority: PublicKey;
-    let destinationAta: PublicKey;
-    let transferHookAuthority: Keypair;
-    let pdaExtraAccountMeta: PublicKey;
-    let mint: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        destinationAuthority = Keypair.generate().publicKey;
-        transferHookAuthority = Keypair.generate();
-    });
-    beforeEach(async () => {
-        const mintKeypair = Keypair.generate();
-        mint = mintKeypair.publicKey;
-        pdaExtraAccountMeta = getExtraAccountMetaAddress(mint, TRANSFER_HOOK_TEST_PROGRAM_ID);
-        payerAta = getAssociatedTokenAddressSync(
-            mint,
-            payer.publicKey,
-            false,
-            TEST_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-        destinationAta = getAssociatedTokenAddressSync(
-            mint,
-            destinationAuthority,
-            false,
-            TEST_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-        const mintLen = getMintLen(EXTENSIONS);
-        const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mint,
-                space: mintLen,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeTransferHookInstruction(
-                mint,
-                transferHookAuthority.publicKey,
-                TRANSFER_HOOK_TEST_PROGRAM_ID,
-                TEST_PROGRAM_ID
-            ),
-            createInitializeMintInstruction(mint, TEST_TOKEN_DECIMALS, payer.publicKey, null, TEST_PROGRAM_ID)
-        );
-
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair], undefined);
-    });
-    it('is initialized', async () => {
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const transferHook = getTransferHook(mintInfo);
-        expect(transferHook).to.not.be.null;
-        if (transferHook !== null) {
-            expect(transferHook.authority).to.eql(transferHookAuthority.publicKey);
-            expect(transferHook.programId).to.eql(TRANSFER_HOOK_TEST_PROGRAM_ID);
-        }
-    });
-    it('can be updated', async () => {
-        const newTransferHookProgramId = Keypair.generate().publicKey;
-        await updateTransferHook(
-            connection,
-            payer,
-            mint,
-            newTransferHookProgramId,
-            transferHookAuthority,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const transferHook = getTransferHook(mintInfo);
-        expect(transferHook).to.not.be.null;
-        if (transferHook !== null) {
-            expect(transferHook.authority).to.eql(transferHookAuthority.publicKey);
-            expect(transferHook.programId).to.eql(newTransferHookProgramId);
-        }
-    });
-    it('authority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            transferHookAuthority,
-            AuthorityType.TransferHookProgramId,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        const transferHook = getTransferHook(mintInfo);
-        expect(transferHook).to.not.be.null;
-        if (transferHook !== null) {
-            expect(transferHook.authority).to.eql(PublicKey.default);
-        }
-    });
-    it('transferChecked', async () => {
-        const extraAccount = Keypair.generate().publicKey;
-        const keys: AccountMeta[] = [
-            { pubkey: pdaExtraAccountMeta, isSigner: false, isWritable: true },
-            { pubkey: mint, isSigner: false, isWritable: false },
-            { pubkey: payer.publicKey, isSigner: true, isWritable: false },
-            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-        ];
-
-        const data = Buffer.alloc(8 + 4 + ExtraAccountMetaLayout.span);
-        const discriminator = createHash('sha256')
-            .update('spl-transfer-hook-interface:initialize-extra-account-metas')
-            .digest()
-            .subarray(0, 8);
-        discriminator.copy(data);
-        ExtraAccountMetaListLayout.encode(
-            {
-                count: 1,
-                extraAccounts: [
-                    {
-                        discriminator: 0,
-                        addressConfig: extraAccount.toBuffer(),
-                        isSigner: false,
-                        isWritable: false,
-                    },
-                ],
-            },
-            data,
-            8
-        );
-
-        const initExtraAccountMetaInstruction = new TransactionInstruction({
-            keys,
-            data,
-            programId: TRANSFER_HOOK_TEST_PROGRAM_ID,
-        });
-
-        const setupTransaction = new Transaction().add(
-            initExtraAccountMetaInstruction,
-            SystemProgram.transfer({
-                fromPubkey: payer.publicKey,
-                toPubkey: pdaExtraAccountMeta,
-                lamports: 10000000,
-            }),
-            createAssociatedTokenAccountInstruction(
-                payer.publicKey,
-                payerAta,
-                payer.publicKey,
-                mint,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            ),
-            createMintToCheckedInstruction(
-                mint,
-                payerAta,
-                payer.publicKey,
-                5 * 10 ** TEST_TOKEN_DECIMALS,
-                TEST_TOKEN_DECIMALS,
-                [],
-                TEST_PROGRAM_ID
-            )
-        );
-
-        await sendAndConfirmTransaction(connection, setupTransaction, [payer]);
-
-        await createAssociatedTokenAccountIdempotent(
-            connection,
-            payer,
-            mint,
-            destinationAuthority,
-            undefined,
-            TEST_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-
-        await transferCheckedWithTransferHook(
-            connection,
-            payer,
-            payerAta,
-            mint,
-            destinationAta,
-            payer,
-            BigInt(10 ** TEST_TOKEN_DECIMALS),
-            TEST_TOKEN_DECIMALS,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-});
diff --git a/token/js/test/e2e/amount.test.ts b/token/js/test/e2e/amount.test.ts
deleted file mode 100644
index a8e0c0d8c09..00000000000
--- a/token/js/test/e2e/amount.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-import { createMint, amountToUiAmount, uiAmountToAmount } from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('Amount', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    it('amountToUiAmount', async () => {
-        const amount = BigInt(5245);
-        const uiAmount = await amountToUiAmount(connection, payer, mint, amount, TEST_PROGRAM_ID);
-        expect(uiAmount).to.eql('52.45');
-    });
-    it('uiAmountToAmount', async () => {
-        const uiAmount = await uiAmountToAmount(connection, payer, mint, '52.45', TEST_PROGRAM_ID);
-        expect(uiAmount).to.eql(BigInt(5245));
-    });
-});
diff --git a/token/js/test/e2e/burn.test.ts b/token/js/test/e2e/burn.test.ts
deleted file mode 100644
index 4b0c4e23ff5..00000000000
--- a/token/js/test/e2e/burn.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-import { createMint, createAccount, getAccount, mintTo, burn, burnChecked } from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('burn', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let owner: Keypair;
-    let account: PublicKey;
-    let amount: bigint;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        owner = Keypair.generate();
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-        amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-    });
-    it('burn', async () => {
-        const burnAmount = BigInt(1);
-        await burn(connection, payer, account, mint, owner, burnAmount, [], undefined, TEST_PROGRAM_ID);
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.amount).to.eql(amount - burnAmount);
-    });
-    it('burnChecked', async () => {
-        const burnAmount = BigInt(1);
-        await burnChecked(
-            connection,
-            payer,
-            account,
-            mint,
-            owner,
-            burnAmount,
-            TEST_TOKEN_DECIMALS,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.amount).to.eql(amount - burnAmount);
-    });
-});
diff --git a/token/js/test/e2e/close.test.ts b/token/js/test/e2e/close.test.ts
deleted file mode 100644
index 6d03a6ccf33..00000000000
--- a/token/js/test/e2e/close.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { expect, use } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-import { createMint, createAccount, closeAccount, mintTo } from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('close', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let freezeAuthority: Keypair;
-    let owner: Keypair;
-    let account: PublicKey;
-    let destination: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        freezeAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        owner = Keypair.generate();
-        destination = Keypair.generate().publicKey;
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-    });
-    it('failsWithNonZeroAmount', async () => {
-        const amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-        expect(closeAccount(connection, payer, account, destination, owner, [], undefined, TEST_PROGRAM_ID)).to.be
-            .rejected;
-    });
-    it('works', async () => {
-        const accountInfo = await connection.getAccountInfo(account);
-        let tokenRentExemptAmount;
-        expect(accountInfo).to.not.be.null;
-        if (accountInfo !== null) {
-            tokenRentExemptAmount = accountInfo.lamports;
-        }
-
-        await closeAccount(connection, payer, account, destination, owner, [], undefined, TEST_PROGRAM_ID);
-
-        const closedInfo = await connection.getAccountInfo(account);
-        expect(closedInfo).to.be.null;
-
-        const destinationInfo = await connection.getAccountInfo(destination);
-        expect(destinationInfo).to.not.be.null;
-        if (destinationInfo !== null) {
-            expect(destinationInfo.lamports).to.eql(tokenRentExemptAmount);
-        }
-    });
-});
diff --git a/token/js/test/e2e/create.test.ts b/token/js/test/e2e/create.test.ts
deleted file mode 100644
index 5d16638e6be..00000000000
--- a/token/js/test/e2e/create.test.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import {
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    createMint,
-    getMint,
-    createAccount,
-    createAssociatedTokenAccountIdempotent,
-    getAccount,
-    getAssociatedTokenAddress,
-    getOrCreateAssociatedTokenAccount,
-} from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('createMint', () => {
-    it('works', async () => {
-        const connection = await getConnection();
-        const payer = await newAccountWithLamports(connection, 1000000000);
-        const testMintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        const mint = await createMint(
-            connection,
-            payer,
-            testMintAuthority.publicKey,
-            testMintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-
-        expect(mintInfo.mintAuthority).to.eql(testMintAuthority.publicKey);
-        expect(mintInfo.supply).to.eql(BigInt(0));
-        expect(mintInfo.decimals).to.eql(TEST_TOKEN_DECIMALS);
-        expect(mintInfo.isInitialized).to.be.true;
-        expect(mintInfo.freezeAuthority).to.eql(testMintAuthority.publicKey);
-    });
-});
-
-describe('createAccount', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        const mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    }),
-        it('auxiliary token account', async () => {
-            const owner = Keypair.generate();
-            const account = await createAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                Keypair.generate(),
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-            expect(accountInfo.mint).to.eql(mint);
-            expect(accountInfo.owner).to.eql(owner.publicKey);
-            expect(accountInfo.amount).to.eql(BigInt(0));
-            expect(accountInfo.delegate).to.be.null;
-            expect(accountInfo.delegatedAmount).to.eql(BigInt(0));
-            expect(accountInfo.isInitialized).to.be.true;
-            expect(accountInfo.isFrozen).to.be.false;
-            expect(accountInfo.isNative).to.be.false;
-            expect(accountInfo.rentExemptReserve).to.be.null;
-            expect(accountInfo.closeAuthority).to.be.null;
-
-            // you can create as many accounts as with same owner
-            const account2 = await createAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                Keypair.generate(),
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            expect(account2).to.not.eql(account);
-        }),
-        it('creates associated token account if it does not exist', async () => {
-            const owner = Keypair.generate();
-            const associatedAddress = await getAssociatedTokenAddress(
-                mint,
-                owner.publicKey,
-                false,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            );
-
-            // associated account shouldn't exist
-            const info = await connection.getAccountInfo(associatedAddress);
-            expect(info).to.be.null;
-
-            const createdAccountInfo = await getOrCreateAssociatedTokenAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                false,
-                undefined,
-                undefined,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            );
-            expect(createdAccountInfo.mint).to.eql(mint);
-            expect(createdAccountInfo.owner).to.eql(owner.publicKey);
-            expect(createdAccountInfo.amount).to.eql(BigInt(0));
-            expect(createdAccountInfo.delegate).to.be.null;
-            expect(createdAccountInfo.delegatedAmount).to.eql(BigInt(0));
-            expect(createdAccountInfo.isInitialized).to.be.true;
-            expect(createdAccountInfo.isFrozen).to.be.false;
-            expect(createdAccountInfo.isNative).to.be.false;
-            expect(createdAccountInfo.rentExemptReserve).to.be.null;
-            expect(createdAccountInfo.closeAuthority).to.be.null;
-
-            // do it again, just gives the account info
-            const accountInfo = await getOrCreateAssociatedTokenAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                false,
-                undefined,
-                undefined,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            );
-
-            expect(createdAccountInfo).to.eql(accountInfo);
-        }),
-        it('associated token account', async () => {
-            const owner = Keypair.generate();
-            const associatedAddress = await getAssociatedTokenAddress(
-                mint,
-                owner.publicKey,
-                false,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            );
-
-            // associated account shouldn't exist
-            const info = await connection.getAccountInfo(associatedAddress);
-            expect(info).to.be.null;
-
-            const createdAddress = await createAccount(
-                connection,
-                payer,
-                mint,
-                owner.publicKey,
-                undefined, // uses ATA by default
-                undefined,
-                TEST_PROGRAM_ID
-            );
-            expect(createdAddress).to.eql(associatedAddress);
-
-            const accountInfo = await getAccount(connection, associatedAddress, undefined, TEST_PROGRAM_ID);
-            expect(accountInfo).to.not.be.null;
-            expect(accountInfo.mint).to.eql(mint);
-            expect(accountInfo.owner).to.eql(owner.publicKey);
-            expect(accountInfo.amount).to.eql(BigInt(0));
-
-            // creating again should cause TX error for the associated token account
-            expect(
-                createAccount(
-                    connection,
-                    payer,
-                    mint,
-                    owner.publicKey,
-                    undefined, // uses ATA by default
-                    undefined,
-                    TEST_PROGRAM_ID
-                )
-            ).to.be.rejected;
-
-            // when creating again but with idempotent mode, TX should not throw error
-            return expect(
-                createAssociatedTokenAccountIdempotent(
-                    connection,
-                    payer,
-                    mint,
-                    owner.publicKey,
-                    undefined,
-                    TEST_PROGRAM_ID
-                )
-            ).to.be.fulfilled;
-        });
-});
diff --git a/token/js/test/e2e/freeze.test.ts b/token/js/test/e2e/freeze.test.ts
deleted file mode 100644
index 1b5a4ea82b2..00000000000
--- a/token/js/test/e2e/freeze.test.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import { burn, createMint, createAccount, getAccount, freezeAccount, thawAccount, mintTo } from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('freezeThaw', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let freezeAuthority: Keypair;
-    let owner: Keypair;
-    let account: PublicKey;
-    let amount: bigint;
-    const burnAmount = BigInt(1);
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        freezeAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        owner = Keypair.generate();
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-        amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-    });
-    it('freezes', async () => {
-        await freezeAccount(connection, payer, account, mint, freezeAuthority, [], undefined, TEST_PROGRAM_ID);
-
-        expect(burn(connection, payer, account, mint, owner, burnAmount, [], undefined, TEST_PROGRAM_ID)).to.be
-            .rejected;
-    });
-    it('thaws', async () => {
-        await freezeAccount(connection, payer, account, mint, freezeAuthority, [], undefined, TEST_PROGRAM_ID);
-
-        await thawAccount(connection, payer, account, mint, freezeAuthority, [], undefined, TEST_PROGRAM_ID);
-
-        await burn(connection, payer, account, mint, owner, burnAmount, [], undefined, TEST_PROGRAM_ID);
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-
-        expect(accountInfo.amount).to.eql(amount - burnAmount);
-    });
-});
diff --git a/token/js/test/e2e/initialize.test.ts b/token/js/test/e2e/initialize.test.ts
deleted file mode 100644
index 973f0fca20b..00000000000
--- a/token/js/test/e2e/initialize.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import type { Connection, Signer } from '@solana/web3.js';
-import { Transaction, SystemProgram, Keypair, sendAndConfirmTransaction } from '@solana/web3.js';
-import { expect } from 'chai';
-import {
-    getMinimumBalanceForRentExemptMint,
-    MINT_SIZE,
-    createInitializeMint2Instruction,
-    getMint,
-    createInitializeMintInstruction,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-
-describe('initialize mint', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mintKeypair: Keypair;
-    let lamports: number;
-    beforeEach(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintKeypair = Keypair.generate();
-        lamports = await getMinimumBalanceForRentExemptMint(connection);
-    });
-    it('works', async () => {
-        const mintAuthority = Keypair.generate().publicKey;
-        const freezeAuthority = Keypair.generate().publicKey;
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mintKeypair.publicKey,
-                space: MINT_SIZE,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMintInstruction(
-                mintKeypair.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority,
-                freezeAuthority,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair]);
-        const mintInfo = await getMint(connection, mintKeypair.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.mintAuthority).to.eql(mintAuthority);
-        expect(mintInfo.supply).to.eql(BigInt(0));
-        expect(mintInfo.decimals).to.eql(TEST_TOKEN_DECIMALS);
-        expect(mintInfo.isInitialized).to.be.true;
-        expect(mintInfo.freezeAuthority).to.eql(freezeAuthority);
-    });
-    it('works with null freeze authority', async () => {
-        const mintAuthority = Keypair.generate().publicKey;
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mintKeypair.publicKey,
-                space: MINT_SIZE,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMintInstruction(
-                mintKeypair.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair]);
-        const mintInfo = await getMint(connection, mintKeypair.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.mintAuthority).to.eql(mintAuthority);
-        expect(mintInfo.supply).to.eql(BigInt(0));
-        expect(mintInfo.decimals).to.eql(TEST_TOKEN_DECIMALS);
-        expect(mintInfo.isInitialized).to.be.true;
-        expect(mintInfo.freezeAuthority).to.be.null;
-    });
-});
-describe('initialize mint 2', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mintKeypair: Keypair;
-    let lamports: number;
-    beforeEach(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintKeypair = Keypair.generate();
-        lamports = await getMinimumBalanceForRentExemptMint(connection);
-    });
-    it('works', async () => {
-        const mintAuthority = Keypair.generate().publicKey;
-        const freezeAuthority = Keypair.generate().publicKey;
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mintKeypair.publicKey,
-                space: MINT_SIZE,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMint2Instruction(
-                mintKeypair.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority,
-                freezeAuthority,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair]);
-        const mintInfo = await getMint(connection, mintKeypair.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.mintAuthority).to.eql(mintAuthority);
-        expect(mintInfo.supply).to.eql(BigInt(0));
-        expect(mintInfo.decimals).to.eql(TEST_TOKEN_DECIMALS);
-        expect(mintInfo.isInitialized).to.be.true;
-        expect(mintInfo.freezeAuthority).to.eql(freezeAuthority);
-    });
-    it('works with null freeze authority', async () => {
-        const mintAuthority = Keypair.generate().publicKey;
-        const transaction = new Transaction().add(
-            SystemProgram.createAccount({
-                fromPubkey: payer.publicKey,
-                newAccountPubkey: mintKeypair.publicKey,
-                space: MINT_SIZE,
-                lamports,
-                programId: TEST_PROGRAM_ID,
-            }),
-            createInitializeMint2Instruction(
-                mintKeypair.publicKey,
-                TEST_TOKEN_DECIMALS,
-                mintAuthority,
-                null,
-                TEST_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair]);
-        const mintInfo = await getMint(connection, mintKeypair.publicKey, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.mintAuthority).to.eql(mintAuthority);
-        expect(mintInfo.supply).to.eql(BigInt(0));
-        expect(mintInfo.decimals).to.eql(TEST_TOKEN_DECIMALS);
-        expect(mintInfo.isInitialized).to.be.true;
-        expect(mintInfo.freezeAuthority).to.be.null;
-    });
-});
diff --git a/token/js/test/e2e/mint.test.ts b/token/js/test/e2e/mint.test.ts
deleted file mode 100644
index 750e63bed88..00000000000
--- a/token/js/test/e2e/mint.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import { createMint, getMint, createAccount, getAccount, mintTo, mintToChecked } from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('mint', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let owner: Keypair;
-    let account: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        owner = Keypair.generate();
-        account = await createAccount(connection, payer, mint, owner.publicKey, undefined, undefined, TEST_PROGRAM_ID);
-    });
-    it('mintTo', async () => {
-        const amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.supply).to.eql(amount);
-
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.amount).to.eql(amount);
-    });
-    it('mintToChecked', async () => {
-        const amount = BigInt(1000);
-        await mintToChecked(
-            connection,
-            payer,
-            mint,
-            account,
-            mintAuthority,
-            amount,
-            TEST_TOKEN_DECIMALS,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        expect(
-            mintToChecked(connection, payer, mint, account, mintAuthority, amount, 1, [], undefined, TEST_PROGRAM_ID)
-        ).to.be.rejected;
-    });
-});
diff --git a/token/js/test/e2e/multisig.test.ts b/token/js/test/e2e/multisig.test.ts
deleted file mode 100644
index e66dd7fcffa..00000000000
--- a/token/js/test/e2e/multisig.test.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import {
-    AuthorityType,
-    createMint,
-    createAccount,
-    getAccount,
-    mintTo,
-    transfer,
-    approve,
-    getMultisig,
-    createMultisig,
-    setAuthority,
-} from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-const TEST_TOKEN_DECIMALS = 2;
-const M = 2;
-const N = 5;
-describe('multisig', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let account1: PublicKey;
-    let account2: PublicKey;
-    let amount: bigint;
-    let multisig: PublicKey;
-    let signers: Keypair[];
-    let signerPublicKeys: PublicKey[];
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        signers = [];
-        signerPublicKeys = [];
-        for (let i = 0; i < N; ++i) {
-            const signer = Keypair.generate();
-            signers.push(signer);
-            signerPublicKeys.push(signer.publicKey);
-        }
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        multisig = await createMultisig(connection, payer, signerPublicKeys, M, undefined, undefined, TEST_PROGRAM_ID);
-        account1 = await createAccount(
-            connection,
-            payer,
-            mint,
-            multisig,
-            Keypair.generate(),
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        account2 = await createAccount(
-            connection,
-            payer,
-            mint,
-            multisig,
-            Keypair.generate(),
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account1, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-    });
-    it('create', async () => {
-        const multisigInfo = await getMultisig(connection, multisig, undefined, TEST_PROGRAM_ID);
-        expect(multisigInfo.m).to.eql(M);
-        expect(multisigInfo.n).to.eql(N);
-        expect(multisigInfo.signer1).to.eql(signerPublicKeys[0]);
-        expect(multisigInfo.signer2).to.eql(signerPublicKeys[1]);
-        expect(multisigInfo.signer3).to.eql(signerPublicKeys[2]);
-        expect(multisigInfo.signer4).to.eql(signerPublicKeys[3]);
-        expect(multisigInfo.signer5).to.eql(signerPublicKeys[4]);
-    });
-    it('transfer', async () => {
-        await transfer(connection, payer, account1, account2, multisig, amount, signers, undefined, TEST_PROGRAM_ID);
-        const accountInfo = await getAccount(connection, account2, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.amount).to.eql(amount);
-    });
-    it('approve', async () => {
-        const delegate = Keypair.generate().publicKey;
-        await approve(connection, payer, account1, delegate, multisig, amount, signers, undefined, TEST_PROGRAM_ID);
-        const approvedAccountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(approvedAccountInfo.delegatedAmount).to.eql(amount);
-        expect(approvedAccountInfo.delegate).to.eql(delegate);
-    });
-    it('setAuthority', async () => {
-        const newOwner = Keypair.generate().publicKey;
-        await setAuthority(
-            connection,
-            payer,
-            account1,
-            multisig,
-            AuthorityType.AccountOwner,
-            newOwner,
-            signers,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.owner).to.eql(newOwner);
-    });
-});
diff --git a/token/js/test/e2e/native.test.ts b/token/js/test/e2e/native.test.ts
deleted file mode 100644
index 95805e27d62..00000000000
--- a/token/js/test/e2e/native.test.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-import { expect } from 'chai';
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, Transaction, SystemProgram, sendAndConfirmTransaction } from '@solana/web3.js';
-import {
-    NATIVE_MINT,
-    NATIVE_MINT_2022,
-    TOKEN_PROGRAM_ID,
-    closeAccount,
-    getAccount,
-    createNativeMint,
-    createWrappedNativeAccount,
-    syncNative,
-} from '../../src';
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-describe('native', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Keypair;
-    let account: PublicKey;
-    let amount: number;
-    let nativeMint: PublicKey;
-    before(async () => {
-        amount = 1_000_000_000;
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 100_000_000_000);
-        if (TEST_PROGRAM_ID == TOKEN_PROGRAM_ID) {
-            nativeMint = NATIVE_MINT;
-        } else {
-            nativeMint = NATIVE_MINT_2022;
-            await createNativeMint(connection, payer, undefined, nativeMint, TEST_PROGRAM_ID);
-        }
-    });
-    beforeEach(async () => {
-        owner = Keypair.generate();
-        account = await createWrappedNativeAccount(
-            connection,
-            payer,
-            owner.publicKey,
-            amount,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID,
-            nativeMint
-        );
-    });
-    it('works', async () => {
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.isNative).to.be.true;
-        expect(accountInfo.amount).to.eql(BigInt(amount));
-    });
-    it('syncNative', async () => {
-        let balance = 0;
-        const preInfo = await connection.getAccountInfo(account);
-        expect(preInfo).to.not.be.null;
-        if (preInfo != null) {
-            balance = preInfo.lamports;
-        }
-
-        // transfer lamports into the native account
-        const additionalLamports = 100;
-        await sendAndConfirmTransaction(
-            connection,
-            new Transaction().add(
-                SystemProgram.transfer({
-                    fromPubkey: payer.publicKey,
-                    toPubkey: account,
-                    lamports: additionalLamports,
-                })
-            ),
-            [payer]
-        );
-
-        // no change in the amount
-        const preAccountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(preAccountInfo.isNative).to.be.true;
-        expect(preAccountInfo.amount).to.eql(BigInt(amount));
-
-        // but change in lamports
-        const postInfo = await connection.getAccountInfo(account);
-        expect(postInfo).to.not.be.null;
-        if (postInfo !== null) {
-            expect(postInfo.lamports).to.eql(balance + additionalLamports);
-        }
-
-        // sync, amount changes
-        await syncNative(connection, payer, account, undefined, TEST_PROGRAM_ID);
-        const postAccountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(postAccountInfo.isNative).to.be.true;
-        expect(postAccountInfo.amount).to.eql(BigInt(amount + additionalLamports));
-    });
-    it('closeAccount', async () => {
-        let balance = 0;
-        const preInfo = await connection.getAccountInfo(account);
-        expect(preInfo).to.not.be.null;
-        if (preInfo != null) {
-            balance = preInfo.lamports;
-        }
-        const destination = Keypair.generate().publicKey;
-        await closeAccount(connection, payer, account, destination, owner, [], undefined, TEST_PROGRAM_ID);
-        const nullInfo = await connection.getAccountInfo(account);
-        expect(nullInfo).to.be.null;
-        const destinationInfo = await connection.getAccountInfo(destination);
-        expect(destinationInfo).to.not.be.null;
-        if (destinationInfo != null) {
-            expect(destinationInfo.lamports).to.eql(balance);
-        }
-    });
-});
diff --git a/token/js/test/e2e/recoverNested.test.ts b/token/js/test/e2e/recoverNested.test.ts
deleted file mode 100644
index af563b7a181..00000000000
--- a/token/js/test/e2e/recoverNested.test.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair, Transaction, sendAndConfirmTransaction } from '@solana/web3.js';
-import { expect } from 'chai';
-
-import {
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    createMint,
-    getAccount,
-    createAssociatedTokenAccount,
-    createAssociatedTokenAccountInstruction,
-    getAssociatedTokenAddressSync,
-    mintTo,
-    recoverNested,
-} from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-
-describe('recoverNested', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let owner: Signer;
-    let mint: PublicKey;
-    let associatedToken: PublicKey;
-    let nestedMint: PublicKey;
-    const nestedMintAmount = 1;
-    let nestedAssociatedToken: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 10000000000);
-        owner = Keypair.generate();
-
-        // mint
-        const mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            0,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        associatedToken = await createAssociatedTokenAccount(
-            connection,
-            payer,
-            mint,
-            owner.publicKey,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        // nested mint
-        const nestedMintAuthority = Keypair.generate();
-        const nestedMintKeypair = Keypair.generate();
-        nestedMint = await createMint(
-            connection,
-            payer,
-            nestedMintAuthority.publicKey,
-            nestedMintAuthority.publicKey,
-            0,
-            nestedMintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        nestedAssociatedToken = getAssociatedTokenAddressSync(
-            nestedMint,
-            associatedToken,
-            true,
-            TEST_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID
-        );
-        const transaction = new Transaction().add(
-            createAssociatedTokenAccountInstruction(
-                payer.publicKey,
-                nestedAssociatedToken,
-                associatedToken,
-                nestedMint,
-                TEST_PROGRAM_ID,
-                ASSOCIATED_TOKEN_PROGRAM_ID
-            )
-        );
-        await sendAndConfirmTransaction(connection, transaction, [payer], undefined);
-
-        // use mintTo to make nestedAssociatedToken have some tokens
-        await mintTo(
-            connection,
-            payer,
-            nestedMint,
-            nestedAssociatedToken,
-            nestedMintAuthority,
-            nestedMintAmount,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    }),
-        it('success', async () => {
-            // create destination associated token
-            const destinationAssociatedToken = await createAssociatedTokenAccount(
-                connection,
-                payer,
-                nestedMint,
-                owner.publicKey,
-                undefined,
-                TEST_PROGRAM_ID
-            );
-
-            await recoverNested(connection, payer, owner, mint, nestedMint, undefined, TEST_PROGRAM_ID);
-
-            expect(await connection.getAccountInfo(nestedAssociatedToken)).to.be.null;
-
-            const accountInfo = await getAccount(connection, destinationAssociatedToken, undefined, TEST_PROGRAM_ID);
-            expect(accountInfo).to.not.be.null;
-            expect(accountInfo.mint).to.eql(nestedMint);
-            expect(accountInfo.owner).to.eql(owner.publicKey);
-            expect(accountInfo.amount).to.eql(BigInt(nestedMintAmount));
-        });
-});
diff --git a/token/js/test/e2e/setAuthority.test.ts b/token/js/test/e2e/setAuthority.test.ts
deleted file mode 100644
index 5dac03f4e69..00000000000
--- a/token/js/test/e2e/setAuthority.test.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import { AuthorityType, createMint, createAccount, getAccount, getMint, setAuthority } from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('setAuthority', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let freezeAuthority: Keypair;
-    let owner: Keypair;
-    let account: PublicKey;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        freezeAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            freezeAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        owner = Keypair.generate();
-        account = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner.publicKey,
-            Keypair.generate(),
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    it('AccountOwner', async () => {
-        const newOwner = Keypair.generate();
-        await setAuthority(
-            connection,
-            payer,
-            account,
-            owner,
-            AuthorityType.AccountOwner,
-            newOwner.publicKey,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.owner).to.eql(newOwner.publicKey);
-        await setAuthority(
-            connection,
-            payer,
-            account,
-            newOwner,
-            AuthorityType.AccountOwner,
-            owner.publicKey,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        expect(
-            setAuthority(
-                connection,
-                payer,
-                account,
-                newOwner,
-                AuthorityType.AccountOwner,
-                owner.publicKey,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        ).to.be.rejected;
-    });
-    it('MintAuthority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            mintAuthority,
-            AuthorityType.MintTokens,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.mintAuthority).to.be.null;
-    });
-    it('CloseAuthority', async () => {
-        const closeAuthority = Keypair.generate();
-        await setAuthority(
-            connection,
-            payer,
-            account,
-            owner,
-            AuthorityType.CloseAccount,
-            closeAuthority.publicKey,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const accountInfo = await getAccount(connection, account, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.closeAuthority).to.eql(closeAuthority.publicKey);
-    });
-    it('FreezeAuthority', async () => {
-        await setAuthority(
-            connection,
-            payer,
-            mint,
-            freezeAuthority,
-            AuthorityType.FreezeAccount,
-            null,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const mintInfo = await getMint(connection, mint, undefined, TEST_PROGRAM_ID);
-        expect(mintInfo.freezeAuthority).to.be.null;
-    });
-});
diff --git a/token/js/test/e2e/transfer.test.ts b/token/js/test/e2e/transfer.test.ts
deleted file mode 100644
index 2796118c474..00000000000
--- a/token/js/test/e2e/transfer.test.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-import type { Connection, PublicKey, Signer } from '@solana/web3.js';
-import { Keypair } from '@solana/web3.js';
-
-import {
-    createMint,
-    createAccount,
-    getAccount,
-    mintTo,
-    transfer,
-    transferChecked,
-    approve,
-    approveChecked,
-    revoke,
-} from '../../src';
-
-import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-const TEST_TOKEN_DECIMALS = 2;
-describe('transfer', () => {
-    let connection: Connection;
-    let payer: Signer;
-    let mint: PublicKey;
-    let mintAuthority: Keypair;
-    let owner1: Keypair;
-    let account1: PublicKey;
-    let owner2: Keypair;
-    let account2: PublicKey;
-    let amount: bigint;
-    before(async () => {
-        connection = await getConnection();
-        payer = await newAccountWithLamports(connection, 1000000000);
-        mintAuthority = Keypair.generate();
-        const mintKeypair = Keypair.generate();
-        mint = await createMint(
-            connection,
-            payer,
-            mintAuthority.publicKey,
-            mintAuthority.publicKey,
-            TEST_TOKEN_DECIMALS,
-            mintKeypair,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-    });
-    beforeEach(async () => {
-        owner1 = Keypair.generate();
-        account1 = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner1.publicKey,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        owner2 = Keypair.generate();
-        account2 = await createAccount(
-            connection,
-            payer,
-            mint,
-            owner2.publicKey,
-            undefined,
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        amount = BigInt(1000);
-        await mintTo(connection, payer, mint, account1, mintAuthority, amount, [], undefined, TEST_PROGRAM_ID);
-    });
-    it('transfer', async () => {
-        await transfer(connection, payer, account1, account2, owner1, amount, [], undefined, TEST_PROGRAM_ID);
-
-        const destAccountInfo = await getAccount(connection, account2, undefined, TEST_PROGRAM_ID);
-        expect(destAccountInfo.amount).to.eql(amount);
-
-        const sourceAccountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(sourceAccountInfo.amount).to.eql(BigInt(0));
-    });
-    it('transferChecked', async () => {
-        const transferAmount = amount / BigInt(2);
-        await transferChecked(
-            connection,
-            payer,
-            account1,
-            mint,
-            account2,
-            owner1,
-            transferAmount,
-            TEST_TOKEN_DECIMALS,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-
-        const destAccountInfo = await getAccount(connection, account2, undefined, TEST_PROGRAM_ID);
-        expect(destAccountInfo.amount).to.eql(transferAmount);
-
-        const sourceAccountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(sourceAccountInfo.amount).to.eql(transferAmount);
-        expect(
-            transferChecked(
-                connection,
-                payer,
-                account1,
-                mint,
-                account2,
-                owner1,
-                transferAmount,
-                TEST_TOKEN_DECIMALS - 1,
-                [],
-                undefined,
-                TEST_PROGRAM_ID
-            )
-        ).to.be.rejected;
-    });
-    it('approveRevoke', async () => {
-        const delegate = Keypair.generate();
-        const delegatedAmount = amount / BigInt(2);
-        await approve(
-            connection,
-            payer,
-            account1,
-            delegate.publicKey,
-            owner1,
-            delegatedAmount,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const approvedAccountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(approvedAccountInfo.delegatedAmount).to.eql(delegatedAmount);
-        expect(approvedAccountInfo.delegate).to.eql(delegate.publicKey);
-        await revoke(connection, payer, account1, owner1, [], undefined, TEST_PROGRAM_ID);
-        const revokedAccountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(revokedAccountInfo.delegatedAmount).to.eql(BigInt(0));
-        expect(revokedAccountInfo.delegate).to.be.null;
-    });
-    it('delegateTransfer', async () => {
-        const delegate = Keypair.generate();
-        const delegatedAmount = amount / BigInt(2);
-        await approveChecked(
-            connection,
-            payer,
-            mint,
-            account1,
-            delegate.publicKey,
-            owner1,
-            delegatedAmount,
-            TEST_TOKEN_DECIMALS,
-            [],
-            undefined,
-            TEST_PROGRAM_ID
-        );
-        const transferAmount = delegatedAmount - BigInt(1);
-        await transfer(connection, payer, account1, account2, delegate, transferAmount, [], undefined, TEST_PROGRAM_ID);
-        const accountInfo = await getAccount(connection, account1, undefined, TEST_PROGRAM_ID);
-        expect(accountInfo.delegatedAmount).to.eql(delegatedAmount - transferAmount);
-        expect(accountInfo.delegate).to.eql(delegate.publicKey);
-        expect(transfer(connection, payer, account1, account2, delegate, BigInt(2), [], undefined, TEST_PROGRAM_ID)).to
-            .be.rejected;
-    });
-});
diff --git a/token/js/test/unit/decode.test.ts b/token/js/test/unit/decode.test.ts
deleted file mode 100644
index 97602083da2..00000000000
--- a/token/js/test/unit/decode.test.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { Keypair } from '@solana/web3.js';
-import { expect } from 'chai';
-import {
-    createInitializeMintCloseAuthorityInstruction,
-    createInitializePermanentDelegateInstruction,
-    TOKEN_2022_PROGRAM_ID,
-} from '../../src';
-
-describe('spl-token-2022 instructions', () => {
-    it('InitializeMintCloseAuthority', () => {
-        const ix = createInitializeMintCloseAuthorityInstruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-    it('InitializePermanentDelegate', () => {
-        const ix = createInitializePermanentDelegateInstruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-});
diff --git a/token/js/test/unit/groupMemberPointer.test.ts b/token/js/test/unit/groupMemberPointer.test.ts
deleted file mode 100644
index c6ceefb2ef2..00000000000
--- a/token/js/test/unit/groupMemberPointer.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { expect } from 'chai';
-import type { Mint } from '../../src';
-import {
-    TOKEN_2022_PROGRAM_ID,
-    createInitializeGroupMemberPointerInstruction,
-    createUpdateGroupMemberPointerInstruction,
-    getGroupMemberPointerState,
-} from '../../src';
-
-const AUTHORITY_ADDRESS_BYTES = Buffer.alloc(32).fill(8);
-const GROUP_MEMBER_ADDRESS_BYTES = Buffer.alloc(32).fill(5);
-const NULL_OPTIONAL_NONZERO_PUBKEY_BYTES = Buffer.alloc(32).fill(0);
-
-describe('SPL Token 2022 GroupMemberPointer Extension', () => {
-    it('can create InitializeGroupMemberPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = new PublicKey(AUTHORITY_ADDRESS_BYTES);
-        const memberAddress = new PublicKey(GROUP_MEMBER_ADDRESS_BYTES);
-        const instruction = createInitializeGroupMemberPointerInstruction(
-            mint,
-            authority,
-            memberAddress,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [{ isSigner: false, isWritable: true, pubkey: mint }],
-                data: Buffer.concat([
-                    Buffer.from([
-                        41, // Token instruction discriminator
-                        0, // GroupMemberPointer instruction discriminator
-                    ]),
-                    AUTHORITY_ADDRESS_BYTES,
-                    GROUP_MEMBER_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateGroupMemberPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const memberAddress = new PublicKey(GROUP_MEMBER_ADDRESS_BYTES);
-        const instruction = createUpdateGroupMemberPointerInstruction(mint, authority, memberAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        41, // Token instruction discriminator
-                        1, // GroupMemberPointer instruction discriminator
-                    ]),
-                    GROUP_MEMBER_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateGroupMemberPointerInstruction to none', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const memberAddress = null;
-        const instruction = createUpdateGroupMemberPointerInstruction(mint, authority, memberAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        41, // Token instruction discriminator
-                        1, // GroupMemberPointer instruction discriminator
-                    ]),
-                    NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can get state with authority and group address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    22, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                GROUP_MEMBER_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupMemberPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            memberAddress: new PublicKey(GROUP_MEMBER_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only group address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    22, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                GROUP_MEMBER_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupMemberPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: null,
-            memberAddress: new PublicKey(GROUP_MEMBER_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only authority address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    22, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupMemberPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            memberAddress: null,
-        });
-    });
-});
diff --git a/token/js/test/unit/groupPointer.test.ts b/token/js/test/unit/groupPointer.test.ts
deleted file mode 100644
index 93a967c405b..00000000000
--- a/token/js/test/unit/groupPointer.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { expect } from 'chai';
-import type { Mint } from '../../src';
-import {
-    TOKEN_2022_PROGRAM_ID,
-    createInitializeGroupPointerInstruction,
-    createUpdateGroupPointerInstruction,
-    getGroupPointerState,
-} from '../../src';
-
-const AUTHORITY_ADDRESS_BYTES = Buffer.alloc(32).fill(8);
-const GROUP_ADDRESS_BYTES = Buffer.alloc(32).fill(5);
-const NULL_OPTIONAL_NONZERO_PUBKEY_BYTES = Buffer.alloc(32).fill(0);
-
-describe('SPL Token 2022 GroupPointer Extension', () => {
-    it('can create InitializeGroupPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = new PublicKey(AUTHORITY_ADDRESS_BYTES);
-        const groupAddress = new PublicKey(GROUP_ADDRESS_BYTES);
-        const instruction = createInitializeGroupPointerInstruction(
-            mint,
-            authority,
-            groupAddress,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [{ isSigner: false, isWritable: true, pubkey: mint }],
-                data: Buffer.concat([
-                    Buffer.from([
-                        40, // Token instruction discriminator
-                        0, // GroupPointer instruction discriminator
-                    ]),
-                    AUTHORITY_ADDRESS_BYTES,
-                    GROUP_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateGroupPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const groupAddress = new PublicKey(GROUP_ADDRESS_BYTES);
-        const instruction = createUpdateGroupPointerInstruction(mint, authority, groupAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        40, // Token instruction discriminator
-                        1, // GroupPointer instruction discriminator
-                    ]),
-                    GROUP_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateGroupPointerInstruction to none', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const groupAddress = null;
-        const instruction = createUpdateGroupPointerInstruction(mint, authority, groupAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        40, // Token instruction discriminator
-                        1, // GroupPointer instruction discriminator
-                    ]),
-                    NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can get state with authority and group address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    20, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                GROUP_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            groupAddress: new PublicKey(GROUP_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only group address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    20, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                GROUP_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: null,
-            groupAddress: new PublicKey(GROUP_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only authority address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    20, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-            ]),
-        } as Mint;
-        const groupPointer = getGroupPointerState(mintInfo);
-        expect(groupPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            groupAddress: null,
-        });
-    });
-});
diff --git a/token/js/test/unit/index.test.ts b/token/js/test/unit/index.test.ts
deleted file mode 100644
index f1a5c7b4f5f..00000000000
--- a/token/js/test/unit/index.test.ts
+++ /dev/null
@@ -1,275 +0,0 @@
-import { Keypair, PublicKey } from '@solana/web3.js';
-import { expect, use } from 'chai';
-import {
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    createAssociatedTokenAccountInstruction,
-    createReallocateInstruction,
-    createInitializeMintInstruction,
-    createInitializeMint2Instruction,
-    createSyncNativeInstruction,
-    createTransferCheckedInstruction,
-    getAssociatedTokenAddress,
-    TOKEN_PROGRAM_ID,
-    TOKEN_2022_PROGRAM_ID,
-    TokenInstruction,
-    TokenOwnerOffCurveError,
-    getAccountLen,
-    ExtensionType,
-    isMintExtension,
-    isAccountExtension,
-    getAssociatedTokenAddressSync,
-    createInitializeAccount2Instruction,
-    createInitializeAccount3Instruction,
-    createAmountToUiAmountInstruction,
-    createUiAmountToAmountInstruction,
-    getMintLen,
-} from '../../src';
-import chaiAsPromised from 'chai-as-promised';
-use(chaiAsPromised);
-
-describe('spl-token instructions', () => {
-    it('TransferChecked', () => {
-        const ix = createTransferCheckedInstruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            1,
-            9
-        );
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(4);
-    });
-
-    it('InitializeMint', () => {
-        const ix = createInitializeMintInstruction(Keypair.generate().publicKey, 9, Keypair.generate().publicKey, null);
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(2);
-    });
-
-    it('InitializeMint2', () => {
-        const ix = createInitializeMint2Instruction(
-            Keypair.generate().publicKey,
-            9,
-            Keypair.generate().publicKey,
-            null
-        );
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-
-    it('SyncNative', () => {
-        const ix = createSyncNativeInstruction(Keypair.generate().publicKey);
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-
-    it('InitializeAccount2', () => {
-        const ix = createInitializeAccount2Instruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey
-        );
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(3);
-    });
-
-    it('InitializeAccount3', () => {
-        const ix = createInitializeAccount3Instruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey
-        );
-        expect(ix.programId).to.eql(TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(2);
-    });
-});
-
-describe('spl-token-2022 instructions', () => {
-    it('TransferChecked', () => {
-        const ix = createTransferCheckedInstruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            1,
-            9,
-            [],
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(4);
-    });
-
-    it('InitializeMint', () => {
-        const ix = createInitializeMintInstruction(
-            Keypair.generate().publicKey,
-            9,
-            Keypair.generate().publicKey,
-            null,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(2);
-    });
-
-    it('InitializeMint2', () => {
-        const ix = createInitializeMint2Instruction(
-            Keypair.generate().publicKey,
-            9,
-            Keypair.generate().publicKey,
-            null,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-
-    it('SyncNative', () => {
-        const ix = createSyncNativeInstruction(Keypair.generate().publicKey, TOKEN_2022_PROGRAM_ID);
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-
-    it('Reallocate', () => {
-        const publicKey = Keypair.generate().publicKey;
-        const extensionTypes = [ExtensionType.MintCloseAuthority, ExtensionType.TransferFeeConfig];
-        const ix = createReallocateInstruction(publicKey, publicKey, extensionTypes, publicKey);
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(4);
-        console.error(ix.data);
-        expect(ix.data[0]).to.eql(TokenInstruction.Reallocate);
-        expect(ix.data[1]).to.eql(extensionTypes[0]);
-        expect(ix.data[3]).to.eql(extensionTypes[1]);
-    });
-
-    it('AmountToUiAmount', () => {
-        const ix = createAmountToUiAmountInstruction(Keypair.generate().publicKey, 22, TOKEN_2022_PROGRAM_ID);
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-
-    it('UiAmountToAmount', () => {
-        const ix = createUiAmountToAmountInstruction(Keypair.generate().publicKey, '22', TOKEN_2022_PROGRAM_ID);
-        expect(ix.programId).to.eql(TOKEN_2022_PROGRAM_ID);
-        expect(ix.keys).to.have.length(1);
-    });
-});
-
-describe('spl-associated-token-account instructions', () => {
-    it('create', () => {
-        const ix = createAssociatedTokenAccountInstruction(
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey,
-            Keypair.generate().publicKey
-        );
-        expect(ix.programId).to.eql(ASSOCIATED_TOKEN_PROGRAM_ID);
-        expect(ix.keys).to.have.length(6);
-    });
-});
-
-describe('state', () => {
-    it('getAssociatedTokenAddress', async () => {
-        const associatedPublicKey = await getAssociatedTokenAddress(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            new PublicKey('B8UwBUUnKwCyKuGMbFKWaG7exYdDk2ozZrPg72NyVbfj')
-        );
-        expect(associatedPublicKey.toString()).to.eql(
-            new PublicKey('DShWnroshVbeUp28oopA3Pu7oFPDBtC1DBmPECXXAQ9n').toString()
-        );
-        await expect(
-            getAssociatedTokenAddress(
-                new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-                associatedPublicKey
-            )
-        ).to.be.rejectedWith(TokenOwnerOffCurveError);
-
-        const associatedPublicKey2 = await getAssociatedTokenAddress(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            associatedPublicKey,
-            true
-        );
-        expect(associatedPublicKey2.toString()).to.eql(
-            new PublicKey('F3DmXZFqkfEWFA7MN2vDPs813GeEWPaT6nLk4PSGuWJd').toString()
-        );
-    });
-
-    it('getAssociatedTokenAddressSync matches getAssociatedTokenAddress', async () => {
-        const asyncAssociatedPublicKey = await getAssociatedTokenAddress(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            new PublicKey('B8UwBUUnKwCyKuGMbFKWaG7exYdDk2ozZrPg72NyVbfj')
-        );
-        const associatedPublicKey = getAssociatedTokenAddressSync(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            new PublicKey('B8UwBUUnKwCyKuGMbFKWaG7exYdDk2ozZrPg72NyVbfj')
-        );
-        expect(associatedPublicKey.toString()).to.eql(
-            new PublicKey('DShWnroshVbeUp28oopA3Pu7oFPDBtC1DBmPECXXAQ9n').toString()
-        );
-        expect(asyncAssociatedPublicKey.toString()).to.eql(associatedPublicKey.toString());
-
-        expect(function () {
-            getAssociatedTokenAddressSync(
-                new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-                associatedPublicKey
-            );
-        }).to.throw(TokenOwnerOffCurveError);
-
-        const asyncAssociatedPublicKey2 = await getAssociatedTokenAddress(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            asyncAssociatedPublicKey,
-            true
-        );
-        const associatedPublicKey2 = getAssociatedTokenAddressSync(
-            new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z'),
-            associatedPublicKey,
-            true
-        );
-        expect(associatedPublicKey2.toString()).to.eql(
-            new PublicKey('F3DmXZFqkfEWFA7MN2vDPs813GeEWPaT6nLk4PSGuWJd').toString()
-        );
-        expect(asyncAssociatedPublicKey2.toString()).to.eql(associatedPublicKey2.toString());
-    });
-});
-
-describe('extensionType', () => {
-    it('calculates size for accounts', () => {
-        expect(getAccountLen([ExtensionType.MintCloseAuthority, ExtensionType.TransferFeeConfig])).to.eql(314);
-        expect(getAccountLen([])).to.eql(165);
-        expect(getAccountLen([ExtensionType.ImmutableOwner])).to.eql(170);
-        expect(getAccountLen([ExtensionType.PermanentDelegate])).to.eql(202);
-    });
-
-    it('calculates size for mints', () => {
-        expect(getMintLen([ExtensionType.TransferFeeConfig, ExtensionType.NonTransferable])).to.eql(282);
-        expect(getMintLen([])).to.eql(82);
-        expect(getMintLen([ExtensionType.TransferHook])).to.eql(234);
-        expect(getMintLen([ExtensionType.MetadataPointer])).to.eql(234);
-        expect(
-            getMintLen([ExtensionType.TransferFeeConfig, ExtensionType.NonTransferable], {
-                [ExtensionType.TokenMetadata]: 200,
-            })
-        ).to.eql(486);
-        expect(
-            getMintLen([], {
-                [ExtensionType.TokenMetadata]: 200,
-            })
-        ).to.eql(370);
-        // Should error on an extension that isn't variable-length
-        expect(() =>
-            getMintLen([ExtensionType.TransferFeeConfig, ExtensionType.NonTransferable], {
-                [ExtensionType.TransferHook]: 200,
-            })
-        ).to.throw('Extension 14 is not variable length');
-    });
-
-    it('exclusive and exhaustive predicates', () => {
-        const exts = Object.values(ExtensionType).filter(Number.isInteger);
-        const mintExts = exts.filter((e: any): e is ExtensionType => isMintExtension(e));
-        const accountExts = exts.filter((e: any): e is ExtensionType => isAccountExtension(e));
-        const collectedExts = [ExtensionType.Uninitialized].concat(mintExts, accountExts);
-
-        expect(collectedExts.sort()).to.eql(exts.sort());
-    });
-});
diff --git a/token/js/test/unit/metadataPointer.test.ts b/token/js/test/unit/metadataPointer.test.ts
deleted file mode 100644
index 5b7580767b0..00000000000
--- a/token/js/test/unit/metadataPointer.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { expect } from 'chai';
-import type { Mint } from '../../src';
-import {
-    TOKEN_2022_PROGRAM_ID,
-    createInitializeMetadataPointerInstruction,
-    createUpdateMetadataPointerInstruction,
-    getMetadataPointerState,
-} from '../../src';
-
-const AUTHORITY_ADDRESS_BYTES = Buffer.alloc(32).fill(8);
-const METADATA_ADDRESS_BYTES = Buffer.alloc(32).fill(5);
-const NULL_OPTIONAL_NONZERO_PUBKEY_BYTES = Buffer.alloc(32).fill(0);
-
-describe('SPL Token 2022 MetadataPointer Extension', () => {
-    it('can create InitializeMetadataPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = new PublicKey(AUTHORITY_ADDRESS_BYTES);
-        const metadataAddress = new PublicKey(METADATA_ADDRESS_BYTES);
-        const instruction = createInitializeMetadataPointerInstruction(
-            mint,
-            authority,
-            metadataAddress,
-            TOKEN_2022_PROGRAM_ID
-        );
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [{ isSigner: false, isWritable: true, pubkey: mint }],
-                data: Buffer.concat([
-                    Buffer.from([
-                        39, // Token instruction discriminator
-                        0, // MetadataPointer instruction discriminator
-                    ]),
-                    AUTHORITY_ADDRESS_BYTES,
-                    METADATA_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateMetadataPointerInstruction', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const metadataAddress = new PublicKey(METADATA_ADDRESS_BYTES);
-        const instruction = createUpdateMetadataPointerInstruction(mint, authority, metadataAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        39, // Token instruction discriminator
-                        1, // MetadataPointer instruction discriminator
-                    ]),
-                    METADATA_ADDRESS_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can create UpdateMetadataPointerInstruction to none', () => {
-        const mint = PublicKey.unique();
-        const authority = PublicKey.unique();
-        const metadataAddress = null;
-        const instruction = createUpdateMetadataPointerInstruction(mint, authority, metadataAddress);
-        expect(instruction).to.deep.equal(
-            new TransactionInstruction({
-                programId: TOKEN_2022_PROGRAM_ID,
-                keys: [
-                    { isSigner: false, isWritable: true, pubkey: mint },
-                    { isSigner: true, isWritable: false, pubkey: authority },
-                ],
-                data: Buffer.concat([
-                    Buffer.from([
-                        39, // Token instruction discriminator
-                        1, // MetadataPointer instruction discriminator
-                    ]),
-                    NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                ]),
-            })
-        );
-    });
-    it('can get state with authority and metadata address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    18, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                METADATA_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const metadataPointer = getMetadataPointerState(mintInfo);
-        expect(metadataPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            metadataAddress: new PublicKey(METADATA_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only metadata address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    18, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-                METADATA_ADDRESS_BYTES,
-            ]),
-        } as Mint;
-        const metadataPointer = getMetadataPointerState(mintInfo);
-        expect(metadataPointer).to.deep.equal({
-            authority: null,
-            metadataAddress: new PublicKey(METADATA_ADDRESS_BYTES),
-        });
-    });
-    it('can get state with only authority address', async () => {
-        const mintInfo = {
-            tlvData: Buffer.concat([
-                Buffer.from([
-                    // Extension discriminator
-                    18, 0,
-                    // Extension length
-                    64, 0,
-                ]),
-                AUTHORITY_ADDRESS_BYTES,
-                NULL_OPTIONAL_NONZERO_PUBKEY_BYTES,
-            ]),
-        } as Mint;
-        const metadataPointer = getMetadataPointerState(mintInfo);
-        expect(metadataPointer).to.deep.equal({
-            authority: new PublicKey(AUTHORITY_ADDRESS_BYTES),
-            metadataAddress: null,
-        });
-    });
-});
diff --git a/token/js/test/unit/programId.test.ts b/token/js/test/unit/programId.test.ts
deleted file mode 100644
index 3ea894cce0d..00000000000
--- a/token/js/test/unit/programId.test.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { expect } from 'chai';
-import { PublicKey } from '@solana/web3.js';
-import {
-    AccountState,
-    createCreateNativeMintInstruction,
-    createEnableRequiredMemoTransfersInstruction,
-    createInitializeNonTransferableMintInstruction,
-    createInitializeTransferFeeConfigInstruction,
-    createInitializeMintCloseAuthorityInstruction,
-    createInitializeDefaultAccountStateInstruction,
-    NATIVE_MINT,
-    NATIVE_MINT_2022,
-    TOKEN_PROGRAM_ID,
-    TOKEN_2022_PROGRAM_ID,
-    TokenUnsupportedInstructionError,
-    createInitializePermanentDelegateInstruction,
-    createEnableCpiGuardInstruction,
-    createInitializeTransferHookInstruction,
-} from '../../src';
-
-describe('unsupported extensions in spl-token', () => {
-    const mint = new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z');
-    const account = new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z');
-    const authority = new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z');
-    const payer = new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z');
-    const transferHookProgramId = new PublicKey('7o36UsWR1JQLpZ9PE2gn9L4SQ69CNNiWAXd4Jt7rqz9Z');
-    it('initializeMintCloseAuthority', () => {
-        expect(function () {
-            createInitializeMintCloseAuthorityInstruction(mint, null, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializeMintCloseAuthorityInstruction(mint, null, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('defaultAccountState', () => {
-        expect(function () {
-            createInitializeDefaultAccountStateInstruction(mint, AccountState.Frozen, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializeDefaultAccountStateInstruction(mint, AccountState.Frozen, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('memoTransfer', () => {
-        expect(function () {
-            createEnableRequiredMemoTransfersInstruction(account, authority, [], TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createEnableRequiredMemoTransfersInstruction(account, authority, [], TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('transferFee', () => {
-        expect(function () {
-            createInitializeTransferFeeConfigInstruction(mint, null, null, 0, BigInt(0), TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializeTransferFeeConfigInstruction(mint, null, null, 0, BigInt(0), TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('nativeMint', () => {
-        expect(function () {
-            createCreateNativeMintInstruction(payer, NATIVE_MINT, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createCreateNativeMintInstruction(payer, NATIVE_MINT_2022, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('transferHook', () => {
-        expect(function () {
-            createInitializeTransferHookInstruction(mint, authority, transferHookProgramId, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializeTransferHookInstruction(mint, authority, transferHookProgramId, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('nonTransferableMint', () => {
-        expect(function () {
-            createInitializeNonTransferableMintInstruction(mint, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializeNonTransferableMintInstruction(mint, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('initializePermanentDelegate', () => {
-        expect(function () {
-            createInitializePermanentDelegateInstruction(mint, null, TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createInitializePermanentDelegateInstruction(mint, null, TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-    it('cpiGuard', () => {
-        expect(function () {
-            createEnableCpiGuardInstruction(account, authority, [], TOKEN_PROGRAM_ID);
-        }).to.throw(TokenUnsupportedInstructionError);
-        expect(function () {
-            createEnableCpiGuardInstruction(account, authority, [], TOKEN_2022_PROGRAM_ID);
-        }).to.not.throw(TokenUnsupportedInstructionError);
-    });
-});
diff --git a/token/js/test/unit/tokenMetadata.test.ts b/token/js/test/unit/tokenMetadata.test.ts
deleted file mode 100644
index 33bbb1a8155..00000000000
--- a/token/js/test/unit/tokenMetadata.test.ts
+++ /dev/null
@@ -1,221 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { expect } from 'chai';
-
-import type { TokenMetadata } from '@solana/spl-token-metadata';
-import { Field } from '@solana/spl-token-metadata';
-import { updateTokenMetadata } from '../../src';
-
-describe('SPL Token 2022 Metadata Extension', () => {
-    describe('Update token metadata', () => {
-        it('guards against updates on mint or updateAuthority', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            expect(() => updateTokenMetadata(input, 'mint', 'string')).to.throw(
-                'Cannot update mint via this instruction'
-            );
-            expect(() => updateTokenMetadata(input, 'updateAuthority', 'string')).to.throw(
-                'Cannot update updateAuthority via this instruction'
-            );
-        });
-        it('can update name', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'updated_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'name', 'updated_name')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, 'Name', 'updated_name')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, Field.Name, 'updated_name')).to.deep.equal(expected);
-        });
-
-        it('can update symbol', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'updated_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'symbol', 'updated_symbol')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, 'Symbol', 'updated_symbol')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, Field.Symbol, 'updated_symbol')).to.deep.equal(expected);
-        });
-
-        it('can update uri', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'updated_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'uri', 'updated_uri')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, 'Uri', 'updated_uri')).to.deep.equal(expected);
-            expect(updateTokenMetadata(input, Field.Uri, 'updated_uri')).to.deep.equal(expected);
-        });
-
-        it('can update additional Metadata', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'update1'],
-                    ['key2', 'value2'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'key1', 'update1')).to.deep.equal(expected);
-        });
-
-        it('can add additional Metadata', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                    ['key3', 'value3'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'key3', 'value3')).to.deep.equal(expected);
-        });
-
-        it('can update `additionalMetadata` key to additional metadata', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                    ['additionalMetadata', 'value3'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                    ['additionalMetadata', 'update3'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'additionalMetadata', 'update3')).to.deep.equal(expected);
-        });
-
-        it('can add `additionalMetadata` key to additional metadata', async () => {
-            const input = Object.freeze({
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                ],
-            } as TokenMetadata);
-
-            const expected: TokenMetadata = {
-                mint: PublicKey.default,
-                name: 'new_name',
-                symbol: 'new_symbol',
-                uri: 'new_uri',
-                additionalMetadata: [
-                    ['key1', 'value1'],
-                    ['key2', 'value2'],
-                    ['additionalMetadata', 'value3'],
-                ],
-            };
-
-            expect(updateTokenMetadata(input, 'additionalMetadata', 'value3')).to.deep.equal(expected);
-        });
-    });
-});
diff --git a/token/js/test/unit/transferHook.test.ts b/token/js/test/unit/transferHook.test.ts
deleted file mode 100644
index a943f752fc2..00000000000
--- a/token/js/test/unit/transferHook.test.ts
+++ /dev/null
@@ -1,540 +0,0 @@
-import type { ExtraAccountMeta, ExtraAccountMetaList } from '../../src';
-import {
-    ACCOUNT_SIZE,
-    ACCOUNT_TYPE_SIZE,
-    ExtensionType,
-    ExtraAccountMetaAccountDataLayout,
-    ExtraAccountMetaLayout,
-    LENGTH_SIZE,
-    MintLayout,
-    TOKEN_2022_PROGRAM_ID,
-    TRANSFER_HOOK_SIZE,
-    TYPE_SIZE,
-    TransferHookLayout,
-    addExtraAccountMetasForExecute,
-    createTransferCheckedWithTransferHookInstruction,
-    getExtraAccountMetaAddress,
-    getExtraAccountMetas,
-    resolveExtraAccountMeta,
-} from '../../src';
-import { expect, use } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import type { Connection } from '@solana/web3.js';
-import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { getConnection } from '../common';
-use(chaiAsPromised);
-
-describe('transferHook', () => {
-    describe('validation data', () => {
-        let connection: Connection;
-        const testProgramId = new PublicKey('7N4HggYEJAtCLJdnHGCtFqfxcB5rhQCsQTze3ftYstVj');
-        const instructionData = Buffer.from(Array.from(Array(32).keys()));
-        const plainAccount = new PublicKey('6c5q79ccBTWvZTEx3JkdHThtMa2eALba5bfvHGf8kA2c');
-        const seeds = [
-            Buffer.from('seed'),
-            Buffer.from([4, 5, 6, 7]),
-            plainAccount.toBuffer(),
-            Buffer.from([2, 2, 2, 2]),
-        ];
-        const pdaPublicKey = PublicKey.findProgramAddressSync(seeds, testProgramId)[0];
-        const pdaPublicKeyWithProgramId = PublicKey.findProgramAddressSync(seeds, plainAccount)[0];
-
-        const plainSeed = Buffer.concat([
-            Buffer.from([1]), // u8 discriminator
-            Buffer.from([4]), // u8 length
-            Buffer.from('seed'), // 4 bytes seed
-        ]);
-
-        const instructionDataSeed = Buffer.concat([
-            Buffer.from([2]), // u8 discriminator
-            Buffer.from([4]), // u8 offset
-            Buffer.from([4]), // u8 length
-        ]);
-
-        const accountKeySeed = Buffer.concat([
-            Buffer.from([3]), // u8 discriminator
-            Buffer.from([0]), // u8 index
-        ]);
-
-        const accountDataSeed = Buffer.concat([
-            Buffer.from([4]), // u8 discriminator
-            Buffer.from([0]), // u8 account index
-            Buffer.from([2]), // u8 account data offset
-            Buffer.from([4]), // u8 account data length
-        ]);
-
-        const addressConfig = Buffer.concat([plainSeed, instructionDataSeed, accountKeySeed, accountDataSeed], 32);
-
-        const plainExtraAccountMeta = {
-            discriminator: 0,
-            addressConfig: plainAccount.toBuffer(),
-            isSigner: false,
-            isWritable: false,
-        };
-        const plainExtraAccount = Buffer.concat([
-            Buffer.from([0]), // u8 discriminator
-            plainAccount.toBuffer(), // 32 bytes address
-            Buffer.from([0]), // bool isSigner
-            Buffer.from([0]), // bool isWritable
-        ]);
-
-        const pdaExtraAccountMeta = {
-            discriminator: 1,
-            addressConfig,
-            isSigner: true,
-            isWritable: false,
-        };
-        const pdaExtraAccount = Buffer.concat([
-            Buffer.from([1]), // u8 discriminator
-            addressConfig, // 32 bytes address config
-            Buffer.from([1]), // bool isSigner
-            Buffer.from([0]), // bool isWritable
-        ]);
-
-        const pdaExtraAccountMetaWithProgramId = {
-            discriminator: 128,
-            addressConfig,
-            isSigner: false,
-            isWritable: true,
-        };
-        const pdaExtraAccountWithProgramId = Buffer.concat([
-            Buffer.from([128]), // u8 discriminator
-            addressConfig, // 32 bytes address config
-            Buffer.from([0]), // bool isSigner
-            Buffer.from([1]), // bool isWritable
-        ]);
-
-        const extraAccountList = Buffer.concat([
-            Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]), // u64 accountDiscriminator
-            Buffer.from([0, 0, 0, 0]), // u32 length
-            Buffer.from([3, 0, 0, 0]), // u32 count
-            plainExtraAccount,
-            pdaExtraAccount,
-            pdaExtraAccountWithProgramId,
-        ]);
-
-        before(async () => {
-            connection = await getConnection();
-            connection.getAccountInfo = async (
-                _publicKey: PublicKey,
-                _commitmentOrConfig?: Parameters<(typeof connection)['getAccountInfo']>[1]
-            ): ReturnType<(typeof connection)['getAccountInfo']> => ({
-                data: Buffer.from([0, 0, 2, 2, 2, 2]),
-                owner: PublicKey.default,
-                executable: false,
-                lamports: 0,
-            });
-        });
-
-        it('can parse extra metas', () => {
-            const accountInfo = {
-                data: extraAccountList,
-                owner: PublicKey.default,
-                executable: false,
-                lamports: 0,
-            };
-            const parsedExtraAccounts = getExtraAccountMetas(accountInfo);
-            expect(parsedExtraAccounts).to.not.be.null;
-            if (parsedExtraAccounts == null) {
-                return;
-            }
-
-            expect(parsedExtraAccounts).to.have.length(3);
-            if (parsedExtraAccounts.length !== 3) {
-                return;
-            }
-
-            expect(parsedExtraAccounts[0].discriminator).to.eql(0);
-            expect(parsedExtraAccounts[0].addressConfig).to.eql(plainAccount.toBuffer());
-            expect(parsedExtraAccounts[0].isSigner).to.be.false;
-            expect(parsedExtraAccounts[0].isWritable).to.be.false;
-
-            expect(parsedExtraAccounts[1].discriminator).to.eql(1);
-            expect(parsedExtraAccounts[1].addressConfig).to.eql(addressConfig);
-            expect(parsedExtraAccounts[1].isSigner).to.be.true;
-            expect(parsedExtraAccounts[1].isWritable).to.be.false;
-
-            expect(parsedExtraAccounts[2].discriminator).to.eql(128);
-            expect(parsedExtraAccounts[2].addressConfig).to.eql(addressConfig);
-            expect(parsedExtraAccounts[2].isSigner).to.be.false;
-            expect(parsedExtraAccounts[2].isWritable).to.be.true;
-        });
-
-        it('can resolve extra metas', async () => {
-            const resolvedPlainAccount = await resolveExtraAccountMeta(
-                connection,
-                plainExtraAccountMeta,
-                [],
-                instructionData,
-                testProgramId
-            );
-
-            expect(resolvedPlainAccount.pubkey).to.eql(plainAccount);
-            expect(resolvedPlainAccount.isSigner).to.be.false;
-            expect(resolvedPlainAccount.isWritable).to.be.false;
-
-            const resolvedPdaAccount = await resolveExtraAccountMeta(
-                connection,
-                pdaExtraAccountMeta,
-                [resolvedPlainAccount],
-                instructionData,
-                testProgramId
-            );
-
-            expect(resolvedPdaAccount.pubkey).to.eql(pdaPublicKey);
-            expect(resolvedPdaAccount.isSigner).to.be.true;
-            expect(resolvedPdaAccount.isWritable).to.be.false;
-
-            const resolvedPdaAccountWithProgramId = await resolveExtraAccountMeta(
-                connection,
-                pdaExtraAccountMetaWithProgramId,
-                [resolvedPlainAccount],
-                instructionData,
-                testProgramId
-            );
-
-            expect(resolvedPdaAccountWithProgramId.pubkey).to.eql(pdaPublicKeyWithProgramId);
-            expect(resolvedPdaAccountWithProgramId.isSigner).to.be.false;
-            expect(resolvedPdaAccountWithProgramId.isWritable).to.be.true;
-        });
-    });
-
-    describe('adding extra metas to instructions', () => {
-        let connection: Connection;
-
-        let transferHookProgramId: PublicKey;
-
-        let sourcePubkey: PublicKey;
-        let mintPubkey: PublicKey;
-        let destinationPubkey: PublicKey;
-        let authorityPubkey: PublicKey;
-        let validateStatePubkey: PublicKey;
-
-        const amount = 100n;
-        const amountInLeBytes = Buffer.alloc(8);
-        amountInLeBytes.writeBigUInt64LE(amount);
-        const decimals = 0;
-
-        // Arbitrary program ID included to test external PDAs
-        let arbitraryProgramId: PublicKey;
-
-        beforeEach(async () => {
-            connection = await getConnection();
-
-            transferHookProgramId = Keypair.generate().publicKey;
-
-            sourcePubkey = Keypair.generate().publicKey;
-            mintPubkey = Keypair.generate().publicKey;
-            destinationPubkey = Keypair.generate().publicKey;
-            authorityPubkey = Keypair.generate().publicKey;
-            validateStatePubkey = getExtraAccountMetaAddress(mintPubkey, transferHookProgramId);
-
-            arbitraryProgramId = Keypair.generate().publicKey;
-        });
-
-        function createMockFetchAccountDataFn(extraAccounts: ExtraAccountMeta[]) {
-            return async function mockFetchAccountDataFn(
-                publicKey: PublicKey,
-                _commitmentOrConfig?: Parameters<Connection['getAccountInfo']>[1]
-            ): ReturnType<Connection['getAccountInfo']> {
-                // Mocked mint state
-                if (publicKey.equals(mintPubkey)) {
-                    const data = Buffer.alloc(
-                        ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE + TYPE_SIZE + LENGTH_SIZE + TRANSFER_HOOK_SIZE
-                    );
-                    MintLayout.encode(
-                        {
-                            mintAuthorityOption: 0,
-                            mintAuthority: PublicKey.default,
-                            supply: 10000n,
-                            decimals,
-                            isInitialized: true,
-                            freezeAuthorityOption: 0,
-                            freezeAuthority: PublicKey.default,
-                        },
-                        data,
-                        0
-                    );
-                    data.writeUint8(1, ACCOUNT_SIZE); // Account type (1): Mint = 1
-                    data.writeUint16LE(ExtensionType.TransferHook, ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
-                    data.writeUint16LE(TRANSFER_HOOK_SIZE, ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE + TYPE_SIZE);
-                    TransferHookLayout.encode(
-                        {
-                            authority: Keypair.generate().publicKey,
-                            programId: transferHookProgramId,
-                        },
-                        data,
-                        ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE + TYPE_SIZE + LENGTH_SIZE
-                    );
-                    return {
-                        data,
-                        owner: TOKEN_2022_PROGRAM_ID,
-                        executable: false,
-                        lamports: 0,
-                    };
-                }
-
-                // Mocked validate state
-                if (publicKey.equals(validateStatePubkey)) {
-                    const extraAccountsList: ExtraAccountMetaList = {
-                        count: extraAccounts.length,
-                        extraAccounts,
-                    };
-                    const instructionDiscriminator = Buffer.from([
-                        105, 37, 101, 197, 75, 251, 102, 26,
-                    ]).readBigUInt64LE();
-                    const data = Buffer.alloc(8 + 4 + 4 + ExtraAccountMetaLayout.span * extraAccounts.length);
-                    ExtraAccountMetaAccountDataLayout.encode(
-                        {
-                            instructionDiscriminator,
-                            length: 4 + ExtraAccountMetaLayout.span * extraAccounts.length,
-                            extraAccountsList,
-                        },
-                        data
-                    );
-                    return {
-                        data,
-                        owner: transferHookProgramId,
-                        executable: false,
-                        lamports: 0,
-                    };
-                }
-
-                return {
-                    data: Buffer.from([]),
-                    owner: PublicKey.default,
-                    executable: false,
-                    lamports: 0,
-                };
-            };
-        }
-
-        const addressConfig = (data: Uint8Array) => {
-            const addressConfig = Buffer.alloc(32);
-            addressConfig.set(data, 0);
-            return addressConfig;
-        };
-
-        const fixedAddress = (address: PublicKey, isSigner: boolean, isWritable: boolean) => ({
-            discriminator: 0,
-            addressConfig: address.toBuffer(),
-            isSigner,
-            isWritable,
-        });
-
-        const pda = (seeds: number[], isSigner: boolean, isWritable: boolean) => ({
-            discriminator: 1,
-            addressConfig: addressConfig(new Uint8Array(seeds)),
-            isSigner,
-            isWritable,
-        });
-
-        const externalPda = (programKeyIndex: number, seeds: number[], isSigner: boolean, isWritable: boolean) => ({
-            discriminator: (1 << 7) + programKeyIndex,
-            addressConfig: addressConfig(new Uint8Array(seeds)),
-            isSigner,
-            isWritable,
-        });
-
-        it('can add extra account metas for execute', async () => {
-            const extraMeta1Pubkey = Keypair.generate().publicKey;
-            const extraMeta2Pubkey = Keypair.generate().publicKey;
-            const extraMeta3Pubkey = Keypair.generate().publicKey;
-
-            // prettier-ignore
-            connection.getAccountInfo = createMockFetchAccountDataFn([
-                fixedAddress(extraMeta1Pubkey, false, false),
-                fixedAddress(extraMeta2Pubkey, false, false),
-                fixedAddress(extraMeta3Pubkey, false, false),
-                pda([
-                    3, 0, // First seed: Account key at index 0 (2)
-                    3, 4, // Second seed: Account key at index 4 (2)
-                ], false, false),
-                pda([
-                    3, 5, // First seed: Account key at index 5 (2)
-                    3, 6, // Second seed: Account key at index 6 (2)
-                ], false, false),
-                pda([
-                    1, 6, 112, 114, 101, 102, 105, 120, // First seed: Literal "prefix" (8)
-                    2, 8, 8, // Second seed: Instruction data 8..16 (3)
-                ], false, false),
-            ]);
-
-            const extraMeta4Pubkey = PublicKey.findProgramAddressSync(
-                [sourcePubkey.toBuffer(), validateStatePubkey.toBuffer()],
-                transferHookProgramId
-            )[0];
-            const extraMeta5Pubkey = PublicKey.findProgramAddressSync(
-                [extraMeta1Pubkey.toBuffer(), extraMeta2Pubkey.toBuffer()],
-                transferHookProgramId
-            )[0];
-            const extraMeta6Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    Buffer.from('prefix'),
-                    amountInLeBytes, // Instruction data 8..16
-                ],
-                transferHookProgramId
-            )[0];
-
-            // Fail missing key
-            const rawInstructionMissingKey = new TransactionInstruction({
-                keys: [
-                    // source missing
-                    { pubkey: mintPubkey, isSigner: false, isWritable: false },
-                    { pubkey: destinationPubkey, isSigner: false, isWritable: true },
-                    { pubkey: authorityPubkey, isSigner: true, isWritable: false },
-                ],
-                programId: transferHookProgramId,
-            });
-            await expect(
-                addExtraAccountMetasForExecute(
-                    connection,
-                    rawInstructionMissingKey,
-                    transferHookProgramId,
-                    sourcePubkey,
-                    mintPubkey,
-                    destinationPubkey,
-                    authorityPubkey,
-                    amount
-                )
-            ).to.be.rejectedWith('Missing required account in instruction');
-
-            const instruction = new TransactionInstruction({
-                keys: [
-                    { pubkey: sourcePubkey, isSigner: false, isWritable: true },
-                    { pubkey: mintPubkey, isSigner: false, isWritable: false },
-                    { pubkey: destinationPubkey, isSigner: false, isWritable: true },
-                    { pubkey: authorityPubkey, isSigner: true, isWritable: false },
-                ],
-                programId: transferHookProgramId,
-            });
-
-            await addExtraAccountMetasForExecute(
-                connection,
-                instruction,
-                transferHookProgramId,
-                sourcePubkey,
-                mintPubkey,
-                destinationPubkey,
-                authorityPubkey,
-                amount
-            );
-
-            const checkMetas = [
-                { pubkey: sourcePubkey, isSigner: false, isWritable: true },
-                { pubkey: mintPubkey, isSigner: false, isWritable: false },
-                { pubkey: destinationPubkey, isSigner: false, isWritable: true },
-                { pubkey: authorityPubkey, isSigner: true, isWritable: false },
-                { pubkey: extraMeta1Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta2Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta3Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta4Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta5Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta6Pubkey, isSigner: false, isWritable: false },
-                { pubkey: transferHookProgramId, isSigner: false, isWritable: false },
-                { pubkey: validateStatePubkey, isSigner: false, isWritable: false },
-            ];
-
-            expect(instruction.keys).to.eql(checkMetas);
-        });
-
-        it('can create a transfer instruction with extra metas', async () => {
-            // prettier-ignore
-            connection.getAccountInfo = createMockFetchAccountDataFn([
-                pda([
-                    3, 0, // First seed: Account key at index 0 (2)
-                    3, 1, // Second seed: Account key at index 1 (2)
-                ], false, false),
-                pda([
-                    3, 4, // First seed: Account key at index 4 (2)
-                ], false, false),
-                pda([
-                    1, 6, 112, 114, 101, 102, 105, 120, // First seed: Literal "prefix" (8)
-                    2, 8, 8, // Second seed: Instruction data 8..16 (3)
-                ], false, false),
-                fixedAddress(arbitraryProgramId, false, false),
-                externalPda(8, [
-                    1, 6, 112, 114, 101, 102, 105, 120, // First seed: Literal "prefix" (8)
-                    2, 8, 8, // Second seed: Instruction data 8..16 (3)
-                    3, 6, // Third seed: Account key at index 6 (2)
-                ], false, false),
-                externalPda(8, [
-                    1, 14, 97, 110, 111, 116, 104, 101, 114, 95, 112, 114, 101, 102, 105,
-                    120, // First seed: Literal "another_prefix" (16)
-                    2, 8, 8, // Second seed: Instruction data 8..16 (3)
-                    3, 6, // Third seed: Account key at index 6 (2)
-                    3, 9, // Fourth seed: Account key at index 9 (2)
-                ], false, false),
-            ]);
-
-            const extraMeta1Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    sourcePubkey.toBuffer(), // Account key at index 0
-                    mintPubkey.toBuffer(), // Account key at index 1
-                ],
-                transferHookProgramId
-            )[0];
-            const extraMeta2Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    validateStatePubkey.toBuffer(), // Account key at index 4
-                ],
-                transferHookProgramId
-            )[0];
-            const extraMeta3Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    Buffer.from('prefix'),
-                    amountInLeBytes, // Instruction data 8..16
-                ],
-                transferHookProgramId
-            )[0];
-            const extraMeta4Pubkey = arbitraryProgramId;
-            const extraMeta5Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    Buffer.from('prefix'),
-                    amountInLeBytes, // Instruction data 8..16
-                    extraMeta2Pubkey.toBuffer(),
-                ],
-                extraMeta4Pubkey // PDA off of the arbitrary program ID
-            )[0];
-            const extraMeta6Pubkey = PublicKey.findProgramAddressSync(
-                [
-                    Buffer.from('another_prefix'),
-                    amountInLeBytes, // Instruction data 8..16
-                    extraMeta2Pubkey.toBuffer(),
-                    extraMeta5Pubkey.toBuffer(),
-                ],
-                extraMeta4Pubkey // PDA off of the arbitrary program ID
-            )[0];
-
-            const instruction = await createTransferCheckedWithTransferHookInstruction(
-                connection,
-                sourcePubkey,
-                mintPubkey,
-                destinationPubkey,
-                authorityPubkey,
-                amount,
-                decimals,
-                [],
-                undefined,
-                TOKEN_2022_PROGRAM_ID
-            );
-
-            const checkMetas = [
-                { pubkey: sourcePubkey, isSigner: false, isWritable: true },
-                { pubkey: mintPubkey, isSigner: false, isWritable: false },
-                { pubkey: destinationPubkey, isSigner: false, isWritable: true },
-                { pubkey: authorityPubkey, isSigner: true, isWritable: false },
-                { pubkey: extraMeta1Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta2Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta3Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta4Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta5Pubkey, isSigner: false, isWritable: false },
-                { pubkey: extraMeta6Pubkey, isSigner: false, isWritable: false },
-                { pubkey: transferHookProgramId, isSigner: false, isWritable: false },
-                { pubkey: validateStatePubkey, isSigner: false, isWritable: false },
-            ];
-
-            expect(instruction.keys).to.eql(checkMetas);
-        });
-    });
-});
diff --git a/token/js/test/unit/transferfee.test.ts b/token/js/test/unit/transferfee.test.ts
deleted file mode 100644
index bfde797d778..00000000000
--- a/token/js/test/unit/transferfee.test.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-import {
-    calculateFee,
-    calculateEpochFee,
-    ONE_IN_BASIS_POINTS,
-    createInitializeTransferFeeConfigInstruction,
-    decodeInitializeTransferFeeConfigInstructionUnchecked,
-} from '../../src';
-import { expect } from 'chai';
-import { Keypair, PublicKey } from '@solana/web3.js';
-
-describe('transferFee', () => {
-    describe('encoding/decoding `InitializeTransferFeeConfig` instructions', () => {
-        it('should encode and decode with both authorities', () => {
-            const mint = Keypair.generate().publicKey;
-            const transferFeeConfigAuthority = Keypair.generate().publicKey;
-            const withdrawWithheldAuthority = Keypair.generate().publicKey;
-            const instruction = createInitializeTransferFeeConfigInstruction(
-                mint,
-                transferFeeConfigAuthority,
-                withdrawWithheldAuthority,
-                100,
-                100n
-            );
-            const decoded = decodeInitializeTransferFeeConfigInstructionUnchecked(instruction);
-            expect(decoded.data.transferFeeConfigAuthority).to.eql(transferFeeConfigAuthority);
-            expect(decoded.data.withdrawWithheldAuthority).to.eql(withdrawWithheldAuthority);
-            expect(decoded.data.transferFeeBasisPoints).to.eql(100);
-            expect(decoded.data.maximumFee).to.eql(100n);
-        });
-        it('should encode and decode with no transfer fee config authority', () => {
-            const mint = Keypair.generate().publicKey;
-            const withdrawWithheldAuthority = Keypair.generate().publicKey;
-            const instruction = createInitializeTransferFeeConfigInstruction(
-                mint,
-                null,
-                withdrawWithheldAuthority,
-                100,
-                100n
-            );
-            const decoded = decodeInitializeTransferFeeConfigInstructionUnchecked(instruction);
-            expect(decoded.data.transferFeeConfigAuthority).to.eql(null);
-            expect(decoded.data.withdrawWithheldAuthority).to.eql(withdrawWithheldAuthority);
-            expect(decoded.data.transferFeeBasisPoints).to.eql(100);
-            expect(decoded.data.maximumFee).to.eql(100n);
-        });
-        it('should encode and decode with no withdraw withheld authority', () => {
-            const mint = Keypair.generate().publicKey;
-            const transferFeeConfigAuthority = Keypair.generate().publicKey;
-            const instruction = createInitializeTransferFeeConfigInstruction(
-                mint,
-                transferFeeConfigAuthority,
-                null,
-                100,
-                100n
-            );
-            const decoded = decodeInitializeTransferFeeConfigInstructionUnchecked(instruction);
-            expect(decoded.data.transferFeeConfigAuthority).to.eql(transferFeeConfigAuthority);
-            expect(decoded.data.withdrawWithheldAuthority).to.eql(null);
-            expect(decoded.data.transferFeeBasisPoints).to.eql(100);
-            expect(decoded.data.maximumFee).to.eql(100n);
-        });
-        it('should encode and decode with no authorities', () => {
-            const mint = Keypair.generate().publicKey;
-            const instruction = createInitializeTransferFeeConfigInstruction(mint, null, null, 100, 100n);
-            const decoded = decodeInitializeTransferFeeConfigInstructionUnchecked(instruction);
-            expect(decoded.data.transferFeeConfigAuthority).to.eql(null);
-            expect(decoded.data.withdrawWithheldAuthority).to.eql(null);
-            expect(decoded.data.transferFeeBasisPoints).to.eql(100);
-            expect(decoded.data.maximumFee).to.eql(100n);
-        });
-    });
-
-    describe('calculateFee', () => {
-        it('should return 0 fee when transferFeeBasisPoints is 0', () => {
-            const transferFee = {
-                epoch: 1n,
-                maximumFee: 100n,
-                transferFeeBasisPoints: 0,
-            };
-            const preFeeAmount = 100n;
-            const fee = calculateFee(transferFee, preFeeAmount);
-            expect(fee).to.eql(0n);
-        });
-
-        it('should return 0 fee when preFeeAmount is 0', () => {
-            const transferFee = {
-                epoch: 1n,
-                maximumFee: 100n,
-                transferFeeBasisPoints: 100,
-            };
-            const preFeeAmount = 0n;
-            const fee = calculateFee(transferFee, preFeeAmount);
-            expect(fee).to.eql(0n);
-        });
-
-        it('should calculate the fee correctly when preFeeAmount is non-zero', () => {
-            const transferFee = {
-                epoch: 1n,
-                maximumFee: 100n,
-                transferFeeBasisPoints: 50,
-            };
-            const preFeeAmount = 500n;
-            const fee = calculateFee(transferFee, preFeeAmount);
-            expect(fee).to.eql(3n);
-        });
-
-        it('fee should be equal to maximum fee', () => {
-            const transferFee = {
-                epoch: 1n,
-                maximumFee: 5000n,
-                transferFeeBasisPoints: 50,
-            };
-            const preFeeAmount = transferFee.maximumFee;
-            const fee = calculateFee(transferFee, preFeeAmount * ONE_IN_BASIS_POINTS);
-            expect(fee).to.eql(transferFee.maximumFee);
-        });
-        it('fee should be equal to maximum fee when added 1 to preFeeAmount', () => {
-            const transferFee = {
-                epoch: 1n,
-                maximumFee: 5000n,
-                transferFeeBasisPoints: 50,
-            };
-            const preFeeAmount = transferFee.maximumFee;
-            const fee = calculateFee(transferFee, preFeeAmount * ONE_IN_BASIS_POINTS + 1n);
-            expect(fee).to.eql(transferFee.maximumFee);
-        });
-    });
-
-    describe('calculateEpochFee', () => {
-        const transferFeeConfig = {
-            transferFeeConfigAuthority: PublicKey.default,
-            withdrawWithheldAuthority: PublicKey.default,
-            withheldAmount: 500n,
-            olderTransferFee: {
-                epoch: 1n,
-                maximumFee: 100n,
-                transferFeeBasisPoints: 50,
-            },
-            newerTransferFee: {
-                epoch: 2n,
-                maximumFee: 200n,
-                transferFeeBasisPoints: 75,
-            },
-        };
-
-        it('should return olderTransferFee when epoch is less than newerTransferFee.epoch', () => {
-            const preFeeAmount = 200n;
-            const epoch = 1n;
-            const fee = calculateEpochFee(transferFeeConfig, epoch, preFeeAmount);
-            expect(fee).to.eql(1n);
-        });
-
-        it('should return newerTransferFee when epoch is greater than or equal to newerTransferFee.epoch', () => {
-            const preFeeAmount = 200n;
-            const epoch = 2n;
-            const fee = calculateEpochFee(transferFeeConfig, epoch, preFeeAmount);
-            expect(fee).to.eql(2n);
-        });
-
-        it('should cap the fee to the maximumFee when calculated fee exceeds maximumFee', () => {
-            const preFeeAmount = 500n;
-            const epoch = 2n;
-            const fee = calculateEpochFee(transferFeeConfig, epoch, preFeeAmount);
-            expect(fee).to.eql(4n);
-        });
-    });
-});
diff --git a/token/js/tsconfig.all.json b/token/js/tsconfig.all.json
deleted file mode 100644
index 985513259e2..00000000000
--- a/token/js/tsconfig.all.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.root.json",
-    "references": [
-        {
-            "path": "./tsconfig.cjs.json"
-        },
-        {
-            "path": "./tsconfig.esm.json"
-        }
-    ]
-}
diff --git a/token/js/tsconfig.base.json b/token/js/tsconfig.base.json
deleted file mode 100644
index 90620c4e485..00000000000
--- a/token/js/tsconfig.base.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "include": [],
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Node",
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "strict": true,
-        "stripInternal": true
-    }
-}
diff --git a/token/js/tsconfig.cjs.json b/token/js/tsconfig.cjs.json
deleted file mode 100644
index 2db9b71569e..00000000000
--- a/token/js/tsconfig.cjs.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/cjs",
-        "target": "ES2016",
-        "module": "CommonJS",
-        "sourceMap": true
-    }
-}
diff --git a/token/js/tsconfig.esm.json b/token/js/tsconfig.esm.json
deleted file mode 100644
index 25e7e25e751..00000000000
--- a/token/js/tsconfig.esm.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "include": ["src"],
-    "compilerOptions": {
-        "outDir": "lib/esm",
-        "declarationDir": "lib/types",
-        "target": "ES2020",
-        "module": "ES2020",
-        "sourceMap": true,
-        "declaration": true,
-        "declarationMap": true
-    }
-}
diff --git a/token/js/tsconfig.json b/token/js/tsconfig.json
deleted file mode 100644
index 2f9b239bfca..00000000000
--- a/token/js/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig.all.json",
-    "include": ["src", "test"],
-    "compilerOptions": {
-        "noEmit": true,
-        "skipLibCheck": true
-    }
-}
diff --git a/token/js/tsconfig.root.json b/token/js/tsconfig.root.json
deleted file mode 100644
index fadf294ab43..00000000000
--- a/token/js/tsconfig.root.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "compilerOptions": {
-        "composite": true
-    }
-}
diff --git a/token/js/typedoc.json b/token/js/typedoc.json
deleted file mode 100644
index c39fc53aee1..00000000000
--- a/token/js/typedoc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "entryPoints": ["src/index.ts"],
-    "out": "docs",
-    "readme": "README.md"
-}
diff --git a/token/program-2022-test/Cargo.toml b/token/program-2022-test/Cargo.toml
deleted file mode 100644
index ac81ceba552..00000000000
--- a/token/program-2022-test/Cargo.toml
+++ /dev/null
@@ -1,44 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL-Token 2022 Integration Tests"
-edition = "2021"
-license = "Apache-2.0"
-name = "spl-token-2022-test"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "0.0.1"
-
-[features]
-test-sbf = ["zk-ops"]
-default = ["zk-ops"]
-zk-ops = []
-
-[build-dependencies]
-walkdir = "2"
-
-[dev-dependencies]
-async-trait = "0.1"
-borsh = "1.5.1"
-futures-util = "0.3"
-solana-program = ">=1.18.11,<=2"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-associated-token-account = { version = "3.0.2", path = "../../associated-token-account/program" }
-spl-memo = { version = "4.0.1", path = "../../memo/program", features = [
-  "no-entrypoint",
-] }
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-spl-token-2022 = { version = "3.0.2", path = "../program-2022", features = [
-  "no-entrypoint",
-] }
-spl-instruction-padding = { version = "0.1.1", path = "../../instruction-padding/program", features = [
-  "no-entrypoint",
-] }
-spl-tlv-account-resolution = { version = "0.6.3", path = "../../libraries/tlv-account-resolution" }
-spl-token-client = { version = "0.10.0", path = "../client" }
-spl-token-group-interface = { version = "0.2.3", path = "../../token-group/interface" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-spl-transfer-hook-example = { version = "0.6", path = "../transfer-hook/example", features = [
-  "no-entrypoint",
-] }
-spl-transfer-hook-interface = { version = "0.6.3", path = "../transfer-hook/interface" }
-test-case = "3.3"
diff --git a/token/program-2022-test/build.rs b/token/program-2022-test/build.rs
deleted file mode 100644
index 12e0f75b217..00000000000
--- a/token/program-2022-test/build.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-extern crate walkdir;
-
-use {
-    std::{env, path::Path, process::Command},
-    walkdir::WalkDir,
-};
-
-fn rerun_if_changed(directory: &Path) {
-    let src = directory.join("src");
-    let files_in_src: Vec<_> = WalkDir::new(src)
-        .into_iter()
-        .map(|entry| entry.unwrap())
-        .filter(|entry| {
-            if !entry.file_type().is_file() {
-                return false;
-            }
-            true
-        })
-        .map(|f| f.path().to_str().unwrap().to_owned())
-        .collect();
-
-    for file in files_in_src {
-        if !Path::new(&file).is_file() {
-            panic!("{} is not a file", file);
-        }
-        println!("cargo:rerun-if-changed={}", file);
-    }
-    let toml = directory.join("Cargo.toml").to_str().unwrap().to_owned();
-    println!("cargo:rerun-if-changed={}", toml);
-}
-
-fn main() {
-    let cwd = env::current_dir().expect("Unable to get current working directory");
-
-    let spl_token_2022_dir = cwd
-        .parent()
-        .expect("Unable to get parent directory of current working dir")
-        .join("program-2022");
-    rerun_if_changed(&spl_token_2022_dir);
-
-    let instruction_padding_dir = cwd
-        .parent()
-        .expect("Unable to get parent directory of current working dir")
-        .parent()
-        .expect("Unable to get grandparent directory of current working dir")
-        .join("instruction-padding")
-        .join("program");
-    rerun_if_changed(&instruction_padding_dir);
-
-    println!("cargo:rerun-if-changed=build.rs");
-
-    for program_dir in [spl_token_2022_dir, instruction_padding_dir] {
-        let program_toml = program_dir.join("Cargo.toml");
-        let program_toml = format!("{}", program_toml.display());
-        let args = vec!["build-sbf", "--manifest-path", &program_toml];
-        let output = Command::new("cargo")
-            .args(&args)
-            .output()
-            .expect("Error running cargo build-sbf");
-        if let Ok(output_str) = std::str::from_utf8(&output.stdout) {
-            let subs = output_str.split('\n');
-            for sub in subs {
-                println!("cargo:warning=(not a warning) {}", sub);
-            }
-        }
-    }
-
-    // Set the temporary `twoxtx` cfg if `../twoxtx-setup.sh` was run
-    let twoxtx_solana_dir = cwd
-        .parent()
-        .expect("Unable to get parent directory of current working dir")
-        .join("twoxtx-solana");
-    if twoxtx_solana_dir.exists() {
-        println!("cargo:rustc-cfg=twoxtx");
-    }
-}
diff --git a/token/program-2022-test/tests/burn.rs b/token/program-2022-test/tests/burn.rs
deleted file mode 100644
index df4ab148b2b..00000000000
--- a/token/program-2022-test/tests/burn.rs
+++ /dev/null
@@ -1,300 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::error::TokenError,
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-};
-
-async fn run_basic(context: TestContext) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // mint a token
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // unchecked is ok
-    token_unchecked
-        .burn(&alice_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-
-    // checked is ok
-    token
-        .burn(&alice_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-
-    // burn too much is not ok
-    let error = token
-        .burn(&alice_account, &alice.pubkey(), amount, &[&alice])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-
-    // wrong signer
-    let error = token
-        .burn(&alice_account, &bob.pubkey(), 1, &[&bob])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn basic() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_basic(context).await;
-}
-
-#[tokio::test]
-async fn basic_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000u64,
-        }])
-        .await
-        .unwrap();
-    run_basic(context).await;
-}
-
-async fn run_self_owned(context: TestContext) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        ..
-    } = context.token_context.unwrap();
-
-    token
-        .create_auxiliary_token_account(&alice, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice.pubkey();
-
-    // mint a token
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // unchecked is ok
-    token_unchecked
-        .burn(&alice_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-
-    // checked is ok
-    token
-        .burn(&alice_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn self_owned() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_self_owned(context).await;
-}
-
-#[tokio::test]
-async fn self_owned_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000u64,
-        }])
-        .await
-        .unwrap();
-    run_self_owned(context).await;
-}
-
-async fn run_burn_and_close_system_or_incinerator(context: TestContext, non_owner: &Pubkey) {
-    let TokenContext {
-        mint_authority,
-        token,
-        alice,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // mint a token
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            1,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // transfer token to incinerator/system
-    let non_owner_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&non_owner_account, non_owner)
-        .await
-        .unwrap();
-    let non_owner_account = non_owner_account.pubkey();
-    token
-        .transfer(
-            &alice_account,
-            &non_owner_account,
-            &alice.pubkey(),
-            1,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // can't close when holding tokens
-    let carlos = Keypair::new();
-    let error = token
-        .close_account(
-            &non_owner_account,
-            &solana_program::incinerator::id(),
-            &carlos.pubkey(),
-            &[&carlos],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonNativeHasBalance as u32)
-            )
-        )))
-    );
-
-    // but anyone can burn it
-    token
-        .burn(&non_owner_account, &carlos.pubkey(), 1, &[&carlos])
-        .await
-        .unwrap();
-
-    // closing fails if destination is not the incinerator
-    let error = token
-        .close_account(
-            &non_owner_account,
-            &carlos.pubkey(),
-            &carlos.pubkey(),
-            &[&carlos],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-
-    let error = token
-        .close_account(
-            &non_owner_account,
-            &solana_program::system_program::id(),
-            &carlos.pubkey(),
-            &[&carlos],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-
-    // ... and then close it
-    token.get_new_latest_blockhash().await.unwrap();
-    token
-        .close_account(
-            &non_owner_account,
-            &solana_program::incinerator::id(),
-            &carlos.pubkey(),
-            &[&carlos],
-        )
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn burn_and_close_incinerator_tokens() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_burn_and_close_system_or_incinerator(context, &solana_program::incinerator::id()).await;
-}
-
-#[tokio::test]
-async fn burn_and_close_system_tokens() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_burn_and_close_system_or_incinerator(context, &solana_program::system_program::id()).await;
-}
diff --git a/token/program-2022-test/tests/close_account.rs b/token/program-2022-test/tests/close_account.rs
deleted file mode 100644
index d070b9d1134..00000000000
--- a/token/program-2022-test/tests/close_account.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, program_pack::Pack, pubkey::Pubkey, signature::Signer,
-        signer::keypair::Keypair, system_instruction, transaction::TransactionError,
-        transport::TransportError,
-    },
-    spl_token_2022::{instruction, state::Account},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-};
-
-#[tokio::test]
-async fn success_init_after_close_account() {
-    let mut context = TestContext::new().await;
-    let payer = Keypair::from_bytes(&context.context.lock().await.payer.to_bytes()).unwrap();
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let token = context.token_context.take().unwrap().token;
-    let token_program_id = spl_token_2022::id();
-    let owner = Keypair::new();
-    let token_account_keypair = Keypair::new();
-    token
-        .create_auxiliary_token_account(&token_account_keypair, &owner.pubkey())
-        .await
-        .unwrap();
-    let token_account = token_account_keypair.pubkey();
-
-    let destination = Pubkey::new_unique();
-    token
-        .process_ixs(
-            &[
-                instruction::close_account(
-                    &token_program_id,
-                    &token_account,
-                    &destination,
-                    &owner.pubkey(),
-                    &[],
-                )
-                .unwrap(),
-                system_instruction::create_account(
-                    &payer.pubkey(),
-                    &token_account,
-                    1_000_000_000,
-                    Account::LEN as u64,
-                    &token_program_id,
-                ),
-                instruction::initialize_account(
-                    &token_program_id,
-                    &token_account,
-                    token.get_address(),
-                    &owner.pubkey(),
-                )
-                .unwrap(),
-            ],
-            &[&owner, &payer, &token_account_keypair],
-        )
-        .await
-        .unwrap();
-    let destination = token.get_account(destination).await.unwrap();
-    assert!(destination.lamports > 0);
-}
-
-#[tokio::test]
-async fn fail_init_after_close_account() {
-    let mut context = TestContext::new().await;
-    let payer = Keypair::from_bytes(&context.context.lock().await.payer.to_bytes()).unwrap();
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let token = context.token_context.take().unwrap().token;
-    let token_program_id = spl_token_2022::id();
-    let owner = Keypair::new();
-    let token_account_keypair = Keypair::new();
-    token
-        .create_auxiliary_token_account(&token_account_keypair, &owner.pubkey())
-        .await
-        .unwrap();
-    let token_account = token_account_keypair.pubkey();
-
-    let destination = Pubkey::new_unique();
-    let error = token
-        .process_ixs(
-            &[
-                instruction::close_account(
-                    &token_program_id,
-                    &token_account,
-                    &destination,
-                    &owner.pubkey(),
-                    &[],
-                )
-                .unwrap(),
-                system_instruction::transfer(&payer.pubkey(), &token_account, 1_000_000_000),
-                instruction::initialize_account(
-                    &token_program_id,
-                    &token_account,
-                    token.get_address(),
-                    &owner.pubkey(),
-                )
-                .unwrap(),
-            ],
-            &[&owner, &payer],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(2, InstructionError::InvalidAccountData,)
-        )))
-    );
-    let error = token.get_account(destination).await.unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-}
-
-#[tokio::test]
-async fn fail_init_after_close_mint() {
-    let close_authority = Keypair::new();
-    let mut context = TestContext::new().await;
-    let payer = Keypair::from_bytes(&context.context.lock().await.payer.to_bytes()).unwrap();
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority: Some(close_authority.pubkey()),
-        }])
-        .await
-        .unwrap();
-    let token = context.token_context.take().unwrap().token;
-    let token_program_id = spl_token_2022::id();
-
-    let destination = Pubkey::new_unique();
-    let error = token
-        .process_ixs(
-            &[
-                instruction::close_account(
-                    &token_program_id,
-                    token.get_address(),
-                    &destination,
-                    &close_authority.pubkey(),
-                    &[],
-                )
-                .unwrap(),
-                system_instruction::transfer(&payer.pubkey(), token.get_address(), 1_000_000_000),
-                instruction::initialize_mint_close_authority(
-                    &token_program_id,
-                    token.get_address(),
-                    None,
-                )
-                .unwrap(),
-                instruction::initialize_mint(
-                    &token_program_id,
-                    token.get_address(),
-                    &close_authority.pubkey(),
-                    None,
-                    0,
-                )
-                .unwrap(),
-            ],
-            &[&close_authority, &payer],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(2, InstructionError::InvalidAccountData,)
-        )))
-    );
-    let error = token.get_account(destination).await.unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-}
diff --git a/token/program-2022-test/tests/confidential_transfer.rs b/token/program-2022-test/tests/confidential_transfer.rs
deleted file mode 100644
index bacc44c2848..00000000000
--- a/token/program-2022-test/tests/confidential_transfer.rs
+++ /dev/null
@@ -1,3039 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{
-        ConfidentialTokenAccountBalances, ConfidentialTokenAccountMeta, TestContext, TokenContext,
-    },
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            confidential_transfer::{
-                self,
-                account_info::TransferAccountInfo,
-                instruction::{
-                    CloseSplitContextStateAccounts, TransferSplitContextStateAccounts,
-                    TransferWithFeeSplitContextStateAccounts,
-                },
-                ConfidentialTransferAccount, MAXIMUM_DEPOSIT_TRANSFER_AMOUNT,
-            },
-            BaseStateWithExtensions, ExtensionType,
-        },
-        solana_zk_token_sdk::{
-            encryption::{auth_encryption::*, elgamal::*},
-            zk_token_elgamal::pod::{self, Zeroable},
-            zk_token_proof_instruction::*,
-            zk_token_proof_program,
-            zk_token_proof_state::ProofContextState,
-        },
-    },
-    spl_token_client::{
-        proof_generation::transfer_with_fee_split_proof_data,
-        token::{ComputeUnitLimit, ExtensionInitializationParams, TokenError as TokenClientError},
-    },
-    std::{convert::TryInto, mem::size_of},
-};
-
-#[cfg(feature = "zk-ops")]
-const TEST_MAXIMUM_FEE: u64 = 100;
-#[cfg(feature = "zk-ops")]
-const TEST_FEE_BASIS_POINTS: u16 = 250;
-
-#[tokio::test]
-async fn confidential_transfer_configure_token_account() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = false;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-    let alice_elgamal_pubkey = (*alice_meta.elgamal_keypair.pubkey()).into();
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(&extension.approved));
-    assert!(bool::from(&extension.allow_confidential_credits));
-    assert_eq!(extension.elgamal_pubkey, alice_elgamal_pubkey);
-    assert_eq!(
-        alice_meta
-            .aes_key
-            .decrypt(&(extension.decryptable_available_balance.try_into().unwrap()))
-            .unwrap(),
-        0
-    );
-
-    token
-        .confidential_transfer_approve_account(
-            &alice_meta.token_account,
-            &authority.pubkey(),
-            &[&authority],
-        )
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(&extension.approved));
-
-    // Configuring an already initialized account should produce an error
-    let err = token
-        .confidential_transfer_configure_token_account(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::ExtensionAlreadyInitialized as u32),
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn confidential_transfer_fail_approving_account_on_wrong_mint() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = false;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context_a = TestContext::new().await;
-    context_a
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let token_a_context = context_a.token_context.unwrap();
-
-    let mut context_b = TestContext {
-        context: context_a.context.clone(),
-        token_context: None,
-    };
-    context_b
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-    let TokenContext { token, alice, .. } = context_b.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-
-    let err = token_a_context
-        .token
-        .confidential_transfer_approve_account(
-            &alice_meta.token_account,
-            &authority.pubkey(),
-            &[&authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn confidential_transfer_enable_disable_confidential_credits() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-
-    token
-        .confidential_transfer_disable_confidential_credits(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(&extension.allow_confidential_credits));
-
-    token
-        .mint_to(
-            &alice_meta.token_account,
-            &mint_authority.pubkey(),
-            10,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            10,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(
-                    TokenError::ConfidentialTransferDepositsAndTransfersDisabled as u32
-                )
-            )
-        )))
-    );
-
-    token
-        .confidential_transfer_enable_confidential_credits(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(&extension.allow_confidential_credits));
-
-    // Refresh the blockhash since we're doing the same thing twice in a row
-    token.get_new_latest_blockhash().await.unwrap();
-    token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            10,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn confidential_transfer_enable_disable_non_confidential_credits() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        ..
-    } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, false).await;
-
-    token
-        .mint_to(
-            &alice_meta.token_account,
-            &mint_authority.pubkey(),
-            10,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_disable_non_confidential_credits(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            &[&bob],
-        )
-        .await
-        .unwrap();
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(&extension.allow_non_confidential_credits));
-
-    let err = token
-        .transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            10,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonConfidentialTransfersDisabled as u32)
-            )
-        )))
-    );
-
-    token
-        .confidential_transfer_enable_non_confidential_credits(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            &[&bob],
-        )
-        .await
-        .unwrap();
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(bool::from(&extension.allow_non_confidential_credits));
-
-    // transfer a different number to change the signature
-    token
-        .transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            9,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn confidential_transfer_empty_account() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-
-    // newly created confidential transfer account should hold no balance and
-    // therefore, immediately closable
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-
-    token
-        .confidential_transfer_empty_account(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            None,
-            &alice_meta.elgamal_keypair,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_deposit() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, Some(2), false, false).await;
-
-    token
-        .mint_to(
-            &alice_meta.token_account,
-            &mint_authority.pubkey(),
-            65537,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(state.base.amount, 65537);
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert_eq!(extension.pending_balance_credit_counter, 0.into());
-    assert_eq!(extension.expected_pending_balance_credit_counter, 0.into());
-    assert_eq!(extension.actual_pending_balance_credit_counter, 0.into());
-    assert_eq!(
-        extension.pending_balance_lo,
-        pod::ElGamalCiphertext::zeroed()
-    );
-    assert_eq!(
-        extension.pending_balance_hi,
-        pod::ElGamalCiphertext::zeroed()
-    );
-    assert_eq!(
-        extension.available_balance,
-        pod::ElGamalCiphertext::zeroed()
-    );
-
-    token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            65537,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(state.base.amount, 0);
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert_eq!(extension.pending_balance_credit_counter, 1.into());
-    assert_eq!(extension.expected_pending_balance_credit_counter, 0.into());
-    assert_eq!(extension.actual_pending_balance_credit_counter, 0.into());
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 1,
-                pending_balance_hi: 1,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    // deposit zero amount
-    token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            0,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_apply_pending_balance(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            alice_meta.elgamal_keypair.secret(),
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // try to deposit over maximum allowed value
-    let illegal_amount = MAXIMUM_DEPOSIT_TRANSFER_AMOUNT.checked_add(1).unwrap();
-
-    token
-        .mint_to(
-            &alice_meta.token_account,
-            &mint_authority.pubkey(),
-            illegal_amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            illegal_amount,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MaximumDepositAmountExceeded as u32),
-            )
-        )))
-    );
-
-    // deposit maximum allowed value
-    token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            MAXIMUM_DEPOSIT_TRANSFER_AMOUNT,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // maximum pending balance credits exceeded
-    token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            0,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_deposit(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            1,
-            decimals,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(
-                    TokenError::MaximumPendingBalanceCreditCounterExceeded as u32
-                ),
-            )
-        )))
-    );
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(state.base.amount, 1);
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert_eq!(extension.pending_balance_credit_counter, 2.into());
-    assert_eq!(extension.expected_pending_balance_credit_counter, 2.into());
-    assert_eq!(extension.actual_pending_balance_credit_counter, 2.into());
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_withdraw() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(state.base.amount, 0);
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 42,
-                decryptable_available_balance: 42,
-            },
-        )
-        .await;
-
-    // withdraw zero amount
-    token
-        .confidential_transfer_withdraw(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            0,
-            decimals,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 42,
-                decryptable_available_balance: 42,
-            },
-        )
-        .await;
-
-    // withdraw entire balance
-    token
-        .confidential_transfer_withdraw(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            42,
-            decimals,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(state.base.amount, 42);
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    // attempt to withdraw without enough funds
-    let err = token
-        .confidential_transfer_withdraw(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            1,
-            decimals,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(err, TokenClientError::ProofGeneration);
-
-    token
-        .confidential_transfer_empty_account(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            None,
-            &alice_meta.elgamal_keypair,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_transfer() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, Some(2), false, false).await;
-
-    // Self-transfer of 0 tokens
-    token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            0,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            alice_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 42,
-                decryptable_available_balance: 42,
-            },
-        )
-        .await;
-
-    // Self-transfer of N tokens
-    token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            alice_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 42,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_apply_pending_balance(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            alice_meta.elgamal_keypair.secret(),
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 42,
-                decryptable_available_balance: 42,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 42,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_transfer(
-            &bob_meta.token_account,
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            None,
-            0,
-            None,
-            &bob_meta.elgamal_keypair,
-            &bob_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&bob],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_transfer(
-            &bob_meta.token_account,
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            None,
-            0,
-            None,
-            &bob_meta.elgamal_keypair,
-            &bob_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(
-                    TokenError::MaximumPendingBalanceCreditCounterExceeded as u32
-                ),
-            )
-        )))
-    );
-
-    token
-        .confidential_transfer_apply_pending_balance(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            None,
-            bob_meta.elgamal_keypair.secret(),
-            &bob_meta.aes_key,
-            &[&bob],
-        )
-        .await
-        .unwrap();
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 42,
-                decryptable_available_balance: 42,
-            },
-        )
-        .await;
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_transfer_with_fee() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        true,
-        &mint_authority,
-        100,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, true).await;
-
-    // Self-transfer of 0 tokens
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            0,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            alice_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 100,
-                decryptable_available_balance: 100,
-            },
-        )
-        .await;
-
-    // Self-transfers does not incur a fee
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            alice_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 100,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_apply_pending_balance(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            alice_meta.elgamal_keypair.secret(),
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 100,
-                decryptable_available_balance: 100,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_empty_account(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            None,
-            None,
-            &alice_meta.elgamal_keypair,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_empty_account(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            None,
-            None,
-            &bob_meta.elgamal_keypair,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::ConfidentialTransferAccountHasBalance as u32)
-            )
-        )))
-    );
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_apply_pending_balance(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            None,
-            bob_meta.elgamal_keypair.secret(),
-            &bob_meta.aes_key,
-            &[&bob],
-        )
-        .await
-        .unwrap();
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 97,
-                decryptable_available_balance: 97,
-            },
-        )
-        .await;
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_transfer_memo() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, true, false).await;
-
-    // transfer without memo
-    let err = token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoMemo as u32)
-            )
-        )))
-    );
-
-    // transfer with memo
-    token
-        .with_memo("🦖", vec![alice.pubkey()])
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 42,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_transfer_with_fee_and_memo() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        true,
-        &mint_authority,
-        100,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, true, true).await;
-
-    let err = token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoMemo as u32)
-            )
-        )))
-    );
-
-    token
-        .with_memo("🦖", vec![alice.pubkey()])
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-}
-
-#[tokio::test]
-async fn confidential_transfer_configure_token_account_with_proof_context() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = false;
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: None,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token, alice, bob, ..
-    } = context.token_context.unwrap();
-
-    let token_account_keypair = Keypair::new();
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &token_account_keypair,
-            &alice.pubkey(),
-            vec![ExtensionType::ConfidentialTransferAccount],
-        )
-        .await
-        .unwrap();
-    let token_account = token_account_keypair.pubkey();
-
-    let elgamal_keypair =
-        ElGamalKeypair::new_from_signer(&alice, &token_account.to_bytes()).unwrap();
-    let aes_key = AeKey::new_from_signer(&alice, &token_account.to_bytes()).unwrap();
-
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<PubkeyValidityProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyPubkeyValidity;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let proof_data =
-            confidential_transfer::instruction::PubkeyValidityData::new(&elgamal_keypair).unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    token
-        .confidential_transfer_configure_token_account(
-            &token_account,
-            &alice.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &elgamal_keypair,
-            &aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let elgamal_pubkey = (*elgamal_keypair.pubkey()).into();
-
-    let state = token.get_account_info(&token_account).await.unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    assert!(!bool::from(&extension.approved));
-    assert!(bool::from(&extension.allow_confidential_credits));
-    assert_eq!(extension.elgamal_pubkey, elgamal_pubkey);
-    assert_eq!(
-        aes_key
-            .decrypt(&(extension.decryptable_available_balance.try_into().unwrap()))
-            .unwrap(),
-        0
-    );
-
-    // attempt to create an account with a wrong proof type context state
-    let token_account_keypair = Keypair::new();
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &token_account_keypair,
-            &bob.pubkey(),
-            vec![ExtensionType::ConfidentialTransferAccount],
-        )
-        .await
-        .unwrap();
-    let token_account = token_account_keypair.pubkey();
-
-    let elgamal_keypair = ElGamalKeypair::new_from_signer(&bob, &token_account.to_bytes()).unwrap();
-    let aes_key = AeKey::new_from_signer(&bob, &token_account.to_bytes()).unwrap();
-
-    let context_state_account = Keypair::new();
-
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<ZeroBalanceProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyZeroBalance;
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let ciphertext = elgamal_keypair.pubkey().encrypt(0_u64);
-        let proof_data = confidential_transfer::instruction::ZeroBalanceProofData::new(
-            &elgamal_keypair,
-            &ciphertext,
-        )
-        .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    let err = token
-        .confidential_transfer_configure_token_account(
-            &token_account,
-            &bob.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &elgamal_keypair,
-            &aes_key,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidArgument,)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn confidential_transfer_empty_account_with_proof_context() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = false;
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: None,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token, alice, bob, ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new(&token, &alice, None, false, false).await;
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<ZeroBalanceProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyZeroBalance;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let proof_data = confidential_transfer::instruction::ZeroBalanceProofData::new(
-            &alice_meta.elgamal_keypair,
-            &ElGamalCiphertext::default(),
-        )
-        .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    token
-        .confidential_transfer_empty_account(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &alice_meta.elgamal_keypair,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // attempt to create an account with a wrong proof type context state
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, false).await;
-    let context_state_account = Keypair::new();
-
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<PubkeyValidityProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyPubkeyValidity;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let proof_data =
-            confidential_transfer::instruction::PubkeyValidityData::new(&bob_meta.elgamal_keypair)
-                .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    let err = token
-        .confidential_transfer_empty_account(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &bob_meta.elgamal_keypair,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidArgument,)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn confidential_transfer_withdraw_with_proof_context() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: None,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<WithdrawProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyWithdraw;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let state = token
-            .get_account_info(&alice_meta.token_account)
-            .await
-            .unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferAccount>()
-            .unwrap();
-        let current_ciphertext = extension.available_balance.try_into().unwrap();
-
-        let proof_data = confidential_transfer::instruction::WithdrawData::new(
-            0,
-            &alice_meta.elgamal_keypair,
-            42,
-            &current_ciphertext,
-        )
-        .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    token
-        .confidential_transfer_withdraw(
-            &alice_meta.token_account,
-            &alice.pubkey(),
-            Some(&context_state_account.pubkey()),
-            0,
-            decimals,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // attempt to create an account with a wrong proof type context state
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, false).await;
-    let context_state_account = Keypair::new();
-
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<PubkeyValidityProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyPubkeyValidity;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let proof_data =
-            confidential_transfer::instruction::PubkeyValidityData::new(&bob_meta.elgamal_keypair)
-                .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    let err = token
-        .confidential_transfer_withdraw(
-            &bob_meta.token_account,
-            &bob.pubkey(),
-            Some(&context_state_account.pubkey()),
-            0,
-            decimals,
-            None,
-            &bob_meta.elgamal_keypair,
-            &bob_meta.aes_key,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidArgument,)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn confidential_transfer_transfer_with_proof_context() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &bob,
-        None,
-        false,
-        false,
-        &mint_authority,
-        0,
-        decimals,
-    )
-    .await;
-
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<TransferProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyTransfer;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let state = token
-            .get_account_info(&alice_meta.token_account)
-            .await
-            .unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferAccount>()
-            .unwrap();
-        let current_available_balance = extension.available_balance.try_into().unwrap();
-
-        let proof_data = confidential_transfer::instruction::TransferData::new(
-            42,
-            (42, &current_available_balance),
-            &alice_meta.elgamal_keypair,
-            (
-                bob_meta.elgamal_keypair.pubkey(),
-                auditor_elgamal_keypair.pubkey(),
-            ),
-        )
-        .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            Some(&context_state_account.pubkey()),
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // attempt to create an account with a wrong proof type context state
-    let context_state_account = Keypair::new();
-
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<WithdrawProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyWithdraw;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let state = token
-            .get_account_info(&alice_meta.token_account)
-            .await
-            .unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferAccount>()
-            .unwrap();
-        let current_ciphertext = extension.available_balance.try_into().unwrap();
-
-        let proof_data = confidential_transfer::instruction::WithdrawData::new(
-            0,
-            &alice_meta.elgamal_keypair,
-            0,
-            &current_ciphertext,
-        )
-        .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let last_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            last_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    let err = token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            Some(&context_state_account.pubkey()),
-            0,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidArgument,)
-        )))
-    )
-}
-
-#[tokio::test]
-async fn confidential_transfer_transfer_with_split_proof_context() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &bob,
-        None,
-        false,
-        false,
-        &mint_authority,
-        0,
-        decimals,
-    )
-    .await;
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    let transfer_account_info = TransferAccountInfo::new(extension);
-
-    let (
-        equality_proof_data,
-        ciphertext_validity_proof_data,
-        range_proof_data,
-        source_decrypt_handles,
-    ) = transfer_account_info
-        .generate_split_transfer_proof_data(
-            42,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-        )
-        .unwrap();
-
-    let context_state_authority = Keypair::new();
-    let equality_proof_context_state_account = Keypair::new();
-    let ciphertext_validity_proof_context_state_account = Keypair::new();
-    let range_proof_context_state_account = Keypair::new();
-
-    let transfer_context_state_accounts = TransferSplitContextStateAccounts {
-        equality_proof: &equality_proof_context_state_account.pubkey(),
-        ciphertext_validity_proof: &ciphertext_validity_proof_context_state_account.pubkey(),
-        range_proof: &range_proof_context_state_account.pubkey(),
-        authority: &context_state_authority.pubkey(),
-        no_op_on_uninitialized_split_context_state: false,
-        close_split_context_state_accounts: None,
-    };
-
-    // create context state accounts
-    token
-        .create_equality_and_ciphertext_validity_proof_context_states_for_transfer(
-            transfer_context_state_accounts,
-            &equality_proof_data,
-            &ciphertext_validity_proof_data,
-            &[
-                &equality_proof_context_state_account,
-                &ciphertext_validity_proof_context_state_account,
-            ],
-        )
-        .await
-        .unwrap();
-
-    token
-        .create_range_proof_context_state_for_transfer(
-            transfer_context_state_accounts,
-            &range_proof_data,
-            &range_proof_context_state_account,
-        )
-        .await
-        .unwrap();
-
-    // create token22 confidential transfer instruction
-    token
-        .confidential_transfer_transfer_with_split_proofs(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            transfer_context_state_accounts,
-            42,
-            None,
-            &alice_meta.aes_key,
-            &source_decrypt_handles,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // close context state accounts
-    token
-        .confidential_transfer_close_context_state(
-            &equality_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &ciphertext_validity_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &range_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    // check balances
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 42,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-}
-
-#[tokio::test]
-async fn confidential_transfer_transfer_with_split_proof_contexts_in_parallel() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        42,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &bob,
-        None,
-        false,
-        false,
-        &mint_authority,
-        0,
-        decimals,
-    )
-    .await;
-
-    let context_state_authority = Keypair::new();
-    let equality_proof_context_state_account = Keypair::new();
-    let ciphertext_validity_proof_context_state_account = Keypair::new();
-    let range_proof_context_state_account = Keypair::new();
-
-    let lamport_destination = Pubkey::new_unique();
-
-    let close_split_context_state_accounts = CloseSplitContextStateAccounts {
-        lamport_destination: &lamport_destination,
-        zk_token_proof_program: &zk_token_proof_program::id(),
-    };
-
-    let transfer_context_state_accounts = TransferSplitContextStateAccounts {
-        equality_proof: &equality_proof_context_state_account.pubkey(),
-        ciphertext_validity_proof: &ciphertext_validity_proof_context_state_account.pubkey(),
-        range_proof: &range_proof_context_state_account.pubkey(),
-        authority: &context_state_authority.pubkey(),
-        no_op_on_uninitialized_split_context_state: true,
-        close_split_context_state_accounts: Some(close_split_context_state_accounts),
-    };
-
-    let equality_and_ciphertext_proof_signers = vec![
-        &alice,
-        &equality_proof_context_state_account,
-        &ciphertext_validity_proof_context_state_account,
-        &context_state_authority,
-    ];
-    let range_proof_signers = vec![
-        &alice,
-        &range_proof_context_state_account,
-        &context_state_authority,
-    ];
-    // With split proofs in parallel, one of the transactions does more work
-    // than the other, which isn't caught during the simulation to discover the
-    // compute unit limit.
-    let token = token.with_compute_unit_limit(ComputeUnitLimit::Static(500_000));
-    token
-        .confidential_transfer_transfer_with_split_proofs_in_parallel(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            transfer_context_state_accounts,
-            42,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            &equality_and_ciphertext_proof_signers,
-            &range_proof_signers,
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 42,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    let error = token
-        .get_account(equality_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(ciphertext_validity_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(range_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let lamport_destination = token.get_account(lamport_destination).await.unwrap();
-    assert!(lamport_destination.lamports > 0);
-}
-
-#[tokio::test]
-async fn confidential_transfer_transfer_with_fee_and_split_proof_context() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        true,
-        &mint_authority,
-        100,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, true).await;
-
-    let state = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferAccount>()
-        .unwrap();
-    let transfer_account_info = TransferAccountInfo::new(extension);
-
-    let current_source_available_balance =
-        transfer_account_info.available_balance.try_into().unwrap();
-    let current_decryptable_available_balance = transfer_account_info
-        .decryptable_available_balance
-        .try_into()
-        .unwrap();
-
-    let fee_parameters = FeeParameters {
-        fee_rate_basis_points: TEST_FEE_BASIS_POINTS,
-        maximum_fee: TEST_MAXIMUM_FEE,
-    };
-
-    let (
-        equality_proof_data,
-        transfer_amount_ciphertext_validity_proof_data,
-        fee_sigma_proof_data,
-        fee_ciphertext_validity_proof_data,
-        range_proof_data,
-        source_decrypt_handles,
-    ) = transfer_with_fee_split_proof_data(
-        &current_source_available_balance,
-        &current_decryptable_available_balance,
-        100,
-        &alice_meta.elgamal_keypair,
-        &alice_meta.aes_key,
-        bob_meta.elgamal_keypair.pubkey(),
-        Some(auditor_elgamal_keypair.pubkey()),
-        withdraw_withheld_authority_elgamal_keypair.pubkey(),
-        &fee_parameters,
-    )
-    .unwrap();
-
-    let context_state_authority = Keypair::new();
-    let equality_proof_context_state_account = Keypair::new();
-    let transfer_amount_ciphertext_validity_proof_context_state_account = Keypair::new();
-    let fee_sigma_proof_context_state_account = Keypair::new();
-    let fee_ciphertext_validity_proof_context_state_account = Keypair::new();
-    let range_proof_context_state_account = Keypair::new();
-
-    let transfer_context_state_accounts = TransferWithFeeSplitContextStateAccounts {
-        equality_proof: &equality_proof_context_state_account.pubkey(),
-        transfer_amount_ciphertext_validity_proof:
-            &transfer_amount_ciphertext_validity_proof_context_state_account.pubkey(),
-        fee_sigma_proof: &fee_sigma_proof_context_state_account.pubkey(),
-        fee_ciphertext_validity_proof: &fee_ciphertext_validity_proof_context_state_account
-            .pubkey(),
-        range_proof: &range_proof_context_state_account.pubkey(),
-        authority: &context_state_authority.pubkey(),
-        no_op_on_uninitialized_split_context_state: false,
-        close_split_context_state_accounts: None,
-    };
-
-    // create context state accounts
-    token
-        .create_equality_and_ciphertext_validity_proof_context_states_for_transfer_with_fee(
-            transfer_context_state_accounts,
-            &equality_proof_data,
-            &transfer_amount_ciphertext_validity_proof_data,
-            &[
-                &equality_proof_context_state_account,
-                &transfer_amount_ciphertext_validity_proof_context_state_account,
-            ],
-        )
-        .await
-        .unwrap();
-
-    token
-        .create_fee_sigma_and_ciphertext_validity_proof_context_states_for_transfer_with_fee(
-            transfer_context_state_accounts,
-            &fee_sigma_proof_data,
-            &fee_ciphertext_validity_proof_data,
-            &[
-                &fee_sigma_proof_context_state_account,
-                &fee_ciphertext_validity_proof_context_state_account,
-            ],
-        )
-        .await
-        .unwrap();
-
-    token
-        .create_range_proof_context_state_for_transfer_with_fee(
-            transfer_context_state_accounts,
-            &range_proof_data,
-            &[&range_proof_context_state_account],
-        )
-        .await
-        .unwrap();
-
-    // create token22 confidential transfer instruction
-    token
-        .confidential_transfer_transfer_with_fee_and_split_proofs(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            transfer_context_state_accounts,
-            100,
-            None,
-            &alice_meta.aes_key,
-            &source_decrypt_handles,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // close context state accounts
-    token
-        .confidential_transfer_close_context_state(
-            &equality_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &transfer_amount_ciphertext_validity_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &fee_sigma_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &fee_ciphertext_validity_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_close_context_state(
-            &range_proof_context_state_account.pubkey(),
-            &alice_meta.token_account,
-            &context_state_authority.pubkey(),
-            &[&context_state_authority],
-        )
-        .await
-        .unwrap();
-
-    // check balances
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-}
-
-#[tokio::test]
-async fn confidential_transfer_transfer_with_fee_and_split_proof_context_in_parallel() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        true,
-        &mint_authority,
-        100,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, None, false, true).await;
-
-    let context_state_authority = Keypair::new();
-    let equality_proof_context_state_account = Keypair::new();
-    let transfer_amount_ciphertext_validity_proof_context_state_account = Keypair::new();
-    let fee_sigma_proof_context_state_account = Keypair::new();
-    let fee_ciphertext_validity_proof_context_state_account = Keypair::new();
-    let range_proof_context_state_account = Keypair::new();
-
-    let lamport_destination = Pubkey::new_unique();
-
-    let close_split_context_state_accounts = CloseSplitContextStateAccounts {
-        lamport_destination: &lamport_destination,
-        zk_token_proof_program: &zk_token_proof_program::id(),
-    };
-
-    let transfer_context_state_accounts = TransferWithFeeSplitContextStateAccounts {
-        equality_proof: &equality_proof_context_state_account.pubkey(),
-        transfer_amount_ciphertext_validity_proof:
-            &transfer_amount_ciphertext_validity_proof_context_state_account.pubkey(),
-        fee_sigma_proof: &fee_sigma_proof_context_state_account.pubkey(),
-        fee_ciphertext_validity_proof: &fee_ciphertext_validity_proof_context_state_account
-            .pubkey(),
-        range_proof: &range_proof_context_state_account.pubkey(),
-        authority: &context_state_authority.pubkey(),
-        no_op_on_uninitialized_split_context_state: true,
-        close_split_context_state_accounts: Some(close_split_context_state_accounts),
-    };
-
-    let equality_and_ciphertext_proof_signers = vec![
-        &alice,
-        &equality_proof_context_state_account,
-        &transfer_amount_ciphertext_validity_proof_context_state_account,
-        &context_state_authority,
-    ];
-    let fee_sigma_proof_signers = vec![
-        &alice,
-        &fee_sigma_proof_context_state_account,
-        &fee_ciphertext_validity_proof_context_state_account,
-        &context_state_authority,
-    ];
-    let range_proof_signers = vec![
-        &alice,
-        &range_proof_context_state_account,
-        &context_state_authority,
-    ];
-    // With split proofs in parallel, one of the transactions does more work
-    // than the other, which isn't caught during the simulation to discover the
-    // compute unit limit.
-    let token = token.with_compute_unit_limit(ComputeUnitLimit::Static(500_000));
-    token
-        .confidential_transfer_transfer_with_fee_and_split_proofs_in_parallel(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            transfer_context_state_accounts,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            TEST_FEE_BASIS_POINTS,
-            TEST_MAXIMUM_FEE,
-            &equality_and_ciphertext_proof_signers,
-            &fee_sigma_proof_signers,
-            &range_proof_signers,
-        )
-        .await
-        .unwrap();
-
-    // check balances
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    let error = token
-        .get_account(equality_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(transfer_amount_ciphertext_validity_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(fee_sigma_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(fee_ciphertext_validity_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let error = token
-        .get_account(range_proof_context_state_account.pubkey())
-        .await
-        .unwrap_err();
-    assert_eq!(error, TokenClientError::AccountNotFound);
-
-    let lamport_destination = token.get_account(lamport_destination).await.unwrap();
-    assert!(lamport_destination.lamports > 0);
-}
diff --git a/token/program-2022-test/tests/confidential_transfer_fee.rs b/token/program-2022-test/tests/confidential_transfer_fee.rs
deleted file mode 100644
index f45a4f259f4..00000000000
--- a/token/program-2022-test/tests/confidential_transfer_fee.rs
+++ /dev/null
@@ -1,1238 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            confidential_transfer::{ConfidentialTransferAccount, ConfidentialTransferMint},
-            confidential_transfer_fee::{
-                account_info::WithheldTokensInfo, ConfidentialTransferFeeAmount,
-                ConfidentialTransferFeeConfig,
-            },
-            transfer_fee::TransferFee,
-            BaseStateWithExtensions, ExtensionType,
-        },
-        instruction,
-        solana_zk_token_sdk::{
-            encryption::{auth_encryption::*, elgamal::*},
-            zk_token_elgamal::pod::{self, Zeroable},
-            zk_token_proof_instruction::*,
-            zk_token_proof_program,
-            zk_token_proof_state::ProofContextState,
-        },
-    },
-    spl_token_client::{
-        client::{SendTransaction, SimulateTransaction},
-        token::{ExtensionInitializationParams, Token, TokenError as TokenClientError},
-    },
-    std::{convert::TryInto, mem::size_of},
-};
-
-#[cfg(feature = "zk-ops")]
-const TEST_MAXIMUM_FEE: u64 = 100;
-#[cfg(feature = "zk-ops")]
-const TEST_FEE_BASIS_POINTS: u16 = 250;
-
-struct ConfidentialTokenAccountMeta {
-    token_account: Pubkey,
-    elgamal_keypair: ElGamalKeypair,
-    aes_key: AeKey,
-}
-
-impl ConfidentialTokenAccountMeta {
-    async fn new<T>(
-        token: &Token<T>,
-        owner: &Keypair,
-        mint_authority: &Keypair,
-        amount: u64,
-        decimals: u8,
-    ) -> Self
-    where
-        T: SendTransaction + SimulateTransaction,
-    {
-        let token_account_keypair = Keypair::new();
-        let extensions = vec![
-            ExtensionType::ConfidentialTransferAccount,
-            ExtensionType::ConfidentialTransferFeeAmount,
-        ];
-
-        token
-            .create_auxiliary_token_account_with_extension_space(
-                &token_account_keypair,
-                &owner.pubkey(),
-                extensions,
-            )
-            .await
-            .unwrap();
-        let token_account = token_account_keypair.pubkey();
-
-        let elgamal_keypair =
-            ElGamalKeypair::new_from_signer(owner, &token_account.to_bytes()).unwrap();
-        let aes_key = AeKey::new_from_signer(owner, &token_account.to_bytes()).unwrap();
-
-        token
-            .confidential_transfer_configure_token_account(
-                &token_account,
-                &owner.pubkey(),
-                None,
-                None,
-                &elgamal_keypair,
-                &aes_key,
-                &[owner],
-            )
-            .await
-            .unwrap();
-
-        token
-            .mint_to(
-                &token_account,
-                &mint_authority.pubkey(),
-                amount,
-                &[mint_authority],
-            )
-            .await
-            .unwrap();
-
-        token
-            .confidential_transfer_deposit(
-                &token_account,
-                &owner.pubkey(),
-                amount,
-                decimals,
-                &[owner],
-            )
-            .await
-            .unwrap();
-
-        token
-            .confidential_transfer_apply_pending_balance(
-                &token_account,
-                &owner.pubkey(),
-                None,
-                elgamal_keypair.secret(),
-                &aes_key,
-                &[owner],
-            )
-            .await
-            .unwrap();
-
-        Self {
-            token_account,
-            elgamal_keypair,
-            aes_key,
-        }
-    }
-
-    #[cfg(feature = "zk-ops")]
-    async fn check_balances<T>(&self, token: &Token<T>, expected: ConfidentialTokenAccountBalances)
-    where
-        T: SendTransaction + SimulateTransaction,
-    {
-        let state = token.get_account_info(&self.token_account).await.unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferAccount>()
-            .unwrap();
-
-        assert_eq!(
-            extension
-                .pending_balance_lo
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.pending_balance_lo,
-        );
-        assert_eq!(
-            extension
-                .pending_balance_hi
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.pending_balance_hi,
-        );
-        assert_eq!(
-            extension
-                .available_balance
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.available_balance,
-        );
-        assert_eq!(
-            self.aes_key
-                .decrypt(&extension.decryptable_available_balance.try_into().unwrap())
-                .unwrap(),
-            expected.decryptable_available_balance,
-        );
-    }
-}
-
-#[cfg(feature = "zk-ops")]
-struct ConfidentialTokenAccountBalances {
-    pending_balance_lo: u64,
-    pending_balance_hi: u64,
-    available_balance: u64,
-    decryptable_available_balance: u64,
-}
-
-#[cfg(feature = "zk-ops")]
-async fn check_withheld_amount_in_mint<T>(
-    token: &Token<T>,
-    withdraw_withheld_authority_elgamal_keypair: &ElGamalKeypair,
-    expected: u64,
-) where
-    T: SendTransaction + SimulateTransaction,
-{
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferFeeConfig>()
-        .unwrap();
-    let decrypted_amount = extension
-        .withheld_amount
-        .decrypt(withdraw_withheld_authority_elgamal_keypair.secret())
-        .unwrap();
-    assert_eq!(decrypted_amount, expected);
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_fee_config() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-
-    // Try invalid combinations of extensions
-    let err = context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                3,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32),
-            )
-        )))
-    );
-
-    let err = context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                3,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32),
-            )
-        )))
-    );
-
-    let err = context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32),
-            )
-        )))
-    );
-
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn confidential_transfer_initialize_and_update_mint() {
-    let authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext { token, .. } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
-
-    assert_eq!(
-        extension.authority,
-        Some(authority.pubkey()).try_into().unwrap()
-    );
-    assert_eq!(
-        extension.auto_approve_new_accounts,
-        auto_approve_new_accounts.into()
-    );
-    assert_eq!(
-        extension.auditor_elgamal_pubkey,
-        Some(auditor_elgamal_pubkey).try_into().unwrap()
-    );
-
-    // Change the authority
-    let new_authority = Keypair::new();
-    let wrong_keypair = Keypair::new();
-
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong_keypair.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::ConfidentialTransferMint,
-            &[&wrong_keypair],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    token
-        .set_authority(
-            token.get_address(),
-            &authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::ConfidentialTransferMint,
-            &[&authority],
-        )
-        .await
-        .unwrap();
-
-    // New authority can change mint parameters while the old cannot
-    let new_auto_approve_new_accounts = false;
-    let new_auditor_elgamal_pubkey = None;
-
-    let err = token
-        .confidential_transfer_update_mint(
-            &authority.pubkey(),
-            new_auto_approve_new_accounts,
-            new_auditor_elgamal_pubkey,
-            &[&authority],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    token
-        .confidential_transfer_update_mint(
-            &new_authority.pubkey(),
-            new_auto_approve_new_accounts,
-            new_auditor_elgamal_pubkey,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
-    assert_eq!(
-        extension.authority,
-        Some(new_authority.pubkey()).try_into().unwrap()
-    );
-    assert_eq!(
-        extension.auto_approve_new_accounts,
-        new_auto_approve_new_accounts.try_into().unwrap(),
-    );
-    assert_eq!(
-        extension.auditor_elgamal_pubkey,
-        new_auditor_elgamal_pubkey.try_into().unwrap(),
-    );
-
-    // Set new authority to None
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::ConfidentialTransferMint,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
-    assert_eq!(extension.authority, None.try_into().unwrap());
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_withdraw_withheld_tokens_from_mint() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta =
-        ConfidentialTokenAccountMeta::new(&token, &alice, &mint_authority, 100, decimals).await;
-    let bob_meta =
-        ConfidentialTokenAccountMeta::new(&token, &bob, &mint_authority, 0, decimals).await;
-
-    let transfer_fee_parameters = TransferFee {
-        epoch: 0.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-    };
-
-    // Test fee is 2.5% so the withheld fees should be 3
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            transfer_fee_parameters.transfer_fee_basis_points.into(),
-            transfer_fee_parameters.maximum_fee.into(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let new_decryptable_available_balance = alice_meta.aes_key.encrypt(0);
-    token
-        .confidential_transfer_withdraw_withheld_tokens_from_mint(
-            &alice_meta.token_account,
-            &withdraw_withheld_authority.pubkey(),
-            None,
-            None,
-            &withdraw_withheld_authority_elgamal_keypair,
-            alice_meta.elgamal_keypair.pubkey(),
-            &new_decryptable_available_balance.into(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-
-    // withheld fees are not harvested to mint yet
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    token
-        .confidential_transfer_harvest_withheld_tokens_to_mint(&[&bob_meta.token_account])
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, pod::ElGamalCiphertext::zeroed());
-
-    // calculate and encrypt fee to attach to the `WithdrawWithheldTokensFromMint`
-    // instruction data
-    let fee = transfer_fee_parameters.calculate_fee(100).unwrap();
-    let new_decryptable_available_balance = alice_meta.aes_key.encrypt(fee);
-
-    check_withheld_amount_in_mint(&token, &withdraw_withheld_authority_elgamal_keypair, fee).await;
-
-    token
-        .confidential_transfer_withdraw_withheld_tokens_from_mint(
-            &alice_meta.token_account,
-            &withdraw_withheld_authority.pubkey(),
-            None,
-            None,
-            &withdraw_withheld_authority_elgamal_keypair,
-            alice_meta.elgamal_keypair.pubkey(),
-            &new_decryptable_available_balance.into(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-
-    // withheld fees are withdrawn back to alice's account
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 3,
-                decryptable_available_balance: 3,
-            },
-        )
-        .await;
-
-    check_withheld_amount_in_mint(&token, &withdraw_withheld_authority_elgamal_keypair, 0).await;
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_withdraw_withheld_tokens_from_accounts() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta =
-        ConfidentialTokenAccountMeta::new(&token, &alice, &mint_authority, 100, decimals).await;
-    let bob_meta =
-        ConfidentialTokenAccountMeta::new(&token, &bob, &mint_authority, 0, decimals).await;
-
-    let transfer_fee_parameters = TransferFee {
-        epoch: 0.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-    };
-
-    // Test fee is 2.5% so the withheld fees should be 3
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            transfer_fee_parameters.transfer_fee_basis_points.into(),
-            transfer_fee_parameters.maximum_fee.into(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let fee = transfer_fee_parameters.calculate_fee(100).unwrap();
-    let new_decryptable_available_balance = alice_meta.aes_key.encrypt(fee);
-    token
-        .confidential_transfer_withdraw_withheld_tokens_from_accounts(
-            &alice_meta.token_account,
-            &withdraw_withheld_authority.pubkey(),
-            None,
-            None,
-            &withdraw_withheld_authority_elgamal_keypair,
-            alice_meta.elgamal_keypair.pubkey(),
-            &new_decryptable_available_balance.into(),
-            &[&bob_meta.token_account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: fee,
-                decryptable_available_balance: fee,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, pod::ElGamalCiphertext::zeroed());
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_withdraw_withheld_tokens_from_mint_with_proof_context() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta =
-        ConfidentialTokenAccountMeta::new(&token, &alice, &mint_authority, 100, decimals).await;
-    let bob_meta =
-        ConfidentialTokenAccountMeta::new(&token, &bob, &mint_authority, 0, decimals).await;
-
-    let transfer_fee_parameters = TransferFee {
-        epoch: 0.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-    };
-
-    // Test fee is 2.5% so the withheld fees should be 3
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            transfer_fee_parameters.transfer_fee_basis_points.into(),
-            transfer_fee_parameters.maximum_fee.into(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    token
-        .confidential_transfer_harvest_withheld_tokens_to_mint(&[&bob_meta.token_account])
-        .await
-        .unwrap();
-
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<CiphertextCiphertextEqualityProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyCiphertextCiphertextEquality;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let state = token.get_mint_info().await.unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferFeeConfig>()
-            .unwrap();
-        let withheld_tokens_info = WithheldTokensInfo::new(&extension.withheld_amount);
-
-        let proof_data = withheld_tokens_info
-            .generate_proof_data(
-                &withdraw_withheld_authority_elgamal_keypair,
-                alice_meta.elgamal_keypair.pubkey(),
-            )
-            .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let recent_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            recent_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    // calculate and encrypt fee to attach to the `WithdrawWithheldTokensFromMint`
-    // instruction data
-    let fee = transfer_fee_parameters.calculate_fee(100).unwrap();
-    let new_decryptable_available_balance = alice_meta.aes_key.encrypt(fee);
-    token
-        .confidential_transfer_withdraw_withheld_tokens_from_mint(
-            &alice_meta.token_account,
-            &withdraw_withheld_authority.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &withdraw_withheld_authority_elgamal_keypair,
-            alice_meta.elgamal_keypair.pubkey(),
-            &new_decryptable_available_balance.into(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-
-    // withheld fees are withdrawn back to alice's account
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 3,
-                decryptable_available_balance: 3,
-            },
-        )
-        .await;
-
-    check_withheld_amount_in_mint(&token, &withdraw_withheld_authority_elgamal_keypair, 0).await;
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_withdraw_withheld_tokens_from_accounts_with_proof_context() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta =
-        ConfidentialTokenAccountMeta::new(&token, &alice, &mint_authority, 100, decimals).await;
-    let bob_meta =
-        ConfidentialTokenAccountMeta::new(&token, &bob, &mint_authority, 0, decimals).await;
-
-    let transfer_fee_parameters = TransferFee {
-        epoch: 0.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-    };
-
-    // Test fee is 2.5% so the withheld fees should be 3
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            transfer_fee_parameters.transfer_fee_basis_points.into(),
-            transfer_fee_parameters.maximum_fee.into(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let context_state_account = Keypair::new();
-
-    // create context state
-    {
-        let context_state_authority = Keypair::new();
-        let space = size_of::<ProofContextState<CiphertextCiphertextEqualityProofContext>>();
-
-        let instruction_type = ProofInstruction::VerifyCiphertextCiphertextEquality;
-
-        let context_state_info = ContextStateInfo {
-            context_state_account: &context_state_account.pubkey(),
-            context_state_authority: &context_state_authority.pubkey(),
-        };
-
-        let state = token
-            .get_account_info(&bob_meta.token_account)
-            .await
-            .unwrap();
-        let withheld_amount = state
-            .get_extension::<ConfidentialTransferFeeAmount>()
-            .unwrap()
-            .withheld_amount;
-        let withheld_tokens_info = WithheldTokensInfo::new(&withheld_amount);
-
-        let proof_data = withheld_tokens_info
-            .generate_proof_data(
-                &withdraw_withheld_authority_elgamal_keypair,
-                alice_meta.elgamal_keypair.pubkey(),
-            )
-            .unwrap();
-
-        let mut ctx = context.context.lock().await;
-        let rent = ctx.banks_client.get_rent().await.unwrap();
-
-        let instructions = vec![
-            system_instruction::create_account(
-                &ctx.payer.pubkey(),
-                &context_state_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                &zk_token_proof_program::id(),
-            ),
-            instruction_type.encode_verify_proof(Some(context_state_info), &proof_data),
-        ];
-
-        let recent_blockhash = ctx.get_new_latest_blockhash().await.unwrap();
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &context_state_account],
-            recent_blockhash,
-        );
-        ctx.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    let fee = transfer_fee_parameters.calculate_fee(100).unwrap();
-    let new_decryptable_available_balance = alice_meta.aes_key.encrypt(fee);
-    token
-        .confidential_transfer_withdraw_withheld_tokens_from_accounts(
-            &alice_meta.token_account,
-            &withdraw_withheld_authority.pubkey(),
-            Some(&context_state_account.pubkey()),
-            None,
-            &withdraw_withheld_authority_elgamal_keypair,
-            alice_meta.elgamal_keypair.pubkey(),
-            &new_decryptable_available_balance.into(),
-            &[&bob_meta.token_account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: fee,
-                decryptable_available_balance: fee,
-            },
-        )
-        .await;
-
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 97,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, pod::ElGamalCiphertext::zeroed());
-}
-
-#[cfg(feature = "zk-ops")]
-#[tokio::test]
-async fn confidential_transfer_harvest_withheld_tokens_to_mint() {
-    let transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let confidential_transfer_authority = Keypair::new();
-    let auto_approve_new_accounts = true;
-    let auditor_elgamal_keypair = ElGamalKeypair::new_rand();
-    let auditor_elgamal_pubkey = (*auditor_elgamal_keypair.pubkey()).into();
-
-    let confidential_transfer_fee_authority = Keypair::new();
-    let withdraw_withheld_authority_elgamal_keypair = ElGamalKeypair::new_rand();
-    let withdraw_withheld_authority_elgamal_pubkey =
-        (*withdraw_withheld_authority_elgamal_keypair.pubkey()).into();
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: Some(transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-                transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-                maximum_fee: TEST_MAXIMUM_FEE,
-            },
-            ExtensionInitializationParams::ConfidentialTransferMint {
-                authority: Some(confidential_transfer_authority.pubkey()),
-                auto_approve_new_accounts,
-                auditor_elgamal_pubkey: Some(auditor_elgamal_pubkey),
-            },
-            ExtensionInitializationParams::ConfidentialTransferFeeConfig {
-                authority: Some(confidential_transfer_fee_authority.pubkey()),
-                withdraw_withheld_authority_elgamal_pubkey,
-            },
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_meta =
-        ConfidentialTokenAccountMeta::new(&token, &alice, &mint_authority, 100, decimals).await;
-    let bob_meta =
-        ConfidentialTokenAccountMeta::new(&token, &bob, &mint_authority, 0, decimals).await;
-
-    let transfer_fee_parameters = TransferFee {
-        epoch: 0.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-    };
-
-    // there are no withheld fees in bob's account yet, but try harvesting
-    token
-        .confidential_transfer_harvest_withheld_tokens_to_mint(&[&bob_meta.token_account])
-        .await
-        .unwrap();
-
-    // Test fee is 2.5% so the withheld fees should be 3
-    token
-        .confidential_transfer_transfer_with_fee(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            100,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            Some(auditor_elgamal_keypair.pubkey()),
-            withdraw_withheld_authority_elgamal_keypair.pubkey(),
-            transfer_fee_parameters.transfer_fee_basis_points.into(),
-            transfer_fee_parameters.maximum_fee.into(),
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // disable harvest withheld tokens to mint
-    token
-        .confidential_transfer_disable_harvest_to_mint(
-            &confidential_transfer_fee_authority.pubkey(),
-            &[&confidential_transfer_fee_authority],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .confidential_transfer_harvest_withheld_tokens_to_mint(&[&bob_meta.token_account])
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::HarvestToMintDisabled as u32),
-            )
-        )))
-    );
-
-    // enable harvest withheld tokens to mint
-    token
-        .confidential_transfer_enable_harvest_to_mint(
-            &confidential_transfer_fee_authority.pubkey(),
-            &[&confidential_transfer_fee_authority],
-        )
-        .await
-        .unwrap();
-
-    // Refresh the blockhash since we're doing the same thing twice in a row
-    token.get_new_latest_blockhash().await.unwrap();
-    token
-        .confidential_transfer_harvest_withheld_tokens_to_mint(&[&bob_meta.token_account])
-        .await
-        .unwrap();
-
-    let state = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    let extension = state
-        .get_extension::<ConfidentialTransferFeeAmount>()
-        .unwrap();
-    assert_eq!(extension.withheld_amount, pod::ElGamalCiphertext::zeroed());
-
-    // calculate and encrypt fee to attach to the `WithdrawWithheldTokensFromMint`
-    // instruction data
-    let fee = transfer_fee_parameters.calculate_fee(100).unwrap();
-
-    check_withheld_amount_in_mint(&token, &withdraw_withheld_authority_elgamal_keypair, fee).await;
-}
diff --git a/token/program-2022-test/tests/cpi_guard.rs b/token/program-2022-test/tests/cpi_guard.rs
deleted file mode 100644
index 5a6591afb12..00000000000
--- a/token/program-2022-test/tests/cpi_guard.rs
+++ /dev/null
@@ -1,793 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{keypair_clone, TestContext, TokenContext},
-    solana_program_test::{
-        processor,
-        tokio::{self, sync::Mutex},
-        ProgramTest,
-    },
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_instruction_padding::instruction::wrap_instruction,
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            cpi_guard::{self, CpiGuard},
-            BaseStateWithExtensions, ExtensionType,
-        },
-        instruction::{self, AuthorityType},
-        processor::Processor as SplToken2022Processor,
-    },
-    spl_token_client::{
-        client::ProgramBanksClientProcessTransaction,
-        token::{Token, TokenError as TokenClientError},
-    },
-    std::sync::Arc,
-};
-
-// set up a bank and bank client with spl token 2022 and the instruction padder
-// also creates a token with no extensions and inits two token accounts
-async fn make_context() -> TestContext {
-    // TODO this may be removed when we upgrade to a solana version with a fixed
-    // `get_stack_height()` stub
-    if std::env::var("BPF_OUT_DIR").is_err() && std::env::var("SBF_OUT_DIR").is_err() {
-        panic!("CpiGuard tests MUST be invoked with `cargo test-sbf`, NOT `cargo test --feature test-sbf`. \
-                In a non-BPF context, `get_stack_height()` always returns 0, and all tests WILL fail.");
-    }
-
-    let mut program_test = ProgramTest::new(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(SplToken2022Processor::process),
-    );
-
-    program_test.add_program(
-        "spl_instruction_padding",
-        spl_instruction_padding::id(),
-        processor!(spl_instruction_padding::processor::process),
-    );
-
-    let program_context = program_test.start_with_context().await;
-    let program_context = Arc::new(Mutex::new(program_context));
-
-    let mut test_context = TestContext {
-        context: program_context,
-        token_context: None,
-    };
-
-    test_context.init_token_with_mint(vec![]).await.unwrap();
-    let token_context = test_context.token_context.as_ref().unwrap();
-
-    token_context
-        .token
-        .create_auxiliary_token_account_with_extension_space(
-            &token_context.alice,
-            &token_context.alice.pubkey(),
-            vec![ExtensionType::CpiGuard],
-        )
-        .await
-        .unwrap();
-
-    token_context
-        .token
-        .create_auxiliary_token_account(&token_context.bob, &token_context.bob.pubkey())
-        .await
-        .unwrap();
-
-    test_context
-}
-
-fn client_error(token_error: TokenError) -> TokenClientError {
-    TokenClientError::Client(Box::new(TransportError::TransactionError(
-        TransactionError::InstructionError(0, InstructionError::Custom(token_error as u32)),
-    )))
-}
-
-#[tokio::test]
-async fn test_cpi_guard_enable_disable() {
-    let context = make_context().await;
-    let TokenContext {
-        token, alice, bob, ..
-    } = context.token_context.unwrap();
-
-    // enable guard properly
-    token
-        .enable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-        .await
-        .unwrap();
-
-    // guard is enabled
-    let alice_state = token.get_account_info(&alice.pubkey()).await.unwrap();
-    let extension = alice_state.get_extension::<CpiGuard>().unwrap();
-    assert!(bool::from(extension.lock_cpi));
-
-    // attempt to disable through cpi. this fails
-    let error = token
-        .process_ixs(
-            &[wrap_instruction(
-                spl_instruction_padding::id(),
-                cpi_guard::instruction::disable_cpi_guard(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    &alice.pubkey(),
-                    &[],
-                )
-                .unwrap(),
-                vec![],
-                0,
-            )
-            .unwrap()],
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(error, client_error(TokenError::CpiGuardSettingsLocked));
-
-    // guard remains enabled
-    let alice_state = token.get_account_info(&alice.pubkey()).await.unwrap();
-    let extension = alice_state.get_extension::<CpiGuard>().unwrap();
-    assert!(bool::from(extension.lock_cpi));
-
-    // disable guard properly
-    token
-        .disable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-        .await
-        .unwrap();
-
-    // guard is disabled
-    let alice_state = token.get_account_info(&alice.pubkey()).await.unwrap();
-    let extension = alice_state.get_extension::<CpiGuard>().unwrap();
-    assert!(!bool::from(extension.lock_cpi));
-
-    // attempt to enable through cpi. this fails
-    let error = token
-        .process_ixs(
-            &[wrap_instruction(
-                spl_instruction_padding::id(),
-                cpi_guard::instruction::enable_cpi_guard(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    &alice.pubkey(),
-                    &[],
-                )
-                .unwrap(),
-                vec![],
-                0,
-            )
-            .unwrap()],
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(error, client_error(TokenError::CpiGuardSettingsLocked));
-
-    // guard remains disabled
-    let alice_state = token.get_account_info(&alice.pubkey()).await.unwrap();
-    let extension = alice_state.get_extension::<CpiGuard>().unwrap();
-    assert!(!bool::from(extension.lock_cpi));
-
-    // enable works with realloc
-    token
-        .reallocate(
-            &bob.pubkey(),
-            &bob.pubkey(),
-            &[ExtensionType::CpiGuard],
-            &[&bob],
-        )
-        .await
-        .unwrap();
-
-    token
-        .enable_cpi_guard(&bob.pubkey(), &bob.pubkey(), &[&bob])
-        .await
-        .unwrap();
-
-    let bob_state = token.get_account_info(&bob.pubkey()).await.unwrap();
-    let extension = bob_state.get_extension::<CpiGuard>().unwrap();
-    assert!(bool::from(extension.lock_cpi));
-}
-
-#[tokio::test]
-async fn test_cpi_guard_transfer() {
-    let context = make_context().await;
-    let TokenContext {
-        token,
-        token_unchecked,
-        mint_authority,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let mk_transfer = |authority, do_checked| {
-        wrap_instruction(
-            spl_instruction_padding::id(),
-            if do_checked {
-                instruction::transfer_checked(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    token.get_address(),
-                    &bob.pubkey(),
-                    &authority,
-                    &[],
-                    1,
-                    9,
-                )
-                .unwrap()
-            } else {
-                #[allow(deprecated)]
-                instruction::transfer(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    &bob.pubkey(),
-                    &authority,
-                    &[],
-                    1,
-                )
-                .unwrap()
-            },
-            vec![],
-            0,
-        )
-        .unwrap()
-    };
-
-    let mut amount = 100;
-    token
-        .mint_to(
-            &alice.pubkey(),
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    for do_checked in [true, false] {
-        let token_obj = if do_checked { &token } else { &token_unchecked };
-        token_obj
-            .enable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        // transfer works normally with cpi guard enabled
-        token_obj
-            .transfer(
-                &alice.pubkey(),
-                &bob.pubkey(),
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // user-auth cpi transfer with cpi guard doesn't work
-        let error = token_obj
-            .process_ixs(&[mk_transfer(alice.pubkey(), do_checked)], &[&alice])
-            .await
-            .unwrap_err();
-        assert_eq!(error, client_error(TokenError::CpiGuardTransferBlocked));
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // delegate-auth cpi transfer to self does not work
-        token_obj
-            .approve(
-                &alice.pubkey(),
-                &alice.pubkey(),
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-
-        let error = token_obj
-            .process_ixs(&[mk_transfer(alice.pubkey(), do_checked)], &[&alice])
-            .await
-            .unwrap_err();
-        assert_eq!(error, client_error(TokenError::CpiGuardTransferBlocked));
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // delegate-auth cpi transfer with cpi guard works
-        token_obj
-            .approve(
-                &alice.pubkey(),
-                &bob.pubkey(),
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-
-        token_obj
-            .process_ixs(&[mk_transfer(bob.pubkey(), do_checked)], &[&bob])
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // transfer still works through cpi with cpi guard off
-        token_obj
-            .disable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        token_obj
-            .process_ixs(&[mk_transfer(alice.pubkey(), do_checked)], &[&alice])
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-    }
-}
-
-#[tokio::test]
-async fn test_cpi_guard_burn() {
-    let context = make_context().await;
-    let TokenContext {
-        token,
-        token_unchecked,
-        mint_authority,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let mk_burn = |authority, do_checked| {
-        wrap_instruction(
-            spl_instruction_padding::id(),
-            if do_checked {
-                instruction::burn_checked(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    token.get_address(),
-                    &authority,
-                    &[],
-                    1,
-                    9,
-                )
-                .unwrap()
-            } else {
-                instruction::burn(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    token.get_address(),
-                    &authority,
-                    &[],
-                    1,
-                )
-                .unwrap()
-            },
-            vec![],
-            0,
-        )
-        .unwrap()
-    };
-
-    let mut amount = 100;
-    token
-        .mint_to(
-            &alice.pubkey(),
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    for do_checked in [true, false] {
-        let token_obj = if do_checked { &token } else { &token_unchecked };
-        token_obj
-            .enable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        // burn works normally with cpi guard enabled
-        token_obj
-            .burn(&alice.pubkey(), &alice.pubkey(), 1, &[&alice])
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // user-auth cpi burn with cpi guard doesn't work
-        let error = token_obj
-            .process_ixs(&[mk_burn(alice.pubkey(), do_checked)], &[&alice])
-            .await
-            .unwrap_err();
-        assert_eq!(error, client_error(TokenError::CpiGuardBurnBlocked));
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // delegate-auth cpi burn with cpi guard works
-        token_obj
-            .approve(
-                &alice.pubkey(),
-                &bob.pubkey(),
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-
-        token_obj
-            .process_ixs(&[mk_burn(bob.pubkey(), do_checked)], &[&bob])
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-
-        // burn still works through cpi with cpi guard off
-        token_obj
-            .disable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        token_obj
-            .process_ixs(&[mk_burn(alice.pubkey(), do_checked)], &[&alice])
-            .await
-            .unwrap();
-        amount -= 1;
-
-        let alice_state = token_obj.get_account_info(&alice.pubkey()).await.unwrap();
-        assert_eq!(alice_state.base.amount, amount);
-    }
-}
-
-#[tokio::test]
-async fn test_cpi_guard_approve() {
-    let context = make_context().await;
-    let TokenContext {
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let mk_approve = |do_checked| {
-        wrap_instruction(
-            spl_instruction_padding::id(),
-            if do_checked {
-                instruction::approve_checked(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    token.get_address(),
-                    &bob.pubkey(),
-                    &alice.pubkey(),
-                    &[],
-                    1,
-                    9,
-                )
-                .unwrap()
-            } else {
-                instruction::approve(
-                    &spl_token_2022::id(),
-                    &alice.pubkey(),
-                    &bob.pubkey(),
-                    &alice.pubkey(),
-                    &[],
-                    1,
-                )
-                .unwrap()
-            },
-            vec![],
-            0,
-        )
-        .unwrap()
-    };
-
-    for do_checked in [true, false] {
-        let token_obj = if do_checked { &token } else { &token_unchecked };
-        token_obj
-            .enable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        // approve works normally with cpi guard enabled
-        token_obj
-            .approve(
-                &alice.pubkey(),
-                &bob.pubkey(),
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-
-        token_obj
-            .revoke(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        // approve doesn't work through cpi
-        let error = token_obj
-            .process_ixs(&[mk_approve(do_checked)], &[&alice])
-            .await
-            .unwrap_err();
-        assert_eq!(error, client_error(TokenError::CpiGuardApproveBlocked));
-
-        // approve still works through cpi with cpi guard off
-        token_obj
-            .disable_cpi_guard(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        // refresh the blockhash
-        token_obj.get_new_latest_blockhash().await.unwrap();
-        token_obj
-            .process_ixs(&[mk_approve(do_checked)], &[&alice])
-            .await
-            .unwrap();
-
-        token_obj
-            .revoke(&alice.pubkey(), &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-    }
-}
-
-async fn make_close_test_account<S: Signer>(
-    token: &Token<ProgramBanksClientProcessTransaction>,
-    owner: &S,
-    authority: Option<Pubkey>,
-) -> Pubkey {
-    let account = Keypair::new();
-
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &account,
-            &owner.pubkey(),
-            vec![ExtensionType::CpiGuard],
-        )
-        .await
-        .unwrap();
-
-    if authority.is_some() {
-        token
-            .set_authority(
-                &account.pubkey(),
-                &owner.pubkey(),
-                authority.as_ref(),
-                AuthorityType::CloseAccount,
-                &[owner],
-            )
-            .await
-            .unwrap();
-    }
-
-    token
-        .enable_cpi_guard(&account.pubkey(), &owner.pubkey(), &[owner])
-        .await
-        .unwrap();
-
-    account.pubkey()
-}
-
-#[tokio::test]
-async fn test_cpi_guard_close_account() {
-    let context = make_context().await;
-    let TokenContext {
-        token, alice, bob, ..
-    } = context.token_context.unwrap();
-
-    let mk_close = |account, destination, authority| {
-        wrap_instruction(
-            spl_instruction_padding::id(),
-            instruction::close_account(
-                &spl_token_2022::id(),
-                &account,
-                &destination,
-                &authority,
-                &[],
-            )
-            .unwrap(),
-            vec![],
-            0,
-        )
-        .unwrap()
-    };
-
-    // test closing through owner and closing through close authority
-    // the result should be the same eitehr way
-    for maybe_close_authority in [None, Some(bob.pubkey())] {
-        let authority = if maybe_close_authority.is_none() {
-            &alice
-        } else {
-            &bob
-        };
-
-        // closing normally works
-        let account = make_close_test_account(&token, &alice, maybe_close_authority).await;
-        token
-            .close_account(&account, &bob.pubkey(), &authority.pubkey(), &[authority])
-            .await
-            .unwrap();
-
-        // cpi close with guard enabled fails if lamports diverted to third party
-        let account = make_close_test_account(&token, &alice, maybe_close_authority).await;
-        let error = token
-            .process_ixs(
-                &[mk_close(account, bob.pubkey(), authority.pubkey())],
-                &[authority],
-            )
-            .await
-            .unwrap_err();
-        assert_eq!(error, client_error(TokenError::CpiGuardCloseAccountBlocked));
-
-        // but close succeeds if lamports are returned to owner
-        token
-            .process_ixs(
-                &[mk_close(account, alice.pubkey(), authority.pubkey())],
-                &[authority],
-            )
-            .await
-            .unwrap();
-
-        // close still works through cpi when guard disabled
-        let account = make_close_test_account(&token, &alice, maybe_close_authority).await;
-        token
-            .disable_cpi_guard(&account, &alice.pubkey(), &[&alice])
-            .await
-            .unwrap();
-
-        token
-            .process_ixs(
-                &[mk_close(account, bob.pubkey(), authority.pubkey())],
-                &[authority],
-            )
-            .await
-            .unwrap();
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-enum SetAuthTest {
-    ChangeOwner,
-    AddCloseAuth,
-    ChangeCloseAuth,
-    RemoveCloseAuth,
-}
-
-#[tokio::test]
-async fn test_cpi_guard_set_authority() {
-    let context = make_context().await;
-    let TokenContext {
-        token, alice, bob, ..
-    } = context.token_context.unwrap();
-
-    // the behavior of cpi guard and close authority is so complicated that its best
-    // to test all cases exhaustively
-    let mut states = vec![];
-    for action in [
-        SetAuthTest::ChangeOwner,
-        SetAuthTest::AddCloseAuth,
-        SetAuthTest::ChangeCloseAuth,
-        SetAuthTest::RemoveCloseAuth,
-    ] {
-        for enable_cpi_guard in [true, false] {
-            for do_in_cpi in [true, false] {
-                states.push((action, enable_cpi_guard, do_in_cpi));
-            }
-        }
-    }
-
-    for state in states {
-        let (action, enable_cpi_guard, do_in_cpi) = state;
-
-        // make a new account
-        let account = Keypair::new();
-        token
-            .create_auxiliary_token_account_with_extension_space(
-                &account,
-                &alice.pubkey(),
-                vec![ExtensionType::CpiGuard],
-            )
-            .await
-            .unwrap();
-
-        // turn on cpi guard if we are testing that case
-        // all actions with cpi guard off should succeed unconditionally
-        // so half of these tests are backwards compat checks
-        if enable_cpi_guard {
-            token
-                .enable_cpi_guard(&account.pubkey(), &alice.pubkey(), &[&alice])
-                .await
-                .unwrap();
-        }
-
-        // if we are changing or removing close auth, we need to have one to
-        // change/remove
-        if action == SetAuthTest::ChangeCloseAuth || action == SetAuthTest::RemoveCloseAuth {
-            token
-                .set_authority(
-                    &account.pubkey(),
-                    &alice.pubkey(),
-                    Some(&bob.pubkey()),
-                    AuthorityType::CloseAccount,
-                    &[&alice],
-                )
-                .await
-                .unwrap();
-        }
-
-        // this produces the token instruction we want to execute
-        let (current_authority, new_authority) = match action {
-            SetAuthTest::ChangeOwner | SetAuthTest::AddCloseAuth => {
-                (keypair_clone(&alice), Some(bob.pubkey()))
-            }
-            SetAuthTest::ChangeCloseAuth => (keypair_clone(&bob), Some(alice.pubkey())),
-            SetAuthTest::RemoveCloseAuth => (keypair_clone(&bob), None),
-        };
-        let token_instruction = instruction::set_authority(
-            &spl_token_2022::id(),
-            &account.pubkey(),
-            new_authority.as_ref(),
-            if action == SetAuthTest::ChangeOwner {
-                AuthorityType::AccountOwner
-            } else {
-                AuthorityType::CloseAccount
-            },
-            &current_authority.pubkey(),
-            &[],
-        )
-        .unwrap();
-
-        // this wraps it or doesn't based on the test case
-        let instruction = if do_in_cpi {
-            wrap_instruction(spl_instruction_padding::id(), token_instruction, vec![], 0).unwrap()
-        } else {
-            token_instruction
-        };
-
-        // and here we go
-        let result = token
-            .process_ixs(&[instruction], &[&current_authority])
-            .await;
-
-        // truth table for our cases
-        match (action, enable_cpi_guard, do_in_cpi) {
-            // all actions succeed with cpi guard off
-            (_, false, _) => result.unwrap(),
-            // ownership cannot be transferred with guard
-            (SetAuthTest::ChangeOwner, true, false) => assert_eq!(
-                result.unwrap_err(),
-                client_error(TokenError::CpiGuardOwnerChangeBlocked)
-            ),
-            // all other actions succeed outside cpi with guard
-            (_, true, false) => result.unwrap(),
-            // removing a close authority succeeds in cpi with guard
-            (SetAuthTest::RemoveCloseAuth, true, true) => result.unwrap(),
-            // changing owner, adding close, or changing close all fail in cpi with guard
-            (_, true, true) => assert_eq!(
-                result.unwrap_err(),
-                client_error(TokenError::CpiGuardSetAuthorityBlocked)
-            ),
-        }
-    }
-}
diff --git a/token/program-2022-test/tests/default_account_state.rs b/token/program-2022-test/tests/default_account_state.rs
deleted file mode 100644
index ebee881d9e9..00000000000
--- a/token/program-2022-test/tests/default_account_state.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, program_option::COption, pubkey::Pubkey, signature::Signer,
-        signer::keypair::Keypair, transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{default_account_state::DefaultAccountState, BaseStateWithExtensions},
-        instruction::AuthorityType,
-        state::AccountState,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::convert::TryFrom,
-};
-
-#[tokio::test]
-async fn success_init_default_acct_state_frozen() {
-    let default_account_state = AccountState::Frozen;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_freezing_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        freeze_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(
-        state.base.freeze_authority,
-        COption::Some(freeze_authority.unwrap().pubkey())
-    );
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        default_account_state,
-    );
-}
-
-#[tokio::test]
-async fn fail_init_no_authority_default_acct_state_frozen() {
-    let default_account_state = AccountState::Frozen;
-    let mut context = TestContext::new().await;
-    let err = context
-        .init_token_with_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(TokenError::MintCannotFreeze as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn success_init_default_acct_state_initialized() {
-    let default_account_state = AccountState::Initialized;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(state.base.freeze_authority, COption::None);
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        default_account_state,
-    );
-}
-
-#[tokio::test]
-async fn success_no_authority_init_default_acct_state_initialized() {
-    let default_account_state = AccountState::Initialized;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_freezing_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        freeze_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(
-        state.base.freeze_authority,
-        COption::Some(freeze_authority.unwrap().pubkey())
-    );
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        default_account_state,
-    );
-}
-
-#[tokio::test]
-async fn fail_invalid_default_acct_state() {
-    let default_account_state = AccountState::Uninitialized;
-    let mut context = TestContext::new().await;
-    let err = context
-        .init_token_with_freezing_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidState as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn end_to_end_default_account_state() {
-    let default_account_state = AccountState::Frozen;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_freezing_mint(vec![ExtensionInitializationParams::DefaultAccountState {
-            state: default_account_state,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        mint_authority,
-        freeze_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let freeze_authority = freeze_authority.unwrap();
-
-    let owner = Pubkey::new_unique();
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &owner)
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    let account_state = token.get_account_info(&account).await.unwrap();
-    assert_eq!(account_state.base.state, default_account_state);
-
-    // Invalid default state
-    let err = token
-        .set_default_account_state(
-            &mint_authority.pubkey(),
-            &AccountState::Uninitialized,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InvalidState as u32)
-            )
-        )))
-    );
-
-    token
-        .set_default_account_state(
-            &freeze_authority.pubkey(),
-            &AccountState::Initialized,
-            &[&freeze_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        AccountState::Initialized,
-    );
-
-    let owner = Pubkey::new_unique();
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &owner)
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    let account_state = token.get_account_info(&account).await.unwrap();
-    assert_eq!(account_state.base.state, AccountState::Initialized);
-
-    // adjusting freeze authority adjusts default state authority
-    let new_authority = Keypair::new();
-    token
-        .set_authority(
-            token.get_address(),
-            &freeze_authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            AuthorityType::FreezeAccount,
-            &[&freeze_authority],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .set_default_account_state(
-            &mint_authority.pubkey(),
-            &AccountState::Frozen,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    token
-        .set_default_account_state(
-            &new_authority.pubkey(),
-            &AccountState::Frozen,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        AccountState::Frozen,
-    );
-
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            AuthorityType::FreezeAccount,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-
-    let err = token
-        .set_default_account_state(
-            &new_authority.pubkey(),
-            &AccountState::Initialized,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<DefaultAccountState>().unwrap();
-    assert_eq!(
-        AccountState::try_from(extension.state).unwrap(),
-        AccountState::Frozen,
-    );
-}
diff --git a/token/program-2022-test/tests/delegate.rs b/token/program-2022-test/tests/delegate.rs
deleted file mode 100644
index ee337cb0da3..00000000000
--- a/token/program-2022-test/tests/delegate.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::error::TokenError,
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-};
-
-#[derive(PartialEq)]
-enum TransferMode {
-    All,
-    CheckedOnly,
-}
-
-#[derive(PartialEq)]
-enum ApproveMode {
-    Unchecked,
-    Checked,
-}
-
-#[derive(PartialEq)]
-enum OwnerMode {
-    SelfOwned,
-    External,
-}
-
-async fn run_basic(
-    context: TestContext,
-    owner_mode: OwnerMode,
-    transfer_mode: TransferMode,
-    approve_mode: ApproveMode,
-) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = match owner_mode {
-        OwnerMode::SelfOwned => {
-            token
-                .create_auxiliary_token_account(&alice, &alice.pubkey())
-                .await
-                .unwrap();
-            alice.pubkey()
-        }
-        OwnerMode::External => {
-            let alice_account = Keypair::new();
-            token
-                .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-                .await
-                .unwrap();
-            alice_account.pubkey()
-        }
-    };
-    let bob_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&bob_account, &bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint tokens
-    let amount = 100;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // delegate to bob
-    let delegated_amount = 10;
-    match approve_mode {
-        ApproveMode::Unchecked => token_unchecked
-            .approve(
-                &alice_account,
-                &bob.pubkey(),
-                &alice.pubkey(),
-                delegated_amount,
-                &[&alice],
-            )
-            .await
-            .unwrap(),
-        ApproveMode::Checked => token
-            .approve(
-                &alice_account,
-                &bob.pubkey(),
-                &alice.pubkey(),
-                delegated_amount,
-                &[&alice],
-            )
-            .await
-            .unwrap(),
-    }
-
-    // transfer too much is not ok
-    let error = token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &bob.pubkey(),
-            delegated_amount.checked_add(1).unwrap(),
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-
-    // transfer is ok
-    if transfer_mode == TransferMode::All {
-        token_unchecked
-            .transfer(&alice_account, &bob_account, &bob.pubkey(), 1, &[&bob])
-            .await
-            .unwrap();
-    }
-
-    token
-        .transfer(&alice_account, &bob_account, &bob.pubkey(), 1, &[&bob])
-        .await
-        .unwrap();
-
-    // burn is ok
-    token_unchecked
-        .burn(&alice_account, &bob.pubkey(), 1, &[&bob])
-        .await
-        .unwrap();
-    token
-        .burn(&alice_account, &bob.pubkey(), 1, &[&bob])
-        .await
-        .unwrap();
-
-    // wrong signer
-    let keypair = &Keypair::new();
-    let error = token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &keypair.pubkey(),
-            1,
-            &[keypair],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // revoke
-    token
-        .revoke(&alice_account, &alice.pubkey(), &[&alice])
-        .await
-        .unwrap();
-
-    // now fails
-    let error = token
-        .transfer(&alice_account, &bob_account, &bob.pubkey(), 2, &[&bob])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn basic() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_basic(
-        context,
-        OwnerMode::External,
-        TransferMode::All,
-        ApproveMode::Unchecked,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn basic_checked() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_basic(
-        context,
-        OwnerMode::External,
-        TransferMode::All,
-        ApproveMode::Checked,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn basic_self_owned() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_basic(
-        context,
-        OwnerMode::SelfOwned,
-        TransferMode::All,
-        ApproveMode::Checked,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn basic_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000u64,
-        }])
-        .await
-        .unwrap();
-    run_basic(
-        context,
-        OwnerMode::External,
-        TransferMode::CheckedOnly,
-        ApproveMode::Unchecked,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn basic_with_extension_checked() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000u64,
-        }])
-        .await
-        .unwrap();
-    run_basic(
-        context,
-        OwnerMode::External,
-        TransferMode::CheckedOnly,
-        ApproveMode::Checked,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn basic_self_owned_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000u64,
-        }])
-        .await
-        .unwrap();
-    run_basic(
-        context,
-        OwnerMode::SelfOwned,
-        TransferMode::CheckedOnly,
-        ApproveMode::Checked,
-    )
-    .await;
-}
diff --git a/token/program-2022-test/tests/freeze.rs b/token/program-2022-test/tests/freeze.rs
deleted file mode 100644
index f17b5ff3b90..00000000000
--- a/token/program-2022-test/tests/freeze.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{signature::Signer, signer::keypair::Keypair},
-    spl_token_2022::state::AccountState,
-};
-
-#[tokio::test]
-async fn basic() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_freezing_mint(vec![]).await.unwrap();
-    let TokenContext {
-        freeze_authority,
-        token,
-        alice,
-        ..
-    } = context.token_context.unwrap();
-    let freeze_authority = freeze_authority.unwrap();
-
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &alice.pubkey())
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    let state = token.get_account_info(&account).await.unwrap();
-    assert_eq!(state.base.state, AccountState::Initialized);
-
-    token
-        .freeze(&account, &freeze_authority.pubkey(), &[&freeze_authority])
-        .await
-        .unwrap();
-    let state = token.get_account_info(&account).await.unwrap();
-    assert_eq!(state.base.state, AccountState::Frozen);
-
-    token
-        .thaw(&account, &freeze_authority.pubkey(), &[&freeze_authority])
-        .await
-        .unwrap();
-    let state = token.get_account_info(&account).await.unwrap();
-    assert_eq!(state.base.state, AccountState::Initialized);
-}
diff --git a/token/program-2022-test/tests/group_member_pointer.rs b/token/program-2022-test/tests/group_member_pointer.rs
deleted file mode 100644
index 8f59ee5bc0a..00000000000
--- a/token/program-2022-test/tests/group_member_pointer.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            group_member_pointer::GroupMemberPointer, group_pointer::GroupPointer,
-            BaseStateWithExtensions,
-        },
-        instruction,
-        processor::Processor,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(
-    mint: Keypair,
-    member_address: &Pubkey,
-    authority: &Pubkey,
-    maybe_group_address: Option<Pubkey>,
-) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let mut extension_init_params = vec![ExtensionInitializationParams::GroupMemberPointer {
-        authority: Some(*authority),
-        member_address: Some(*member_address),
-    }];
-    if let Some(group_address) = maybe_group_address {
-        extension_init_params.push(ExtensionInitializationParams::GroupPointer {
-            authority: Some(*authority),
-            group_address: Some(group_address),
-        });
-    }
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(mint, extension_init_params, None)
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_init() {
-    let authority = Pubkey::new_unique();
-    let member_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &member_address, &authority, None)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(
-        extension.member_address,
-        Some(member_address).try_into().unwrap()
-    );
-}
-
-#[tokio::test]
-async fn success_init_with_group() {
-    let authority = Pubkey::new_unique();
-    let group_address = Pubkey::new_unique();
-    let member_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(
-        mint_keypair,
-        &member_address,
-        &authority,
-        Some(group_address),
-    )
-    .await
-    .token_context
-    .take()
-    .unwrap()
-    .token;
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(
-        extension.member_address,
-        Some(member_address).try_into().unwrap()
-    );
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(
-        extension.group_address,
-        Some(group_address).try_into().unwrap()
-    );
-}
-
-#[tokio::test]
-async fn fail_init_all_none() {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let err = context
-        .init_token_with_mint(vec![ExtensionInitializationParams::GroupMemberPointer {
-            authority: None,
-            member_address: None,
-        }])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidInstruction as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let authority = Keypair::new();
-    let member_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &member_address, &authority.pubkey(), None)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_authority = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::GroupMemberPointer,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::GroupMemberPointer,
-            &[&authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(
-        extension.authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::GroupMemberPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(extension.authority, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&authority.pubkey()),
-            instruction::AuthorityType::GroupMemberPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn update_member_address() {
-    let authority = Keypair::new();
-    let member_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &member_address, &authority.pubkey(), None)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_member_address = Pubkey::new_unique();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .update_group_member_address(&wrong.pubkey(), Some(new_member_address), &[&wrong])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .update_group_member_address(&authority.pubkey(), Some(new_member_address), &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(
-        extension.member_address,
-        Some(new_member_address).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .update_group_member_address(&authority.pubkey(), None, &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupMemberPointer>().unwrap();
-    assert_eq!(extension.member_address, None.try_into().unwrap(),);
-}
diff --git a/token/program-2022-test/tests/group_pointer.rs b/token/program-2022-test/tests/group_pointer.rs
deleted file mode 100644
index 5dc6922919f..00000000000
--- a/token/program-2022-test/tests/group_pointer.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{group_pointer::GroupPointer, BaseStateWithExtensions},
-        instruction,
-        processor::Processor,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, group_address: &Pubkey, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(*authority),
-                group_address: Some(*group_address),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_init() {
-    let authority = Pubkey::new_unique();
-    let group_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &group_address, &authority)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(
-        extension.group_address,
-        Some(group_address).try_into().unwrap()
-    );
-}
-
-#[tokio::test]
-async fn fail_init_all_none() {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let err = context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            Keypair::new(),
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: None,
-                group_address: None,
-            }],
-            None,
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidInstruction as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let authority = Keypair::new();
-    let group_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &group_address, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_authority = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::GroupPointer,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::GroupPointer,
-            &[&authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(
-        extension.authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::GroupPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(extension.authority, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&authority.pubkey()),
-            instruction::AuthorityType::GroupPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn update_group_address() {
-    let authority = Keypair::new();
-    let group_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &group_address, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_group_address = Pubkey::new_unique();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .update_group_address(&wrong.pubkey(), Some(new_group_address), &[&wrong])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .update_group_address(&authority.pubkey(), Some(new_group_address), &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(
-        extension.group_address,
-        Some(new_group_address).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .update_group_address(&authority.pubkey(), None, &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<GroupPointer>().unwrap();
-    assert_eq!(extension.group_address, None.try_into().unwrap(),);
-}
diff --git a/token/program-2022-test/tests/initialize_account.rs b/token/program-2022-test/tests/initialize_account.rs
deleted file mode 100644
index c0cd45250c1..00000000000
--- a/token/program-2022-test/tests/initialize_account.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            transfer_fee::{self, TransferFeeAmount},
-            BaseStateWithExtensions, ExtensionType, StateWithExtensions,
-        },
-        instruction,
-        state::{Account, Mint},
-    },
-};
-
-#[tokio::test]
-async fn no_extensions() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-
-    let account = Keypair::new();
-    let account_owner_pubkey = Pubkey::new_unique();
-    let space = ExtensionType::try_calculate_account_len::<Account>(&[]).unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_account3(
-            &spl_token_2022::id(),
-            &account.pubkey(),
-            &mint_account.pubkey(),
-            &account_owner_pubkey,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-    let account_info = ctx
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .expect("get_account")
-        .expect("account not none");
-    assert_eq!(account_info.data.len(), spl_token_2022::state::Account::LEN);
-    assert_eq!(account_info.owner, spl_token_2022::id());
-    assert_eq!(account_info.lamports, rent.minimum_balance(space));
-}
-
-#[tokio::test]
-async fn fail_on_invalid_mint() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-
-    let space = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let instructions = vec![system_instruction::create_account(
-        &ctx.payer.pubkey(),
-        &mint_account.pubkey(),
-        rent.minimum_balance(space),
-        space as u64,
-        &spl_token_2022::id(),
-    )];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-
-    let account = Keypair::new();
-    let account_owner_pubkey = Pubkey::new_unique();
-    let space = ExtensionType::try_calculate_account_len::<Account>(&[]).unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_account3(
-            &spl_token_2022::id(),
-            &account.pubkey(),
-            &mint_account.pubkey(),
-            &account_owner_pubkey,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(
-            1,
-            InstructionError::Custom(TokenError::InvalidMint as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn single_extension() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::TransferFeeConfig])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        transfer_fee::instruction::initialize_transfer_fee_config(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            None,
-            None,
-            10,
-            4242,
-        )
-        .unwrap(),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-
-    let account = Keypair::new();
-    let account_owner_pubkey = Pubkey::new_unique();
-    let space =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::TransferFeeAmount])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_account3(
-            &spl_token_2022::id(),
-            &account.pubkey(),
-            &mint_account.pubkey(),
-            &account_owner_pubkey,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-    let account_info = ctx
-        .banks_client
-        .get_account(account.pubkey())
-        .await
-        .expect("get_account")
-        .expect("account not none");
-    assert_eq!(
-        account_info.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::TransferFeeAmount])
-            .unwrap(),
-    );
-    assert_eq!(account_info.owner, spl_token_2022::id());
-    assert_eq!(account_info.lamports, rent.minimum_balance(space));
-    let state = StateWithExtensions::<Account>::unpack(&account_info.data).unwrap();
-    assert_eq!(state.base.mint, mint_account.pubkey());
-    assert_eq!(
-        &state.get_extension_types().unwrap(),
-        &[ExtensionType::TransferFeeAmount]
-    );
-    let unpacked_extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(
-        *unpacked_extension,
-        TransferFeeAmount {
-            withheld_amount: 0.into()
-        }
-    );
-}
-
-// TODO: add test for multiple Account extensions when memo extension is present
diff --git a/token/program-2022-test/tests/initialize_mint.rs b/token/program-2022-test/tests/initialize_mint.rs
deleted file mode 100644
index 898ecd4ea19..00000000000
--- a/token/program-2022-test/tests/initialize_mint.rs
+++ /dev/null
@@ -1,654 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        program_option::COption,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            confidential_transfer, confidential_transfer_fee,
-            mint_close_authority::MintCloseAuthority, transfer_fee, BaseStateWithExtensions,
-            ExtensionType,
-        },
-        instruction, native_mint,
-        solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-        state::Mint,
-    },
-    spl_token_client::token::ExtensionInitializationParams,
-    std::convert::TryInto,
-};
-
-#[tokio::test]
-async fn success_base() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let mint = token.get_mint_info().await.unwrap();
-    assert_eq!(mint.base.decimals, decimals);
-    assert_eq!(
-        mint.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(mint.base.supply, 0);
-    assert!(mint.base.is_initialized);
-    assert_eq!(mint.base.freeze_authority, COption::None);
-}
-
-#[tokio::test]
-async fn fail_extension_no_space() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space = Mint::LEN;
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint_close_authority(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(&mint_authority_pubkey),
-        )
-        .unwrap(),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(1, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn fail_extension_after_mint_init() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MintCloseAuthority])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-        instruction::initialize_mint_close_authority(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(&mint_authority_pubkey),
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(1, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn success_extension_and_base() {
-    let close_authority = Some(Pubkey::new_unique());
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(state.base.freeze_authority, COption::None);
-    let extension = state.get_extension::<MintCloseAuthority>().unwrap();
-    assert_eq!(
-        extension.close_authority,
-        close_authority.try_into().unwrap(),
-    );
-}
-
-#[tokio::test]
-async fn fail_init_overallocated_mint() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MintCloseAuthority])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(1, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn fail_account_init_after_mint_extension() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-    let token_account = Keypair::new();
-
-    let mint_space = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let account_space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MintCloseAuthority])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(mint_space),
-            mint_space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &token_account.pubkey(),
-            rent.minimum_balance(account_space),
-            account_space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint_close_authority(
-            &spl_token_2022::id(),
-            &token_account.pubkey(),
-            Some(&mint_authority_pubkey),
-        )
-        .unwrap(),
-        instruction::initialize_account(
-            &spl_token_2022::id(),
-            &token_account.pubkey(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account, &token_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(
-            4,
-            InstructionError::Custom(TokenError::ExtensionBaseMismatch as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn fail_account_init_after_mint_init() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let mint_space = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(mint_space),
-            mint_space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-        instruction::initialize_account(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(2, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn fail_account_init_after_mint_init_with_extension() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let mint_space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MintCloseAuthority])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(mint_space),
-            mint_space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint_close_authority(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(&mint_authority_pubkey),
-        )
-        .unwrap(),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-        instruction::initialize_account(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(3, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn fail_fee_init_after_mint_init() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space =
-        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::TransferFeeConfig])
-            .unwrap();
-    let instructions = vec![
-        system_instruction::create_account(
-            &ctx.payer.pubkey(),
-            &mint_account.pubkey(),
-            rent.minimum_balance(space),
-            space as u64,
-            &spl_token_2022::id(),
-        ),
-        instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            &mint_authority_pubkey,
-            None,
-            9,
-        )
-        .unwrap(),
-        transfer_fee::instruction::initialize_transfer_fee_config(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(&Pubkey::new_unique()),
-            Some(&Pubkey::new_unique()),
-            10,
-            100,
-        )
-        .unwrap(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(1, InstructionError::InvalidAccountData)
-    );
-}
-
-#[tokio::test]
-async fn create_native_mint() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_native_mint().await.unwrap();
-    let TokenContext { token, .. } = context.token_context.unwrap();
-
-    let mint = token.get_mint_info().await.unwrap();
-    assert_eq!(mint.base.decimals, native_mint::DECIMALS);
-    assert_eq!(mint.base.mint_authority, COption::None,);
-    assert_eq!(mint.base.supply, 0);
-    assert!(mint.base.is_initialized);
-    assert_eq!(mint.base.freeze_authority, COption::None);
-}
-
-#[tokio::test]
-async fn fail_invalid_extensions_combination() {
-    let context = TestContext::new().await;
-    let mut ctx = context.context.lock().await;
-    let rent = ctx.banks_client.get_rent().await.unwrap();
-    let mint_account = Keypair::new();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let transfer_fee_config_init_instruction =
-        transfer_fee::instruction::initialize_transfer_fee_config(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(&Pubkey::new_unique()),
-            Some(&Pubkey::new_unique()),
-            10,
-            100,
-        )
-        .unwrap();
-
-    let confidential_transfer_mint_init_instruction =
-        confidential_transfer::instruction::initialize_mint(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(Pubkey::new_unique()),
-            true,
-            None,
-        )
-        .unwrap();
-
-    let confidential_transfer_fee_config_init_instruction =
-        confidential_transfer_fee::instruction::initialize_confidential_transfer_fee_config(
-            &spl_token_2022::id(),
-            &mint_account.pubkey(),
-            Some(Pubkey::new_unique()),
-            ElGamalPubkey::default(),
-        )
-        .unwrap();
-
-    let initialize_mint_instruction = instruction::initialize_mint(
-        &spl_token_2022::id(),
-        &mint_account.pubkey(),
-        &mint_authority_pubkey,
-        None,
-        9,
-    )
-    .unwrap();
-
-    // initialize transfer fee and confidential transfers, but no confidential
-    // transfer fee
-    let mint_space = ExtensionType::try_calculate_account_len::<Mint>(&[
-        ExtensionType::TransferFeeConfig,
-        ExtensionType::ConfidentialTransferMint,
-    ])
-    .unwrap();
-    let create_account_instruction = system_instruction::create_account(
-        &ctx.payer.pubkey(),
-        &mint_account.pubkey(),
-        rent.minimum_balance(mint_space),
-        mint_space as u64,
-        &spl_token_2022::id(),
-    );
-
-    let instructions = vec![
-        create_account_instruction.clone(),
-        transfer_fee_config_init_instruction.clone(),
-        confidential_transfer_mint_init_instruction.clone(),
-        initialize_mint_instruction.clone(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(
-            3,
-            InstructionError::Custom(TokenError::InvalidExtensionCombination as u32)
-        )
-    );
-
-    // initialize transfer fee and confidential transfer fees, but no confidential
-    // transfers
-    let mint_space = ExtensionType::try_calculate_account_len::<Mint>(&[
-        ExtensionType::TransferFeeConfig,
-        ExtensionType::ConfidentialTransferFeeConfig,
-    ])
-    .unwrap();
-    let create_account_instruction = system_instruction::create_account(
-        &ctx.payer.pubkey(),
-        &mint_account.pubkey(),
-        rent.minimum_balance(mint_space),
-        mint_space as u64,
-        &spl_token_2022::id(),
-    );
-
-    let instructions = vec![
-        create_account_instruction.clone(),
-        transfer_fee_config_init_instruction.clone(),
-        confidential_transfer_fee_config_init_instruction.clone(),
-        initialize_mint_instruction.clone(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    let err = ctx
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        err,
-        TransactionError::InstructionError(
-            3,
-            InstructionError::Custom(TokenError::InvalidExtensionCombination as u32)
-        )
-    );
-
-    // initialize all of transfer fee, confidential transfers, and confidential
-    // transfer fees (success case)
-    let mint_space = ExtensionType::try_calculate_account_len::<Mint>(&[
-        ExtensionType::TransferFeeConfig,
-        ExtensionType::ConfidentialTransferMint,
-        ExtensionType::ConfidentialTransferFeeConfig,
-    ])
-    .unwrap();
-    let create_account_instruction = system_instruction::create_account(
-        &ctx.payer.pubkey(),
-        &mint_account.pubkey(),
-        rent.minimum_balance(mint_space),
-        mint_space as u64,
-        &spl_token_2022::id(),
-    );
-
-    let instructions = vec![
-        create_account_instruction.clone(),
-        transfer_fee_config_init_instruction.clone(),
-        confidential_transfer_mint_init_instruction.clone(),
-        confidential_transfer_fee_config_init_instruction.clone(),
-        initialize_mint_instruction.clone(),
-    ];
-
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &mint_account],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-}
diff --git a/token/program-2022-test/tests/interest_bearing_mint.rs b/token/program-2022-test/tests/interest_bearing_mint.rs
deleted file mode 100644
index 5a2299bb1a5..00000000000
--- a/token/program-2022-test/tests/interest_bearing_mint.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{keypair_clone, TestContext, TokenContext},
-    solana_program_test::{
-        processor,
-        tokio::{self, sync::Mutex},
-        ProgramTest,
-    },
-    solana_sdk::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        msg,
-        program::{get_return_data, invoke},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{interest_bearing_mint::InterestBearingConfig, BaseStateWithExtensions},
-        instruction::{amount_to_ui_amount, ui_amount_to_amount, AuthorityType},
-        processor::Processor,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::{convert::TryInto, sync::Arc},
-};
-
-#[tokio::test]
-async fn success_initialize() {
-    for (rate, rate_authority) in [(i16::MIN, None), (i16::MAX, Some(Pubkey::new_unique()))] {
-        let mut context = TestContext::new().await;
-        context
-            .init_token_with_mint(vec![ExtensionInitializationParams::InterestBearingConfig {
-                rate_authority,
-                rate,
-            }])
-            .await
-            .unwrap();
-        let TokenContext { token, .. } = context.token_context.unwrap();
-
-        let state = token.get_mint_info().await.unwrap();
-        let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-        assert_eq!(
-            Option::<Pubkey>::from(extension.rate_authority),
-            rate_authority,
-        );
-        assert_eq!(i16::from(extension.current_rate), rate,);
-        assert_eq!(i16::from(extension.pre_update_average_rate), rate,);
-    }
-}
-
-#[tokio::test]
-async fn update_rate() {
-    let rate_authority = Keypair::new();
-    let initial_rate = 500;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::InterestBearingConfig {
-            rate_authority: Some(rate_authority.pubkey()),
-            rate: initial_rate,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-    assert_eq!(i16::from(extension.current_rate), initial_rate);
-    assert_eq!(i16::from(extension.pre_update_average_rate), initial_rate);
-    let initialization_timestamp = i64::from(extension.initialization_timestamp);
-    assert_eq!(
-        extension.initialization_timestamp,
-        extension.last_update_timestamp
-    );
-
-    // warp forward, so last update timestamp is advanced during update
-    let warp_slot = 1_000;
-    let initial_num_warps = 10;
-    for i in 1..initial_num_warps {
-        context
-            .context
-            .lock()
-            .await
-            .warp_to_slot(i * warp_slot)
-            .unwrap();
-    }
-
-    // correct
-    let middle_rate = 1_000;
-    token
-        .update_interest_rate(&rate_authority.pubkey(), middle_rate, &[&rate_authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-    assert_eq!(i16::from(extension.current_rate), middle_rate);
-    assert_eq!(i16::from(extension.pre_update_average_rate), initial_rate);
-    let last_update_timestamp = i64::from(extension.last_update_timestamp);
-    assert!(last_update_timestamp > initialization_timestamp);
-
-    // warp forward
-    let final_num_warps = 20;
-    for i in initial_num_warps..final_num_warps {
-        context
-            .context
-            .lock()
-            .await
-            .warp_to_slot(i * warp_slot)
-            .unwrap();
-    }
-
-    // update again, pre_update_average_rate is between the two previous
-    let new_rate = 2_000;
-    token
-        .update_interest_rate(&rate_authority.pubkey(), new_rate, &[&rate_authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-    assert_eq!(i16::from(extension.current_rate), new_rate);
-    let pre_update_average_rate = i16::from(extension.pre_update_average_rate);
-    assert!(pre_update_average_rate > initial_rate);
-    assert!(middle_rate > pre_update_average_rate);
-    let final_update_timestamp = i64::from(extension.last_update_timestamp);
-    assert!(final_update_timestamp > last_update_timestamp);
-
-    // wrong signer
-    let wrong_signer = Keypair::new();
-    let err = token
-        .update_interest_rate(&wrong_signer.pubkey(), 0, &[&wrong_signer])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let rate_authority = Keypair::new();
-    let initial_rate = 500;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::InterestBearingConfig {
-            rate_authority: Some(rate_authority.pubkey()),
-            rate: initial_rate,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-
-    // success
-    let new_rate_authority = Keypair::new();
-    token
-        .set_authority(
-            token.get_address(),
-            &rate_authority.pubkey(),
-            Some(&new_rate_authority.pubkey()),
-            AuthorityType::InterestRate,
-            &[&rate_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-    assert_eq!(
-        extension.rate_authority,
-        Some(new_rate_authority.pubkey()).try_into().unwrap(),
-    );
-    token
-        .update_interest_rate(&new_rate_authority.pubkey(), 10, &[&new_rate_authority])
-        .await
-        .unwrap();
-    let err = token
-        .update_interest_rate(&rate_authority.pubkey(), 100, &[&rate_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_rate_authority.pubkey(),
-            None,
-            AuthorityType::InterestRate,
-            &[&new_rate_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<InterestBearingConfig>().unwrap();
-    assert_eq!(extension.rate_authority, None.try_into().unwrap(),);
-
-    // now all fail
-    let err = token
-        .update_interest_rate(&new_rate_authority.pubkey(), 50, &[&new_rate_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-    let err = token
-        .update_interest_rate(&rate_authority.pubkey(), 5, &[&rate_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-}
-
-// test program to CPI into token to get ui amounts
-fn process_instruction(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    _input: &[u8],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_info = next_account_info(account_info_iter)?;
-    let token_program = next_account_info(account_info_iter)?;
-    // 10 tokens, with 9 decimal places
-    let test_amount = 10_000_000_000;
-    // "10" as an amount should be smaller than test_amount due to interest
-    invoke(
-        &ui_amount_to_amount(token_program.key, mint_info.key, "10")?,
-        &[mint_info.clone(), token_program.clone()],
-    )?;
-    let (_, return_data) = get_return_data().unwrap();
-    let amount = u64::from_le_bytes(return_data[0..8].try_into().unwrap());
-    msg!("amount: {}", amount);
-    if amount >= test_amount {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    // test_amount as a UI amount should be larger due to interest
-    invoke(
-        &amount_to_ui_amount(token_program.key, mint_info.key, test_amount)?,
-        &[mint_info.clone(), token_program.clone()],
-    )?;
-    let (_, return_data) = get_return_data().unwrap();
-    let ui_amount = String::from_utf8(return_data).unwrap();
-    msg!("ui amount: {}", ui_amount);
-    let float_ui_amount = ui_amount.parse::<f64>().unwrap();
-    if float_ui_amount <= 10.0 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn amount_conversions() {
-    let rate_authority = Keypair::new();
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    let program_id = Pubkey::new_unique();
-    program_test.add_program(
-        "ui_amount_to_amount",
-        program_id,
-        processor!(process_instruction),
-    );
-
-    let context = program_test.start_with_context().await;
-    let payer = keypair_clone(&context.payer);
-    let last_blockhash = context.last_blockhash;
-    let context = Arc::new(Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let initial_rate = i16::MAX;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::InterestBearingConfig {
-            rate_authority: Some(rate_authority.pubkey()),
-            rate: initial_rate,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-
-    // warp forward, so interest is accrued
-    let warp_slot: u64 = 1_000;
-    let initial_num_warps: u64 = 10;
-    for i in 1..initial_num_warps {
-        context
-            .context
-            .lock()
-            .await
-            .warp_to_slot(i.checked_mul(warp_slot).unwrap())
-            .unwrap();
-    }
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[Instruction {
-            program_id,
-            accounts: vec![
-                AccountMeta::new_readonly(*token.get_address(), false),
-                AccountMeta::new_readonly(spl_token_2022::id(), false),
-            ],
-            data: vec![],
-        }],
-        Some(&payer.pubkey()),
-        &[&payer],
-        last_blockhash,
-    );
-    context
-        .context
-        .lock()
-        .await
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
diff --git a/token/program-2022-test/tests/memo_transfer.rs b/token/program-2022-test/tests/memo_transfer.rs
deleted file mode 100644
index 23a3d7afbe3..00000000000
--- a/token/program-2022-test/tests/memo_transfer.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::{
-        tokio::{self, sync::Mutex},
-        ProgramTestContext,
-    },
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{memo_transfer::MemoTransfer, BaseStateWithExtensions, ExtensionType},
-    },
-    spl_token_client::token::TokenError as TokenClientError,
-    std::sync::Arc,
-};
-
-async fn test_memo_transfers(
-    context: Arc<Mutex<ProgramTestContext>>,
-    token_context: TokenContext,
-    alice_account: Pubkey,
-    bob_account: Pubkey,
-) {
-    let TokenContext {
-        mint_authority,
-        token,
-        alice,
-        bob,
-        ..
-    } = token_context;
-
-    // mint tokens
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            4242,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // require memo transfers into bob_account
-    token
-        .enable_required_transfer_memos(&bob_account, &bob.pubkey(), &[&bob])
-        .await
-        .unwrap();
-
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    let extension = bob_state.get_extension::<MemoTransfer>().unwrap();
-    assert!(bool::from(extension.require_incoming_transfer_memos));
-
-    // attempt to transfer from alice to bob without memo
-    let err = token
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 10, &[&alice])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoMemo as u32)
-            )
-        )))
-    );
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, 0);
-
-    // attempt to transfer from alice to bob with misplaced memo, v1 and current
-    let mut memo_ix = spl_memo::build_memo(&[240, 159, 166, 150], &[]);
-    for program_id in [spl_memo::id(), spl_memo::v1::id()] {
-        let mut ctx = context.lock().await;
-        memo_ix.program_id = program_id;
-        #[allow(deprecated)]
-        let instructions = vec![
-            memo_ix.clone(),
-            system_instruction::transfer(&ctx.payer.pubkey(), &alice.pubkey(), 42),
-            spl_token_2022::instruction::transfer(
-                &spl_token_2022::id(),
-                &alice_account,
-                &bob_account,
-                &alice.pubkey(),
-                &[],
-                10,
-            )
-            .unwrap(),
-        ];
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&ctx.payer.pubkey()),
-            &[&ctx.payer, &alice],
-            ctx.last_blockhash,
-        );
-        let err = ctx
-            .banks_client
-            .process_transaction(tx)
-            .await
-            .unwrap_err()
-            .unwrap();
-        drop(ctx);
-        assert_eq!(
-            err,
-            TransactionError::InstructionError(
-                2,
-                InstructionError::Custom(TokenError::NoMemo as u32)
-            )
-        );
-        let bob_state = token.get_account_info(&bob_account).await.unwrap();
-        assert_eq!(bob_state.base.amount, 0);
-    }
-
-    // transfer with memo
-    token
-        .with_memo("🦖", vec![alice.pubkey()])
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 10, &[&alice])
-        .await
-        .unwrap();
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, 10);
-
-    // transfer with memo v1
-    let mut ctx = context.lock().await;
-    memo_ix.program_id = spl_memo::v1::id();
-    #[allow(deprecated)]
-    let instructions = vec![
-        memo_ix,
-        spl_token_2022::instruction::transfer(
-            &spl_token_2022::id(),
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            &[],
-            11,
-        )
-        .unwrap(),
-    ];
-    let tx = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&ctx.payer.pubkey()),
-        &[&ctx.payer, &alice],
-        ctx.last_blockhash,
-    );
-    ctx.banks_client.process_transaction(tx).await.unwrap();
-    drop(ctx);
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, 21);
-
-    // stop requiring memo transfers into bob_account
-    token
-        .disable_required_transfer_memos(&bob_account, &bob.pubkey(), &[&bob])
-        .await
-        .unwrap();
-
-    // transfer from alice to bob without memo
-    token
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 12, &[&alice])
-        .await
-        .unwrap();
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, 33);
-}
-
-#[tokio::test]
-async fn require_memo_transfers_without_realloc() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let token_context = context.token_context.unwrap();
-
-    // create token accounts
-    token_context
-        .token
-        .create_auxiliary_token_account(&token_context.alice, &token_context.alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = token_context.alice.pubkey();
-    token_context
-        .token
-        .create_auxiliary_token_account_with_extension_space(
-            &token_context.bob,
-            &token_context.bob.pubkey(),
-            vec![ExtensionType::MemoTransfer],
-        )
-        .await
-        .unwrap();
-    let bob_account = token_context.bob.pubkey();
-
-    test_memo_transfers(context.context, token_context, alice_account, bob_account).await;
-}
-
-#[tokio::test]
-async fn require_memo_transfers_with_realloc() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let token_context = context.token_context.unwrap();
-
-    // create token accounts
-    token_context
-        .token
-        .create_auxiliary_token_account(&token_context.alice, &token_context.alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = token_context.alice.pubkey();
-    token_context
-        .token
-        .create_auxiliary_token_account(&token_context.bob, &token_context.bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = token_context.bob.pubkey();
-    token_context
-        .token
-        .reallocate(
-            &token_context.bob.pubkey(),
-            &token_context.bob.pubkey(),
-            &[ExtensionType::MemoTransfer],
-            &[&token_context.bob],
-        )
-        .await
-        .unwrap();
-
-    test_memo_transfers(context.context, token_context, alice_account, bob_account).await;
-}
diff --git a/token/program-2022-test/tests/metadata_pointer.rs b/token/program-2022-test/tests/metadata_pointer.rs
deleted file mode 100644
index 32f61f2271c..00000000000
--- a/token/program-2022-test/tests/metadata_pointer.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{metadata_pointer::MetadataPointer, BaseStateWithExtensions},
-        instruction,
-        processor::Processor,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, metadata_address: &Pubkey, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address: Some(*metadata_address),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_init() {
-    let authority = Pubkey::new_unique();
-    let metadata_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &metadata_address, &authority)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(
-        extension.metadata_address,
-        Some(metadata_address).try_into().unwrap()
-    );
-}
-
-#[tokio::test]
-async fn fail_init_all_none() {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let err = context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            Keypair::new(),
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: None,
-                metadata_address: None,
-            }],
-            None,
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidInstruction as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let authority = Keypair::new();
-    let metadata_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &metadata_address, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_authority = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::MetadataPointer,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::MetadataPointer,
-            &[&authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(
-        extension.authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::MetadataPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(extension.authority, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&authority.pubkey()),
-            instruction::AuthorityType::MetadataPointer,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn update_metadata_address() {
-    let authority = Keypair::new();
-    let metadata_address = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &metadata_address, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_metadata_address = Pubkey::new_unique();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .update_metadata_address(&wrong.pubkey(), Some(new_metadata_address), &[&wrong])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .update_metadata_address(
-            &authority.pubkey(),
-            Some(new_metadata_address),
-            &[&authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(
-        extension.metadata_address,
-        Some(new_metadata_address).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .update_metadata_address(&authority.pubkey(), None, &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MetadataPointer>().unwrap();
-    assert_eq!(extension.metadata_address, None.try_into().unwrap(),);
-}
diff --git a/token/program-2022-test/tests/mint_close_authority.rs b/token/program-2022-test/tests/mint_close_authority.rs
deleted file mode 100644
index 1ea2bca1b2d..00000000000
--- a/token/program-2022-test/tests/mint_close_authority.rs
+++ /dev/null
@@ -1,287 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, program_option::COption, pubkey::Pubkey, signature::Signer,
-        signer::keypair::Keypair, transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{mint_close_authority::MintCloseAuthority, BaseStateWithExtensions},
-        instruction,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::convert::TryInto,
-};
-
-#[tokio::test]
-async fn success_init() {
-    let close_authority = Some(Pubkey::new_unique());
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(state.base.freeze_authority, COption::None);
-    let extension = state.get_extension::<MintCloseAuthority>().unwrap();
-    assert_eq!(
-        extension.close_authority,
-        close_authority.try_into().unwrap(),
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let close_authority = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority: Some(close_authority.pubkey()),
-        }])
-        .await
-        .unwrap();
-    let token = context.token_context.unwrap().token;
-    let new_authority = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::CloseMint,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &close_authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::CloseMint,
-            &[&close_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MintCloseAuthority>().unwrap();
-    assert_eq!(
-        extension.close_authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::CloseMint,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<MintCloseAuthority>().unwrap();
-    assert_eq!(extension.close_authority, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&close_authority.pubkey()),
-            instruction::AuthorityType::CloseMint,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-
-    // fail close
-    let destination = Pubkey::new_unique();
-    let err = token
-        .close_account(
-            token.get_address(),
-            &destination,
-            &new_authority.pubkey(),
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn success_close() {
-    let close_authority = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority: Some(close_authority.pubkey()),
-        }])
-        .await
-        .unwrap();
-    let token = context.token_context.unwrap().token;
-
-    let destination = Pubkey::new_unique();
-    token
-        .close_account(
-            token.get_address(),
-            &destination,
-            &close_authority.pubkey(),
-            &[&close_authority],
-        )
-        .await
-        .unwrap();
-    let destination = token.get_account(destination).await.unwrap();
-    assert!(destination.lamports > 0);
-}
-
-#[tokio::test]
-async fn fail_without_extension() {
-    let close_authority = Pubkey::new_unique();
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let TokenContext {
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    // fail set
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &mint_authority.pubkey(),
-            Some(&close_authority),
-            instruction::AuthorityType::CloseMint,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-
-    // fail close
-    let destination = Pubkey::new_unique();
-    let err = token
-        .close_account(
-            token.get_address(),
-            &destination,
-            &mint_authority.pubkey(),
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_close_with_supply() {
-    let close_authority = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::MintCloseAuthority {
-            close_authority: Some(close_authority.pubkey()),
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    // mint a token
-    let owner = Pubkey::new_unique();
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &owner)
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    token
-        .mint_to(&account, &mint_authority.pubkey(), 1, &[&mint_authority])
-        .await
-        .unwrap();
-
-    // fail close
-    let destination = Pubkey::new_unique();
-    let err = token
-        .close_account(
-            token.get_address(),
-            &destination,
-            &close_authority.pubkey(),
-            &[&close_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintHasSupply as u32)
-            )
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/non_transferable.rs b/token/program-2022-test/tests/non_transferable.rs
deleted file mode 100644
index d0d36706196..00000000000
--- a/token/program-2022-test/tests/non_transferable.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            immutable_owner::ImmutableOwner, transfer_fee::TransferFee, BaseStateWithExtensions,
-            ExtensionType,
-        },
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-};
-
-#[tokio::test]
-async fn transfer() {
-    let test_transfer_amount = 100;
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::NonTransferable])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    // create token accounts
-    token
-        .create_auxiliary_token_account(&alice, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice.pubkey();
-
-    // immutable ownership is added to alice's account during initialization
-    token
-        .get_account_info(&alice_account)
-        .await
-        .unwrap()
-        .get_extension::<ImmutableOwner>()
-        .unwrap();
-
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &bob,
-            &bob.pubkey(),
-            vec![ExtensionType::ImmutableOwner],
-        )
-        .await
-        .unwrap();
-    let bob_account = bob.pubkey();
-
-    // mint to alice should be successful
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            test_transfer_amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    token
-        .mint_to(
-            &bob_account,
-            &mint_authority.pubkey(),
-            test_transfer_amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // self-transfer fails
-    let error = token
-        .transfer(
-            &bob_account,
-            &bob_account,
-            &bob.pubkey(),
-            test_transfer_amount,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // regular transfer fails
-    let error = token
-        .transfer(
-            &bob_account,
-            &alice_account,
-            &bob.pubkey(),
-            test_transfer_amount,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // regular unchecked transfer fails
-    let error = token_unchecked
-        .transfer(
-            &bob_account,
-            &alice_account,
-            &bob.pubkey(),
-            test_transfer_amount,
-            &[&bob],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn transfer_checked_with_fee() {
-    let test_transfer_amount = 100;
-    let maximum_fee = 10;
-    let transfer_fee_basis_points = 100;
-
-    let transfer_fee_config_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-
-    let transfer_fee = TransferFee {
-        epoch: 0.into(),
-        transfer_fee_basis_points: transfer_fee_basis_points.into(),
-        maximum_fee: maximum_fee.into(),
-    };
-
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![
-            ExtensionInitializationParams::TransferFeeConfig {
-                transfer_fee_config_authority: transfer_fee_config_authority.pubkey().into(),
-                withdraw_withheld_authority: withdraw_withheld_authority.pubkey().into(),
-                transfer_fee_basis_points,
-                maximum_fee,
-            },
-            ExtensionInitializationParams::NonTransferable,
-        ])
-        .await
-        .unwrap();
-
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    // create token accounts
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &alice,
-            &alice.pubkey(),
-            vec![ExtensionType::ImmutableOwner],
-        )
-        .await
-        .unwrap();
-    let alice_account = alice.pubkey();
-
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &bob,
-            &bob.pubkey(),
-            vec![ExtensionType::ImmutableOwner],
-        )
-        .await
-        .unwrap();
-    let bob_account = bob.pubkey();
-
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            test_transfer_amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // self-transfer fails
-    let error = token
-        .transfer(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            test_transfer_amount,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // regular transfer fails
-    let error = token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            test_transfer_amount,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // unchecked transfer fails
-    let error = token_unchecked
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            test_transfer_amount,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // self-transfer checked with fee fails
-    let fee = transfer_fee.calculate_fee(test_transfer_amount).unwrap();
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            test_transfer_amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-
-    // transfer checked with fee fails
-    let fee = transfer_fee.calculate_fee(test_transfer_amount).unwrap();
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            test_transfer_amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NonTransferable as u32)
-            )
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/permanent_delegate.rs b/token/program-2022-test/tests/permanent_delegate.rs
deleted file mode 100644
index 0543fadd0af..00000000000
--- a/token/program-2022-test/tests/permanent_delegate.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{permanent_delegate::PermanentDelegate, BaseStateWithExtensions},
-        instruction,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::convert::TryInto,
-};
-
-async fn setup_accounts(token_context: &TokenContext, amount: u64) -> (Pubkey, Pubkey) {
-    let alice_account = Keypair::new();
-    token_context
-        .token
-        .create_auxiliary_token_account(&alice_account, &token_context.alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-    let bob_account = Keypair::new();
-    token_context
-        .token
-        .create_auxiliary_token_account(&bob_account, &token_context.bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint tokens
-    token_context
-        .token
-        .mint_to(
-            &alice_account,
-            &token_context.mint_authority.pubkey(),
-            amount,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-    (alice_account, bob_account)
-}
-
-#[tokio::test]
-async fn success_init() {
-    let delegate = Pubkey::new_unique();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::PermanentDelegate {
-            delegate,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<PermanentDelegate>().unwrap();
-    assert_eq!(extension.delegate, Some(delegate).try_into().unwrap(),);
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let delegate = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::PermanentDelegate {
-            delegate: delegate.pubkey(),
-        }])
-        .await
-        .unwrap();
-    let token_context = context.token_context.unwrap();
-    let new_delegate = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token_context
-        .token
-        .set_authority(
-            token_context.token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_delegate.pubkey()),
-            instruction::AuthorityType::PermanentDelegate,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token_context
-        .token
-        .set_authority(
-            token_context.token.get_address(),
-            &delegate.pubkey(),
-            Some(&new_delegate.pubkey()),
-            instruction::AuthorityType::PermanentDelegate,
-            &[&delegate],
-        )
-        .await
-        .unwrap();
-    let state = token_context.token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<PermanentDelegate>().unwrap();
-    assert_eq!(
-        extension.delegate,
-        Some(new_delegate.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token_context
-        .token
-        .set_authority(
-            token_context.token.get_address(),
-            &new_delegate.pubkey(),
-            None,
-            instruction::AuthorityType::PermanentDelegate,
-            &[&new_delegate],
-        )
-        .await
-        .unwrap();
-    let state = token_context.token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<PermanentDelegate>().unwrap();
-    assert_eq!(extension.delegate, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token_context
-        .token
-        .set_authority(
-            token_context.token.get_address(),
-            &new_delegate.pubkey(),
-            Some(&delegate.pubkey()),
-            instruction::AuthorityType::PermanentDelegate,
-            &[&new_delegate],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-
-    // setup accounts
-    let amount = 10;
-    let (alice_account, bob_account) = setup_accounts(&token_context, amount).await;
-
-    // fail transfer
-    let error = token_context
-        .token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &new_delegate.pubkey(),
-            amount,
-            &[&new_delegate],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn success_transfer() {
-    let delegate = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::PermanentDelegate {
-            delegate: delegate.pubkey(),
-        }])
-        .await
-        .unwrap();
-    let token_context = context.token_context.unwrap();
-    let amount = 10;
-    let (alice_account, bob_account) = setup_accounts(&token_context, amount).await;
-
-    token_context
-        .token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &delegate.pubkey(),
-            amount,
-            &[&delegate],
-        )
-        .await
-        .unwrap();
-
-    let destination = token_context
-        .token
-        .get_account_info(&bob_account)
-        .await
-        .unwrap();
-    assert_eq!(destination.base.amount, amount);
-}
-
-#[tokio::test]
-async fn success_burn() {
-    let delegate = Keypair::new();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::PermanentDelegate {
-            delegate: delegate.pubkey(),
-        }])
-        .await
-        .unwrap();
-    let token_context = context.token_context.unwrap();
-    let amount = 10;
-    let (alice_account, _) = setup_accounts(&token_context, amount).await;
-
-    token_context
-        .token
-        .burn(&alice_account, &delegate.pubkey(), amount, &[&delegate])
-        .await
-        .unwrap();
-
-    let destination = token_context
-        .token
-        .get_account_info(&alice_account)
-        .await
-        .unwrap();
-    assert_eq!(destination.base.amount, 0);
-}
-
-#[tokio::test]
-async fn fail_without_extension() {
-    let delegate = Pubkey::new_unique();
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let token_context = context.token_context.unwrap();
-
-    // fail set
-    let err = token_context
-        .token
-        .set_authority(
-            token_context.token.get_address(),
-            &token_context.mint_authority.pubkey(),
-            Some(&delegate),
-            instruction::AuthorityType::PermanentDelegate,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/program_test.rs b/token/program-2022-test/tests/program_test.rs
deleted file mode 100644
index 0d4979383b4..00000000000
--- a/token/program-2022-test/tests/program_test.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-#![allow(dead_code)]
-
-use {
-    solana_program_test::{processor, tokio::sync::Mutex, ProgramTest, ProgramTestContext},
-    solana_sdk::{
-        pubkey::Pubkey,
-        signer::{keypair::Keypair, Signer},
-    },
-    spl_token_2022::{
-        extension::{
-            confidential_transfer::ConfidentialTransferAccount, BaseStateWithExtensions,
-            ExtensionType,
-        },
-        id, native_mint,
-        processor::Processor,
-        solana_zk_token_sdk::encryption::{auth_encryption::*, elgamal::*},
-    },
-    spl_token_client::{
-        client::{
-            ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient,
-            SendTransaction, SimulateTransaction,
-        },
-        token::{ComputeUnitLimit, ExtensionInitializationParams, Token, TokenResult},
-    },
-    std::sync::Arc,
-};
-
-pub struct TokenContext {
-    pub decimals: u8,
-    pub mint_authority: Keypair,
-    pub token: Token<ProgramBanksClientProcessTransaction>,
-    pub token_unchecked: Token<ProgramBanksClientProcessTransaction>,
-    pub alice: Keypair,
-    pub bob: Keypair,
-    pub freeze_authority: Option<Keypair>,
-}
-
-pub struct TestContext {
-    pub context: Arc<Mutex<ProgramTestContext>>,
-    pub token_context: Option<TokenContext>,
-}
-
-impl TestContext {
-    pub async fn new() -> Self {
-        let program_test = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-        let context = program_test.start_with_context().await;
-        let context = Arc::new(Mutex::new(context));
-
-        Self {
-            context,
-            token_context: None,
-        }
-    }
-
-    pub async fn init_token_with_mint(
-        &mut self,
-        extension_init_params: Vec<ExtensionInitializationParams>,
-    ) -> TokenResult<()> {
-        self.init_token_with_mint_and_freeze_authority(extension_init_params, None)
-            .await
-    }
-
-    pub async fn init_token_with_freezing_mint(
-        &mut self,
-        extension_init_params: Vec<ExtensionInitializationParams>,
-    ) -> TokenResult<()> {
-        let freeze_authority = Keypair::new();
-        self.init_token_with_mint_and_freeze_authority(
-            extension_init_params,
-            Some(freeze_authority),
-        )
-        .await
-    }
-
-    pub async fn init_token_with_mint_and_freeze_authority(
-        &mut self,
-        extension_init_params: Vec<ExtensionInitializationParams>,
-        freeze_authority: Option<Keypair>,
-    ) -> TokenResult<()> {
-        let mint_account = Keypair::new();
-        self.init_token_with_mint_keypair_and_freeze_authority(
-            mint_account,
-            extension_init_params,
-            freeze_authority,
-        )
-        .await
-    }
-
-    pub async fn init_token_with_mint_keypair_and_freeze_authority(
-        &mut self,
-        mint_account: Keypair,
-        extension_init_params: Vec<ExtensionInitializationParams>,
-        freeze_authority: Option<Keypair>,
-    ) -> TokenResult<()> {
-        let payer = keypair_clone(&self.context.lock().await.payer);
-        let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
-            Arc::new(ProgramBanksClient::new_from_context(
-                Arc::clone(&self.context),
-                ProgramBanksClientProcessTransaction,
-            ));
-
-        let decimals: u8 = 9;
-
-        let mint_authority = Keypair::new();
-        let mint_authority_pubkey = mint_authority.pubkey();
-        let freeze_authority_pubkey = freeze_authority
-            .as_ref()
-            .map(|authority| authority.pubkey());
-
-        let token = Token::new(
-            Arc::clone(&client),
-            &id(),
-            &mint_account.pubkey(),
-            Some(decimals),
-            Arc::new(keypair_clone(&payer)),
-        )
-        .with_compute_unit_limit(ComputeUnitLimit::Simulated);
-
-        let token_unchecked = Token::new(
-            Arc::clone(&client),
-            &id(),
-            &mint_account.pubkey(),
-            None,
-            Arc::new(payer),
-        )
-        .with_compute_unit_limit(ComputeUnitLimit::Simulated);
-
-        token
-            .create_mint(
-                &mint_authority_pubkey,
-                freeze_authority_pubkey.as_ref(),
-                extension_init_params,
-                &[&mint_account],
-            )
-            .await?;
-
-        self.token_context = Some(TokenContext {
-            decimals,
-            mint_authority,
-            token,
-            token_unchecked,
-            alice: Keypair::new(),
-            bob: Keypair::new(),
-            freeze_authority,
-        });
-
-        Ok(())
-    }
-
-    pub async fn init_token_with_native_mint(&mut self) -> TokenResult<()> {
-        let payer = keypair_clone(&self.context.lock().await.payer);
-        let client: Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
-            Arc::new(ProgramBanksClient::new_from_context(
-                Arc::clone(&self.context),
-                ProgramBanksClientProcessTransaction,
-            ));
-
-        let token =
-            Token::create_native_mint(Arc::clone(&client), &id(), Arc::new(keypair_clone(&payer)))
-                .await?;
-        // unchecked native is never needed because decimals is known statically
-        let token_unchecked = Token::new_native(Arc::clone(&client), &id(), Arc::new(payer))
-            .with_compute_unit_limit(ComputeUnitLimit::Simulated);
-        self.token_context = Some(TokenContext {
-            decimals: native_mint::DECIMALS,
-            mint_authority: Keypair::new(), /* bogus */
-            token,
-            token_unchecked,
-            alice: Keypair::new(),
-            bob: Keypair::new(),
-            freeze_authority: None,
-        });
-        Ok(())
-    }
-}
-
-pub(crate) fn keypair_clone(kp: &Keypair) -> Keypair {
-    Keypair::from_bytes(&kp.to_bytes()).expect("failed to copy keypair")
-}
-
-pub(crate) struct ConfidentialTokenAccountMeta {
-    pub(crate) token_account: Pubkey,
-    pub(crate) elgamal_keypair: ElGamalKeypair,
-    pub(crate) aes_key: AeKey,
-}
-
-impl ConfidentialTokenAccountMeta {
-    pub(crate) async fn new<T>(
-        token: &Token<T>,
-        owner: &Keypair,
-        maximum_pending_balance_credit_counter: Option<u64>,
-        require_memo: bool,
-        require_fee: bool,
-    ) -> Self
-    where
-        T: SendTransaction + SimulateTransaction,
-    {
-        let token_account_keypair = Keypair::new();
-
-        let mut extensions = vec![ExtensionType::ConfidentialTransferAccount];
-        if require_memo {
-            extensions.push(ExtensionType::MemoTransfer);
-        }
-        if require_fee {
-            extensions.push(ExtensionType::ConfidentialTransferFeeAmount);
-        }
-
-        token
-            .create_auxiliary_token_account_with_extension_space(
-                &token_account_keypair,
-                &owner.pubkey(),
-                extensions,
-            )
-            .await
-            .unwrap();
-        let token_account = token_account_keypair.pubkey();
-
-        let elgamal_keypair =
-            ElGamalKeypair::new_from_signer(owner, &token_account.to_bytes()).unwrap();
-        let aes_key = AeKey::new_from_signer(owner, &token_account.to_bytes()).unwrap();
-
-        token
-            .confidential_transfer_configure_token_account(
-                &token_account,
-                &owner.pubkey(),
-                None,
-                maximum_pending_balance_credit_counter,
-                &elgamal_keypair,
-                &aes_key,
-                &[owner],
-            )
-            .await
-            .unwrap();
-
-        if require_memo {
-            token
-                .enable_required_transfer_memos(&token_account, &owner.pubkey(), &[owner])
-                .await
-                .unwrap();
-        }
-
-        Self {
-            token_account,
-            elgamal_keypair,
-            aes_key,
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    #[cfg(feature = "zk-ops")]
-    pub(crate) async fn new_with_tokens<T>(
-        token: &Token<T>,
-        owner: &Keypair,
-        maximum_pending_balance_credit_counter: Option<u64>,
-        require_memo: bool,
-        require_fee: bool,
-        mint_authority: &Keypair,
-        amount: u64,
-        decimals: u8,
-    ) -> Self
-    where
-        T: SendTransaction + SimulateTransaction,
-    {
-        let meta = Self::new(
-            token,
-            owner,
-            maximum_pending_balance_credit_counter,
-            require_memo,
-            require_fee,
-        )
-        .await;
-
-        token
-            .mint_to(
-                &meta.token_account,
-                &mint_authority.pubkey(),
-                amount,
-                &[mint_authority],
-            )
-            .await
-            .unwrap();
-
-        token
-            .confidential_transfer_deposit(
-                &meta.token_account,
-                &owner.pubkey(),
-                amount,
-                decimals,
-                &[owner],
-            )
-            .await
-            .unwrap();
-
-        token
-            .confidential_transfer_apply_pending_balance(
-                &meta.token_account,
-                &owner.pubkey(),
-                None,
-                meta.elgamal_keypair.secret(),
-                &meta.aes_key,
-                &[owner],
-            )
-            .await
-            .unwrap();
-        meta
-    }
-
-    #[cfg(feature = "zk-ops")]
-    pub(crate) async fn check_balances<T>(
-        &self,
-        token: &Token<T>,
-        expected: ConfidentialTokenAccountBalances,
-    ) where
-        T: SendTransaction + SimulateTransaction,
-    {
-        let state = token.get_account_info(&self.token_account).await.unwrap();
-        let extension = state
-            .get_extension::<ConfidentialTransferAccount>()
-            .unwrap();
-
-        assert_eq!(
-            extension
-                .pending_balance_lo
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.pending_balance_lo,
-        );
-        assert_eq!(
-            extension
-                .pending_balance_hi
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.pending_balance_hi,
-        );
-        assert_eq!(
-            extension
-                .available_balance
-                .decrypt(self.elgamal_keypair.secret())
-                .unwrap(),
-            expected.available_balance,
-        );
-        assert_eq!(
-            self.aes_key
-                .decrypt(&extension.decryptable_available_balance.try_into().unwrap())
-                .unwrap(),
-            expected.decryptable_available_balance,
-        );
-    }
-}
-
-#[cfg(feature = "zk-ops")]
-pub(crate) struct ConfidentialTokenAccountBalances {
-    pub(crate) pending_balance_lo: u64,
-    pub(crate) pending_balance_hi: u64,
-    pub(crate) available_balance: u64,
-    pub(crate) decryptable_available_balance: u64,
-}
diff --git a/token/program-2022-test/tests/reallocate.rs b/token/program-2022-test/tests/reallocate.rs
deleted file mode 100644
index 733dfd1aca0..00000000000
--- a/token/program-2022-test/tests/reallocate.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError,
-        program_option::COption,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{error::TokenError, extension::ExtensionType, state::Account},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    std::convert::TryInto,
-    test_case::test_case,
-};
-
-#[tokio::test]
-async fn reallocate() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let TokenContext {
-        token,
-        alice,
-        mint_authority,
-        ..
-    } = context.token_context.unwrap();
-
-    // reallocate fails on wrong account type
-    let error = token
-        .reallocate(
-            token.get_address(),
-            &mint_authority.pubkey(),
-            &[ExtensionType::ImmutableOwner],
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-
-    // create account just large enough for base
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // reallocate fails on invalid extension type
-    let error = token
-        .reallocate(
-            &alice_account,
-            &alice.pubkey(),
-            &[ExtensionType::MintCloseAuthority],
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InvalidState as u32)
-            )
-        )))
-    );
-
-    // reallocate fails on invalid authority
-    let error = token
-        .reallocate(
-            &alice_account,
-            &mint_authority.pubkey(),
-            &[ExtensionType::ImmutableOwner],
-            &[&mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // reallocate succeeds
-    token
-        .reallocate(
-            &alice_account,
-            &alice.pubkey(),
-            &[ExtensionType::ImmutableOwner],
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let account = token.get_account(alice_account).await.unwrap();
-    assert_eq!(
-        account.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap()
-    );
-
-    // reallocate succeeds with noop if account is already large enough
-    token.get_new_latest_blockhash().await.unwrap();
-    token
-        .reallocate(
-            &alice_account,
-            &alice.pubkey(),
-            &[ExtensionType::ImmutableOwner],
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let account = token.get_account(alice_account).await.unwrap();
-    assert_eq!(
-        account.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-            .unwrap()
-    );
-
-    // reallocate only reallocates enough for new extension, and dedupes extensions
-    token
-        .reallocate(
-            &alice_account,
-            &alice.pubkey(),
-            &[
-                ExtensionType::ImmutableOwner,
-                ExtensionType::ImmutableOwner,
-                ExtensionType::TransferFeeAmount,
-                ExtensionType::TransferFeeAmount,
-            ],
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let account = token.get_account(alice_account).await.unwrap();
-    assert_eq!(
-        account.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(&[
-            ExtensionType::ImmutableOwner,
-            ExtensionType::TransferFeeAmount
-        ])
-        .unwrap()
-    );
-}
-
-#[tokio::test]
-async fn reallocate_without_current_extension_knowledge() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: COption::Some(Pubkey::new_unique()).try_into().unwrap(),
-            withdraw_withheld_authority: COption::Some(Pubkey::new_unique()).try_into().unwrap(),
-            transfer_fee_basis_points: 250,
-            maximum_fee: 10_000_000,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-
-    // create account just large enough for TransferFeeAmount extension
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // reallocate resizes account to accommodate new and existing extensions
-    token
-        .reallocate(
-            &alice_account,
-            &alice.pubkey(),
-            &[ExtensionType::ImmutableOwner],
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let account = token.get_account(alice_account).await.unwrap();
-    assert_eq!(
-        account.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(&[
-            ExtensionType::TransferFeeAmount,
-            ExtensionType::ImmutableOwner
-        ])
-        .unwrap()
-    );
-}
-
-#[test_case(&[ExtensionType::CpiGuard], 1_000_000_000, true ; "transfer more than new rent and sync")]
-#[test_case(&[ExtensionType::CpiGuard], 1_000_000_000, false ; "transfer more than new rent")]
-#[test_case(&[ExtensionType::CpiGuard], 1, true ; "transfer less than new rent and sync")]
-#[test_case(&[ExtensionType::CpiGuard], 1, false ; "transfer less than new rent")]
-#[test_case(&[ExtensionType::CpiGuard], 0, false ; "no transfer with extension")]
-#[test_case(&[], 1_000_000_000, true ; "transfer lamports and sync without extension")]
-#[test_case(&[], 1_000_000_000, false ; "transfer lamports without extension")]
-#[test_case(&[], 0, false ; "no transfer without extension")]
-#[tokio::test]
-async fn reallocate_updates_native_rent_exemption(
-    extensions: &[ExtensionType],
-    transfer_lamports: u64,
-    sync_native: bool,
-) {
-    let mut context = TestContext::new().await;
-    context.init_token_with_native_mint().await.unwrap();
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-    let context = context.context.clone();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // transfer more lamports
-    if transfer_lamports > 0 {
-        let mut context = context.lock().await;
-        let instructions = vec![system_instruction::transfer(
-            &context.payer.pubkey(),
-            &alice_account,
-            transfer_lamports,
-        )];
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&context.payer.pubkey()),
-            &[&context.payer],
-            context.last_blockhash,
-        );
-        context.banks_client.process_transaction(tx).await.unwrap();
-    }
-
-    // amount in the account should be 0 no matter what
-    let account_info = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(account_info.base.amount, 0);
-
-    if sync_native {
-        token.sync_native(&alice_account).await.unwrap();
-        let account_info = token.get_account_info(&alice_account).await.unwrap();
-        assert_eq!(account_info.base.amount, transfer_lamports);
-    }
-
-    let token_account = token.get_account_info(&alice_account).await.unwrap();
-    let pre_amount = token_account.base.amount;
-    let pre_rent_exempt_reserve = token_account.base.is_native.unwrap();
-
-    // reallocate resizes account to accommodate new extension
-    token
-        .reallocate(&alice_account, &alice.pubkey(), extensions, &[&alice])
-        .await
-        .unwrap();
-
-    let account = token.get_account(alice_account).await.unwrap();
-    assert_eq!(
-        account.data.len(),
-        ExtensionType::try_calculate_account_len::<Account>(extensions).unwrap()
-    );
-    let expected_rent_exempt_reserve = {
-        let mut context = context.lock().await;
-        let rent = context.banks_client.get_rent().await.unwrap();
-        rent.minimum_balance(account.data.len())
-    };
-    let token_account = token.get_account_info(&alice_account).await.unwrap();
-    let post_amount = token_account.base.amount;
-    let post_rent_exempt_reserve = token_account.base.is_native.unwrap();
-    // amount of lamports should be totally unchanged
-    assert_eq!(pre_amount, post_amount);
-    // but rent exempt reserve should change
-    assert_eq!(post_rent_exempt_reserve, expected_rent_exempt_reserve);
-    if extensions.is_empty() {
-        assert_eq!(pre_rent_exempt_reserve, post_rent_exempt_reserve);
-    } else {
-        assert!(pre_rent_exempt_reserve < post_rent_exempt_reserve);
-    }
-}
diff --git a/token/program-2022-test/tests/sync_native.rs b/token/program-2022-test/tests/sync_native.rs
deleted file mode 100644
index 59cd489cf13..00000000000
--- a/token/program-2022-test/tests/sync_native.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::{
-        tokio::{self, sync::Mutex},
-        ProgramTestContext,
-    },
-    solana_sdk::{
-        pubkey::Pubkey, signature::Signer, signer::keypair::Keypair, system_instruction,
-        transaction::Transaction,
-    },
-    spl_token_2022::extension::ExtensionType,
-    spl_token_client::{client::ProgramBanksClientProcessTransaction, token::Token},
-    std::sync::Arc,
-};
-
-async fn run_basic(
-    token: Token<ProgramBanksClientProcessTransaction>,
-    context: Arc<Mutex<ProgramTestContext>>,
-    account: Pubkey,
-) {
-    let account_info = token.get_account_info(&account).await.unwrap();
-    assert_eq!(account_info.base.amount, 0);
-
-    // system transfer to account
-    let amount = 1_000;
-    {
-        let mut context = context.lock().await;
-        let instructions = vec![system_instruction::transfer(
-            &context.payer.pubkey(),
-            &account,
-            amount,
-        )];
-        let tx = Transaction::new_signed_with_payer(
-            &instructions,
-            Some(&context.payer.pubkey()),
-            &[&context.payer],
-            context.last_blockhash,
-        );
-        context.banks_client.process_transaction(tx).await.unwrap();
-    }
-    let account_info = token.get_account_info(&account).await.unwrap();
-    assert_eq!(account_info.base.amount, 0);
-
-    token.sync_native(&account).await.unwrap();
-    let account_info = token.get_account_info(&account).await.unwrap();
-    assert_eq!(account_info.base.amount, amount);
-}
-
-#[tokio::test]
-async fn basic() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_native_mint().await.unwrap();
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-    let context = context.context.clone();
-
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &alice.pubkey())
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    run_basic(token, context, account).await;
-}
-
-#[tokio::test]
-async fn basic_with_extension() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_native_mint().await.unwrap();
-    let TokenContext { token, alice, .. } = context.token_context.unwrap();
-    let context = context.context.clone();
-
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account_with_extension_space(
-            &account,
-            &alice.pubkey(),
-            vec![ExtensionType::ImmutableOwner],
-        )
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    run_basic(token, context, account).await;
-}
diff --git a/token/program-2022-test/tests/token_group_initialize.rs b/token/program-2022-test/tests/token_group_initialize.rs
deleted file mode 100644
index e9d1296c31f..00000000000
--- a/token/program-2022-test/tests/token_group_initialize.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_pod::bytemuck::pod_from_bytes,
-    spl_token_2022::{error::TokenError, extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_group_interface::{error::TokenGroupError, state::TokenGroup},
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let group_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(*authority),
-                group_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_initialize() {
-    let authority = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Pubkey::new_unique();
-    let max_size = 10;
-    let token_group = TokenGroup::new(
-        token_context.token.get_address(),
-        Some(update_authority).try_into().unwrap(),
-        max_size,
-    );
-
-    // fails without more lamports for new rent-exemption
-    let error = token_context
-        .token
-        .token_group_initialize(
-            &token_context.mint_authority.pubkey(),
-            &update_authority,
-            max_size,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InsufficientFundsForRent { account_index: 2 }
-        )))
-    );
-
-    // fail wrong signer
-    let not_mint_authority = Keypair::new();
-    let error = token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &not_mint_authority.pubkey(),
-            &update_authority,
-            max_size,
-            &[&not_mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenGroupError::IncorrectMintAuthority as u32)
-            )
-        )))
-    );
-
-    token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority,
-            max_size,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let mint_info = token_context.token.get_mint_info().await.unwrap();
-    let group_bytes = mint_info.get_extension_bytes::<TokenGroup>().unwrap();
-    let fetched_group = pod_from_bytes::<TokenGroup>(group_bytes).unwrap();
-    assert_eq!(fetched_group, &token_group);
-
-    // fail double-init
-    let error = token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority,
-            12, // Change so we get a different transaction
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0, // No additional rent
-                InstructionError::Custom(TokenError::ExtensionAlreadyInitialized as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_group_pointer() {
-    let mut test_context = {
-        let mint_keypair = Keypair::new();
-        let program_test = setup_program_test();
-        let context = program_test.start_with_context().await;
-        let context = Arc::new(tokio::sync::Mutex::new(context));
-        let mut context = TestContext {
-            context,
-            token_context: None,
-        };
-        context
-            .init_token_with_mint_keypair_and_freeze_authority(mint_keypair, vec![], None)
-            .await
-            .unwrap();
-        context
-    };
-
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let error = token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &Pubkey::new_unique(),
-            5,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_init_in_another_mint() {
-    let authority = Pubkey::new_unique();
-    let first_mint_keypair = Keypair::new();
-    let first_mint = first_mint_keypair.pubkey();
-    let mut test_context = setup(first_mint_keypair, &authority).await;
-    let second_mint_keypair = Keypair::new();
-    let second_mint = second_mint_keypair.pubkey();
-    test_context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            second_mint_keypair,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(authority),
-                group_address: Some(second_mint),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-
-    let token_context = test_context.token_context.take().unwrap();
-
-    let error = token_context
-        .token
-        .process_ixs(
-            &[spl_token_group_interface::instruction::initialize_group(
-                &spl_token_2022::id(),
-                &first_mint,
-                token_context.token.get_address(),
-                &token_context.mint_authority.pubkey(),
-                Some(Pubkey::new_unique()),
-                5,
-            )],
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_signature() {
-    let authority = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority).await;
-
-    let token_context = test_context.token_context.take().unwrap();
-
-    let mut instruction = spl_token_group_interface::instruction::initialize_group(
-        &spl_token_2022::id(),
-        token_context.token.get_address(),
-        token_context.token.get_address(),
-        &token_context.mint_authority.pubkey(),
-        Some(Pubkey::new_unique()),
-        5,
-    );
-    instruction.accounts[2].is_signer = false;
-    let error = token_context
-        .token
-        .process_ixs(&[instruction], &[] as &[&dyn Signer; 0]) // yuck, but the compiler needs it
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/token_group_initialize_member.rs b/token/program-2022-test/tests/token_group_initialize_member.rs
deleted file mode 100644
index 53413010032..00000000000
--- a/token/program-2022-test/tests/token_group_initialize_member.rs
+++ /dev/null
@@ -1,490 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_pod::bytemuck::pod_from_bytes,
-    spl_token_2022::{error::TokenError, extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_group_interface::{error::TokenGroupError, state::TokenGroupMember},
-    std::sync::Arc,
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-type SetupConfig = (Keypair, Pubkey); // Mint, Authority
-
-async fn setup(group: SetupConfig, members: Vec<SetupConfig>) -> (TestContext, Vec<TestContext>) {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut group_context = TestContext {
-        context: context.clone(),
-        token_context: None,
-    };
-
-    let (group_mint, group_authority) = group;
-    let group_address = Some(group_mint.pubkey());
-    group_context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            group_mint,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(group_authority),
-                group_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-
-    let mut member_contexts = vec![];
-    for member in members.into_iter() {
-        let (member_mint, member_authority) = member;
-        let member_address = Some(member_mint.pubkey());
-        let mut member_context = TestContext {
-            context: context.clone(),
-            token_context: None,
-        };
-        member_context
-            .init_token_with_mint_keypair_and_freeze_authority(
-                member_mint,
-                vec![ExtensionInitializationParams::GroupMemberPointer {
-                    authority: Some(member_authority),
-                    member_address,
-                }],
-                None,
-            )
-            .await
-            .unwrap();
-        member_contexts.push(member_context);
-    }
-
-    let payer_pubkey = group_context.context.lock().await.payer.pubkey();
-    let group_token_context = group_context.token_context.as_ref().unwrap();
-    group_token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &group_token_context.mint_authority.pubkey(),
-            &group_authority,
-            2,
-            &[&group_token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    (group_context, member_contexts)
-}
-
-#[tokio::test]
-async fn success_initialize() {
-    let group_authority = Keypair::new();
-    let group_mint_keypair = Keypair::new();
-    let member1_authority = Keypair::new();
-    let member1_mint_keypair = Keypair::new();
-    let member2_authority = Keypair::new();
-    let member2_mint_keypair = Keypair::new();
-    let member3_authority = Keypair::new();
-    let member3_mint_keypair = Keypair::new();
-
-    let (_, mut member_contexts) = setup(
-        (
-            group_mint_keypair.insecure_clone(),
-            group_authority.pubkey(),
-        ),
-        vec![
-            (
-                member1_mint_keypair.insecure_clone(),
-                member1_authority.pubkey(),
-            ),
-            (
-                member2_mint_keypair.insecure_clone(),
-                member2_authority.pubkey(),
-            ),
-            (
-                member3_mint_keypair.insecure_clone(),
-                member3_authority.pubkey(),
-            ),
-        ],
-    )
-    .await;
-
-    let member1_token_context = member_contexts[0].token_context.take().unwrap();
-
-    // fails without more lamports for new rent-exemption
-    let error = member1_token_context
-        .token
-        .token_group_initialize_member(
-            &member1_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member1_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    let member_index = if group_mint_keypair
-        .pubkey()
-        .cmp(&member1_mint_keypair.pubkey())
-        .is_le()
-    {
-        4
-    } else {
-        3
-    };
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InsufficientFundsForRent {
-                account_index: member_index
-            }
-        )))
-    );
-
-    // fail wrong mint authority signer
-    let payer_pubkey = member_contexts[0].context.lock().await.payer.pubkey();
-    let not_mint_authority = Keypair::new();
-    let error = member1_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &not_mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&not_mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenGroupError::IncorrectMintAuthority as u32)
-            )
-        )))
-    );
-
-    // fail wrong group update authority signer
-    let not_group_update_authority = Keypair::new();
-    let error = member1_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member1_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &not_group_update_authority.pubkey(),
-            &[
-                &member1_token_context.mint_authority,
-                &not_group_update_authority,
-            ],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32)
-            )
-        )))
-    );
-
-    // fail group and member same mint
-    let error = member1_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member1_token_context.mint_authority.pubkey(),
-            member1_token_context.token.get_address(),
-            &group_authority.pubkey(),
-            &[&member1_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenGroupError::MemberAccountIsGroupAccount as u32)
-            )
-        )))
-    );
-
-    member1_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member1_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member1_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let mint_info = member1_token_context.token.get_mint_info().await.unwrap();
-    let member_bytes = mint_info.get_extension_bytes::<TokenGroupMember>().unwrap();
-    let fetched_member = pod_from_bytes::<TokenGroupMember>(member_bytes).unwrap();
-    assert_eq!(
-        fetched_member,
-        &TokenGroupMember {
-            mint: member1_mint_keypair.pubkey(),
-            group: group_mint_keypair.pubkey(),
-            member_number: 1.try_into().unwrap(),
-        }
-    );
-
-    // fail double-init
-    {
-        let mut context = member_contexts[0].context.lock().await;
-        context.get_new_latest_blockhash().await.unwrap();
-        context.get_new_latest_blockhash().await.unwrap();
-    }
-    let error = member1_token_context
-        .token
-        .token_group_initialize_member(
-            &member1_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member1_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::ExtensionAlreadyInitialized as u32)
-            )
-        )))
-    );
-
-    // Now the second
-    let member2_token_context = member_contexts[1].token_context.take().unwrap();
-    member2_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member2_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member2_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap();
-    let mint_info = member2_token_context.token.get_mint_info().await.unwrap();
-    let member_bytes = mint_info.get_extension_bytes::<TokenGroupMember>().unwrap();
-    let fetched_member = pod_from_bytes::<TokenGroupMember>(member_bytes).unwrap();
-    assert_eq!(
-        fetched_member,
-        &TokenGroupMember {
-            mint: member2_mint_keypair.pubkey(),
-            group: group_mint_keypair.pubkey(),
-            member_number: 2.try_into().unwrap(),
-        }
-    );
-
-    // Third should fail on max size
-    let member3_token_context = member_contexts[2].token_context.take().unwrap();
-    let error = member3_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member3_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member3_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenGroupError::SizeExceedsMaxSize as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_member_pointer() {
-    let group_authority = Keypair::new();
-    let group_mint_keypair = Keypair::new();
-    let member_mint_keypair = Keypair::new();
-
-    let (group_context, _) = setup(
-        (
-            group_mint_keypair.insecure_clone(),
-            group_authority.pubkey(),
-        ),
-        vec![],
-    )
-    .await;
-
-    let mut member_test_context = TestContext {
-        context: group_context.context.clone(),
-        token_context: None,
-    };
-    member_test_context
-        .init_token_with_mint_keypair_and_freeze_authority(member_mint_keypair, vec![], None)
-        .await
-        .unwrap();
-
-    let payer_pubkey = member_test_context.context.lock().await.payer.pubkey();
-    let member_token_context = member_test_context.token_context.take().unwrap();
-
-    let error = member_token_context
-        .token
-        .token_group_initialize_member_with_rent_transfer(
-            &payer_pubkey,
-            &member_token_context.mint_authority.pubkey(),
-            &group_mint_keypair.pubkey(),
-            &group_authority.pubkey(),
-            &[&member_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_init_in_another_mint() {
-    let group_authority = Keypair::new();
-    let group_mint_keypair = Keypair::new();
-    let member_authority = Keypair::new();
-    let first_member_mint_keypair = Keypair::new();
-    let second_member_mint_keypair = Keypair::new();
-
-    let (_, mut member_contexts) = setup(
-        (
-            group_mint_keypair.insecure_clone(),
-            group_authority.pubkey(),
-        ),
-        vec![(
-            second_member_mint_keypair.insecure_clone(),
-            member_authority.pubkey(),
-        )],
-    )
-    .await;
-
-    let member_token_context = member_contexts[0].token_context.take().unwrap();
-    let error = member_token_context
-        .token
-        .process_ixs(
-            &[spl_token_group_interface::instruction::initialize_member(
-                &spl_token_2022::id(),
-                &first_member_mint_keypair.pubkey(),
-                member_token_context.token.get_address(),
-                &member_token_context.mint_authority.pubkey(),
-                &group_mint_keypair.pubkey(),
-                &group_authority.pubkey(),
-            )],
-            &[&member_token_context.mint_authority, &group_authority],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_signatures() {
-    let group_authority = Keypair::new();
-    let group_mint_keypair = Keypair::new();
-    let member_authority = Keypair::new();
-    let member_mint_keypair = Keypair::new();
-
-    let (_, mut member_contexts) = setup(
-        (
-            group_mint_keypair.insecure_clone(),
-            group_authority.pubkey(),
-        ),
-        vec![(
-            member_mint_keypair.insecure_clone(),
-            member_authority.pubkey(),
-        )],
-    )
-    .await;
-
-    let member_token_context = member_contexts[0].token_context.take().unwrap();
-
-    // Missing mint authority
-    let mut instruction = spl_token_group_interface::instruction::initialize_member(
-        &spl_token_2022::id(),
-        &member_mint_keypair.pubkey(),
-        member_token_context.token.get_address(),
-        &member_token_context.mint_authority.pubkey(),
-        &group_mint_keypair.pubkey(),
-        &group_authority.pubkey(),
-    );
-    instruction.accounts[2].is_signer = false;
-    let error = member_token_context
-        .token
-        .process_ixs(&[instruction], &[&group_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-
-    // Missing group update authority
-    let mut instruction = spl_token_group_interface::instruction::initialize_member(
-        &spl_token_2022::id(),
-        &member_mint_keypair.pubkey(),
-        member_token_context.token.get_address(),
-        &member_token_context.mint_authority.pubkey(),
-        &group_mint_keypair.pubkey(),
-        &group_authority.pubkey(),
-    );
-    instruction.accounts[4].is_signer = false;
-    let error = member_token_context
-        .token
-        .process_ixs(&[instruction], &[&member_token_context.mint_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/token_group_update_authority.rs b/token/program-2022-test/tests/token_group_update_authority.rs
deleted file mode 100644
index a6f047b2c2a..00000000000
--- a/token/program-2022-test/tests/token_group_update_authority.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_group_interface::{
-        error::TokenGroupError, instruction::update_group_authority, state::TokenGroup,
-    },
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let group_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(*authority),
-                group_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_update() {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair.insecure_clone(), &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let mut token_group = TokenGroup::new(
-        &mint_keypair.pubkey(),
-        Some(update_authority.pubkey()).try_into().unwrap(),
-        10,
-    );
-
-    token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority.pubkey(),
-            10,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let new_update_authority = Keypair::new();
-    let new_update_authority_pubkey =
-        OptionalNonZeroPubkey::try_from(Some(new_update_authority.pubkey())).unwrap();
-    token_group.update_authority = new_update_authority_pubkey;
-
-    token_context
-        .token
-        .token_group_update_authority(
-            &update_authority.pubkey(),
-            Some(new_update_authority.pubkey()),
-            &[&update_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let mint = token_context.token.get_mint_info().await.unwrap();
-    let fetched_group = mint.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(fetched_group, &token_group);
-
-    // unset
-    token_group.update_authority = None.try_into().unwrap();
-    token_context
-        .token
-        .token_group_update_authority(
-            &new_update_authority.pubkey(),
-            None,
-            &[&new_update_authority],
-        )
-        .await
-        .unwrap();
-
-    let mint = token_context.token.get_mint_info().await.unwrap();
-    let fetched_group = mint.get_extension::<TokenGroup>().unwrap();
-    assert_eq!(fetched_group, &token_group);
-
-    // fail to update
-    let error = token_context
-        .token
-        .token_group_update_authority(
-            &new_update_authority.pubkey(),
-            Some(new_update_authority.pubkey()),
-            &[&new_update_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenGroupError::ImmutableGroup as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = spl_token_2022::id();
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority.pubkey(),
-            10,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // wrong authority
-    let error = token_context
-        .token
-        .token_group_update_authority(&payer_pubkey, None, &[] as &[&dyn Signer; 0])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32),
-            )
-        )))
-    );
-
-    // no signature
-    let mut context = test_context.context.lock().await;
-    let mut instruction =
-        update_group_authority(&program_id, &mint_pubkey, &authority.pubkey(), None);
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-}
diff --git a/token/program-2022-test/tests/token_group_update_max_size.rs b/token/program-2022-test/tests/token_group_update_max_size.rs
deleted file mode 100644
index 9e8382fae20..00000000000
--- a/token/program-2022-test/tests/token_group_update_max_size.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-#![cfg(feature = "test-sbf")]
-#![allow(clippy::items_after_test_module)]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        account::Account as SolanaAccount, instruction::InstructionError, pubkey::Pubkey,
-        signature::Signer, signer::keypair::Keypair, transaction::TransactionError,
-        transport::TransportError,
-    },
-    spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_group_interface::{
-        error::TokenGroupError, instruction::update_group_max_size, state::TokenGroup,
-    },
-    std::{convert::TryInto, sync::Arc},
-    test_case::test_case,
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let group_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::GroupPointer {
-                authority: Some(*authority),
-                group_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-// Successful attempts to set higher than size
-#[test_case(0, 0, 10)]
-#[test_case(5, 0, 10)]
-#[test_case(50, 0, 200_000)]
-#[test_case(100_000, 100_000, 200_000)]
-#[test_case(50, 0, 300_000_000)]
-#[test_case(100_000, 100_000, 300_000_000)]
-#[test_case(100_000_000, 100_000_000, 300_000_000)]
-#[test_case(0, 0, u32::MAX)]
-#[test_case(200_000, 200_000, u32::MAX)]
-#[test_case(300_000_000, 300_000_000, u32::MAX)]
-// Attempts to set lower than size
-#[test_case(5, 5, 4)]
-#[test_case(200_000, 200_000, 50)]
-#[test_case(200_000, 200_000, 100_000)]
-#[test_case(300_000_000, 300_000_000, 50)]
-#[test_case(u32::MAX, u32::MAX, 0)]
-#[tokio::test]
-async fn test_update_group_max_size(max_size: u32, size: u32, new_max_size: u32) {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair.insecure_clone(), &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let mut token_group = TokenGroup::new(
-        &mint_keypair.pubkey(),
-        Some(update_authority.pubkey()).try_into().unwrap(),
-        max_size,
-    );
-
-    token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority.pubkey(),
-            max_size,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    {
-        // Update the group's size manually
-        let mut context = test_context.context.lock().await;
-
-        let group_mint_account = context
-            .banks_client
-            .get_account(mint_keypair.pubkey())
-            .await
-            .unwrap()
-            .unwrap();
-
-        let old_data = context
-            .banks_client
-            .get_account(mint_keypair.pubkey())
-            .await
-            .unwrap()
-            .unwrap()
-            .data;
-
-        let data = {
-            // 0....81:     mint
-            // 82...164:    padding
-            // 165..166:    account type
-            // 167..170:    extension discriminator (GroupPointer)
-            // 171..202:    authority
-            // 203..234:    group pointer
-            // 235..238:    extension discriminator (TokenGroup)
-            // 239..270:    mint
-            // 271..302:    update_authority
-            // 303..306:    size
-            // 307..310:    max_size
-            let (front, back) = old_data.split_at(302);
-            let (_, back) = back.split_at(4);
-            let size_bytes = size.to_le_bytes();
-            let mut bytes = vec![];
-            bytes.extend_from_slice(front);
-            bytes.extend_from_slice(&size_bytes);
-            bytes.extend_from_slice(back);
-            bytes
-        };
-
-        context.set_account(
-            &mint_keypair.pubkey(),
-            &SolanaAccount {
-                data,
-                ..group_mint_account
-            }
-            .into(),
-        );
-
-        token_group.size = size.into();
-    }
-
-    token_group.max_size = new_max_size.into();
-
-    if new_max_size < size {
-        let error = token_context
-            .token
-            .token_group_update_max_size(
-                &update_authority.pubkey(),
-                new_max_size,
-                &[&update_authority],
-            )
-            .await
-            .unwrap_err();
-        assert_eq!(
-            error,
-            TokenClientError::Client(Box::new(TransportError::TransactionError(
-                TransactionError::InstructionError(
-                    0,
-                    InstructionError::Custom(TokenGroupError::SizeExceedsNewMaxSize as u32)
-                )
-            ))),
-        );
-    } else {
-        token_context
-            .token
-            .token_group_update_max_size(
-                &update_authority.pubkey(),
-                new_max_size,
-                &[&update_authority],
-            )
-            .await
-            .unwrap();
-
-        let mint_info = token_context.token.get_mint_info().await.unwrap();
-        let fetched_group = mint_info.get_extension::<TokenGroup>().unwrap();
-        assert_eq!(fetched_group, &token_group);
-    }
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    token_context
-        .token
-        .token_group_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &token_context.mint_authority.pubkey(),
-            &update_authority.pubkey(),
-            10,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // no signature
-    let mut instruction = update_group_max_size(
-        &spl_token_2022::id(),
-        token_context.token.get_address(),
-        &update_authority.pubkey(),
-        20,
-    );
-    instruction.accounts[1].is_signer = false;
-
-    let error = token_context
-        .token
-        .process_ixs(&[instruction], &[] as &[&dyn Signer; 0]) // yuck, but the compiler needs it
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-
-    // wrong authority
-    let wrong_authority = Keypair::new();
-    let error = token_context
-        .token
-        .token_group_update_max_size(&wrong_authority.pubkey(), 20, &[&wrong_authority])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32)
-            )
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/token_metadata_emit.rs b/token/program-2022-test/tests/token_metadata_emit.rs
deleted file mode 100644
index 9de6a5e37f8..00000000000
--- a/token/program-2022-test/tests/token_metadata_emit.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        borsh1::try_from_slice_unchecked, program::MAX_RETURN_DATA, pubkey::Pubkey,
-        signature::Signer, signer::keypair::Keypair, transaction::Transaction,
-    },
-    spl_token_2022::processor::Processor,
-    spl_token_client::token::ExtensionInitializationParams,
-    spl_token_metadata_interface::{instruction::emit, state::TokenMetadata},
-    std::{convert::TryInto, sync::Arc},
-    test_case::test_case,
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let metadata_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[test_case(Some(40), Some(40) ; "zero bytes")]
-#[test_case(Some(40), Some(41) ; "one byte")]
-#[test_case(Some(1_000_000), Some(1_000_001) ; "too far")]
-#[test_case(Some(50), Some(49) ; "wrong way")]
-#[test_case(Some(50), None ; "truncate start")]
-#[test_case(None, Some(50) ; "truncate end")]
-#[test_case(None, None ; "full data")]
-#[tokio::test]
-async fn success(start: Option<u64>, end: Option<u64>) {
-    let program_id = spl_token_2022::id();
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let mut context = test_context.context.lock().await;
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[emit(
-            &program_id,
-            token_context.token.get_address(),
-            start,
-            end,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let simulation = context
-        .banks_client
-        .simulate_transaction(transaction)
-        .await
-        .unwrap();
-
-    let metadata_buffer = borsh::to_vec(&token_metadata).unwrap();
-    if let Some(check_buffer) = TokenMetadata::get_slice(&metadata_buffer, start, end) {
-        if !check_buffer.is_empty() {
-            // pad the data if necessary
-            let mut return_data = vec![0; MAX_RETURN_DATA];
-            if let Some(simulation_details) = simulation.simulation_details {
-                if let Some(simulation_return_data) = simulation_details.return_data {
-                    assert_eq!(simulation_return_data.program_id, program_id);
-                    return_data[..simulation_return_data.data.len()]
-                        .copy_from_slice(&simulation_return_data.data);
-                }
-            }
-
-            assert_eq!(*check_buffer, return_data[..check_buffer.len()]);
-            // we're sure that we're getting the full data, so also compare the deserialized
-            // type
-            if start.is_none() && end.is_none() {
-                let emitted_token_metadata =
-                    try_from_slice_unchecked::<TokenMetadata>(&return_data).unwrap();
-                assert_eq!(token_metadata, emitted_token_metadata);
-            }
-        } else {
-            assert!(simulation.simulation_details.unwrap().return_data.is_none());
-        }
-    } else {
-        assert!(simulation.simulation_details.unwrap().return_data.is_none());
-    }
-}
diff --git a/token/program-2022-test/tests/token_metadata_initialize.rs b/token/program-2022-test/tests/token_metadata_initialize.rs
deleted file mode 100644
index e6576d68f68..00000000000
--- a/token/program-2022-test/tests/token_metadata_initialize.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    borsh::BorshDeserialize,
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{error::TokenError, extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_metadata_interface::{error::TokenMetadataError, state::TokenMetadata},
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let metadata_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_initialize() {
-    let authority = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Pubkey::new_unique();
-    let name = "MyTokenNeedsMetadata".to_string();
-    let symbol = "NEEDS".to_string();
-    let uri = "my.token.needs.metadata".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    // fails without more lamports for new rent-exemption
-    let error = token_context
-        .token
-        .token_metadata_initialize(
-            &update_authority,
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InsufficientFundsForRent { account_index: 2 }
-        )))
-    );
-
-    // fail wrong signer
-    let not_mint_authority = Keypair::new();
-    let error = token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority,
-            &not_mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&not_mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenMetadataError::IncorrectMintAuthority as u32)
-            )
-        )))
-    );
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority,
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let mint_info = token_context.token.get_mint_info().await.unwrap();
-    let metadata_bytes = mint_info.get_extension_bytes::<TokenMetadata>().unwrap();
-    let fetched_metadata = TokenMetadata::try_from_slice(metadata_bytes).unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // fail double-init
-    let error = token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority,
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::ExtensionAlreadyInitialized as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_metadata_pointer() {
-    let mut test_context = {
-        let mint_keypair = Keypair::new();
-        let program_test = setup_program_test();
-        let context = program_test.start_with_context().await;
-        let context = Arc::new(tokio::sync::Mutex::new(context));
-        let mut context = TestContext {
-            context,
-            token_context: None,
-        };
-        context
-            .init_token_with_mint_keypair_and_freeze_authority(mint_keypair, vec![], None)
-            .await
-            .unwrap();
-        context
-    };
-
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let error = token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &Pubkey::new_unique(),
-            &token_context.mint_authority.pubkey(),
-            "Name".to_string(),
-            "Symbol".to_string(),
-            "URI".to_string(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidExtensionCombination as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_init_in_another_mint() {
-    let authority = Pubkey::new_unique();
-    let first_mint_keypair = Keypair::new();
-    let first_mint = first_mint_keypair.pubkey();
-    let mut test_context = setup(first_mint_keypair, &authority).await;
-    let second_mint_keypair = Keypair::new();
-    let second_mint = second_mint_keypair.pubkey();
-    test_context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            second_mint_keypair,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(authority),
-                metadata_address: Some(second_mint),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-
-    let token_context = test_context.token_context.take().unwrap();
-
-    let error = token_context
-        .token
-        .process_ixs(
-            &[spl_token_metadata_interface::instruction::initialize(
-                &spl_token_2022::id(),
-                &first_mint,
-                &Pubkey::new_unique(),
-                token_context.token.get_address(),
-                &token_context.mint_authority.pubkey(),
-                "Name".to_string(),
-                "Symbol".to_string(),
-                "URI".to_string(),
-            )],
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_without_signature() {
-    let authority = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority).await;
-
-    let token_context = test_context.token_context.take().unwrap();
-
-    let mut instruction = spl_token_metadata_interface::instruction::initialize(
-        &spl_token_2022::id(),
-        token_context.token.get_address(),
-        &Pubkey::new_unique(),
-        token_context.token.get_address(),
-        &token_context.mint_authority.pubkey(),
-        "Name".to_string(),
-        "Symbol".to_string(),
-        "URI".to_string(),
-    );
-    instruction.accounts[3].is_signer = false;
-    let error = token_context
-        .token
-        .process_ixs(&[instruction], &[] as &[&dyn Signer; 0]) // yuck, but the compiler needs it
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/token_metadata_remove_key.rs b/token/program-2022-test/tests/token_metadata_remove_key.rs
deleted file mode 100644
index 112793c6c95..00000000000
--- a/token/program-2022-test/tests/token_metadata_remove_key.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::remove_key,
-        state::{Field, TokenMetadata},
-    },
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let metadata_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_remove() {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let key = "new_field, wow!".to_string();
-    let field = Field::Key(key.clone());
-    let value = "so impressed with the new field, don't know what to put here".to_string();
-    token_metadata.update(field.clone(), value.clone());
-
-    // add the field
-    token_context
-        .token
-        .token_metadata_update_field_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            field,
-            value,
-            None,
-            &[&update_authority],
-        )
-        .await
-        .unwrap();
-
-    // now remove it
-    token_context
-        .token
-        .token_metadata_remove_key(
-            &update_authority.pubkey(),
-            key.clone(),
-            false, // idempotent
-            &[&update_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    token_metadata.remove_key(&key);
-    let mint = token_context.token.get_mint_info().await.unwrap();
-    let fetched_metadata = mint.get_variable_len_extension::<TokenMetadata>().unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // succeed again with idempotent flag
-    token_context
-        .token
-        .token_metadata_remove_key(
-            &update_authority.pubkey(),
-            key.clone(),
-            true, // idempotent
-            &[&update_authority],
-        )
-        .await
-        .unwrap();
-
-    // fail doing it again without idempotent flag
-    {
-        // Be really sure to have a new latest blockhash since this keeps failing in CI
-        let mut context = test_context.context.lock().await;
-        context.get_new_latest_blockhash().await.unwrap();
-        context.get_new_latest_blockhash().await.unwrap();
-    }
-    let error = token_context
-        .token
-        .token_metadata_remove_key(
-            &update_authority.pubkey(),
-            key.clone(),
-            false, // idempotent
-            &[&update_authority],
-        )
-        .await
-        .unwrap_err();
-
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenMetadataError::KeyNotFound as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = spl_token_2022::id();
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let key = "new_field, wow!".to_string();
-
-    // wrong authority
-    let error = token_context
-        .token
-        .token_metadata_remove_key(
-            &payer_pubkey,
-            key,
-            true, // idempotent
-            &[] as &[&dyn Signer; 0],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32)
-            )
-        )))
-    );
-
-    // no signature
-    let mut context = test_context.context.lock().await;
-    let mut instruction = remove_key(
-        &program_id,
-        &mint_pubkey,
-        &update_authority.pubkey(),
-        "new_name".to_string(),
-        true, // idempotent
-    );
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-}
diff --git a/token/program-2022-test/tests/token_metadata_update_authority.rs b/token/program-2022-test/tests/token_metadata_update_authority.rs
deleted file mode 100644
index 1a22baf63ee..00000000000
--- a/token/program-2022-test/tests/token_metadata_update_authority.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::{Transaction, TransactionError},
-        transport::TransportError,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_metadata_interface::{
-        error::TokenMetadataError, instruction::update_authority, state::TokenMetadata,
-    },
-    std::{convert::TryInto, sync::Arc},
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let metadata_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_update() {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let new_update_authority = Keypair::new();
-    let new_update_authority_pubkey =
-        OptionalNonZeroPubkey::try_from(Some(new_update_authority.pubkey())).unwrap();
-    token_metadata.update_authority = new_update_authority_pubkey;
-
-    token_context
-        .token
-        .token_metadata_update_authority(
-            &authority.pubkey(),
-            Some(new_update_authority.pubkey()),
-            &[&authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the data is correct
-    let mint = token_context.token.get_mint_info().await.unwrap();
-    let fetched_metadata = mint.get_variable_len_extension::<TokenMetadata>().unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // unset
-    token_metadata.update_authority = None.try_into().unwrap();
-    token_context
-        .token
-        .token_metadata_update_authority(
-            &new_update_authority.pubkey(),
-            None,
-            &[&new_update_authority],
-        )
-        .await
-        .unwrap();
-
-    let mint = token_context.token.get_mint_info().await.unwrap();
-    let fetched_metadata = mint.get_variable_len_extension::<TokenMetadata>().unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-
-    // fail to update
-    let error = token_context
-        .token
-        .token_metadata_update_authority(
-            &new_update_authority.pubkey(),
-            Some(new_update_authority.pubkey()),
-            &[&new_update_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenMetadataError::ImmutableMetadata as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let program_id = spl_token_2022::id();
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mint_pubkey = mint_keypair.pubkey();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // wrong authority
-    let error = token_context
-        .token
-        .token_metadata_update_authority(&payer_pubkey, None, &[] as &[&dyn Signer; 0])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32),
-            )
-        )))
-    );
-
-    // no signature
-    let mut context = test_context.context.lock().await;
-    let mut instruction = update_authority(
-        &program_id,
-        &mint_pubkey,
-        &authority.pubkey(),
-        None.try_into().unwrap(),
-    );
-    instruction.accounts[1].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature,)
-    );
-}
diff --git a/token/program-2022-test/tests/token_metadata_update_field.rs b/token/program-2022-test/tests/token_metadata_update_field.rs
deleted file mode 100644
index 83417d376f4..00000000000
--- a/token/program-2022-test/tests/token_metadata_update_field.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-#![cfg(feature = "test-sbf")]
-#![allow(clippy::items_after_test_module)]
-
-mod program_test;
-use {
-    program_test::TestContext,
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::update_field,
-        state::{Field, TokenMetadata},
-    },
-    std::{convert::TryInto, sync::Arc},
-    test_case::test_case,
-};
-
-fn setup_program_test() -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test
-}
-
-async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
-    let program_test = setup_program_test();
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let metadata_address = Some(mint.pubkey());
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::MetadataPointer {
-                authority: Some(*authority),
-                metadata_address,
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[test_case(Field::Name, "This is my larger name".to_string() ; "larger name")]
-#[test_case(Field::Name, "Smaller".to_string() ; "smaller name")]
-#[test_case(Field::Key("my new field".to_string()), "Some data for the new field!".to_string() ; "new field")]
-#[tokio::test]
-async fn success_update(field: Field, value: String) {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    let name = "MySuperCoolToken".to_string();
-    let symbol = "MINE".to_string();
-    let uri = "my.super.cool.token".to_string();
-    let mut token_metadata = TokenMetadata {
-        name,
-        symbol,
-        uri,
-        update_authority: Some(update_authority.pubkey()).try_into().unwrap(),
-        mint: *token_context.token.get_address(),
-        ..Default::default()
-    };
-
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            token_metadata.name.clone(),
-            token_metadata.symbol.clone(),
-            token_metadata.uri.clone(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    let old_space = token_metadata.tlv_size_of().unwrap();
-    token_metadata.update(field.clone(), value.clone());
-    let new_space = token_metadata.tlv_size_of().unwrap();
-
-    if new_space > old_space {
-        let error = token_context
-            .token
-            .token_metadata_update_field(
-                &update_authority.pubkey(),
-                field.clone(),
-                value.clone(),
-                &[&update_authority],
-            )
-            .await
-            .unwrap_err();
-        assert_eq!(
-            error,
-            TokenClientError::Client(Box::new(TransportError::TransactionError(
-                TransactionError::InsufficientFundsForRent { account_index: 2 }
-            )))
-        );
-    }
-
-    // transfer required lamports
-    token_context
-        .token
-        .token_metadata_update_field_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            field,
-            value,
-            None,
-            &[&update_authority],
-        )
-        .await
-        .unwrap();
-
-    // check that the account looks good
-    let mint_info = token_context.token.get_mint_info().await.unwrap();
-    let fetched_metadata = mint_info
-        .get_variable_len_extension::<TokenMetadata>()
-        .unwrap();
-    assert_eq!(fetched_metadata, token_metadata);
-}
-
-#[tokio::test]
-async fn fail_authority_checks() {
-    let authority = Keypair::new();
-    let mint_keypair = Keypair::new();
-    let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
-    let payer_pubkey = test_context.context.lock().await.payer.pubkey();
-    let token_context = test_context.token_context.take().unwrap();
-
-    let update_authority = Keypair::new();
-    token_context
-        .token
-        .token_metadata_initialize_with_rent_transfer(
-            &payer_pubkey,
-            &update_authority.pubkey(),
-            &token_context.mint_authority.pubkey(),
-            "MySuperCoolToken".to_string(),
-            "MINE".to_string(),
-            "my.super.cool.token".to_string(),
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // no signature
-    let mut instruction = update_field(
-        &spl_token_2022::id(),
-        token_context.token.get_address(),
-        &update_authority.pubkey(),
-        Field::Name,
-        "new_name".to_string(),
-    );
-    instruction.accounts[1].is_signer = false;
-
-    let error = token_context
-        .token
-        .process_ixs(&[instruction], &[] as &[&dyn Signer; 0]) // yuck, but the compiler needs it
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
-        )))
-    );
-
-    // wrong authority
-    let wrong_authority = Keypair::new();
-    let error = token_context
-        .token
-        .token_metadata_update_field(
-            &wrong_authority.pubkey(),
-            Field::Name,
-            "new_name".to_string(),
-            &[&wrong_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenMetadataError::IncorrectUpdateAuthority as u32)
-            )
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/transfer.rs b/token/program-2022-test/tests/transfer.rs
deleted file mode 100644
index 8c3a395fdf5..00000000000
--- a/token/program-2022-test/tests/transfer.rs
+++ /dev/null
@@ -1,379 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
-        transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::error::TokenError,
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-};
-
-#[derive(PartialEq)]
-enum TestMode {
-    All,
-    CheckedOnly,
-}
-
-async fn run_basic_transfers(context: TestContext, test_mode: TestMode) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-    let bob_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&bob_account, &bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint a token
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    if test_mode == TestMode::All {
-        // unchecked is ok
-        token_unchecked
-            .transfer(&alice_account, &bob_account, &alice.pubkey(), 1, &[&alice])
-            .await
-            .unwrap();
-    }
-
-    // checked is ok
-    token
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-
-    // transfer too much is not ok
-    let error = token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            amount,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-
-    // wrong signer
-    let error = token
-        .transfer(&alice_account, &bob_account, &bob.pubkey(), 1, &[&bob])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn basic() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_basic_transfers(context, TestMode::All).await;
-}
-
-#[tokio::test]
-async fn basic_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000_000u64,
-        }])
-        .await
-        .unwrap();
-    run_basic_transfers(context, TestMode::CheckedOnly).await;
-}
-
-async fn run_self_transfers(context: TestContext, test_mode: TestMode) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-
-    // mint a token
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // self transfer is ok
-    token
-        .transfer(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            1,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    if test_mode == TestMode::All {
-        token_unchecked
-            .transfer(
-                &alice_account,
-                &alice_account,
-                &alice.pubkey(),
-                1,
-                &[&alice],
-            )
-            .await
-            .unwrap();
-    }
-
-    // too much self transfer is not ok
-    let error = token
-        .transfer(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            amount.checked_add(1).unwrap(),
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn self_transfer() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_self_transfers(context, TestMode::All).await;
-}
-
-#[tokio::test]
-async fn self_transfer_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000_000u64,
-        }])
-        .await
-        .unwrap();
-    run_self_transfers(context, TestMode::CheckedOnly).await;
-}
-
-async fn run_self_owned(context: TestContext, test_mode: TestMode) {
-    let TokenContext {
-        mint_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    token
-        .create_auxiliary_token_account(&alice, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice.pubkey();
-    let bob_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&bob_account, &bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint a token
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    if test_mode == TestMode::All {
-        // unchecked is ok
-        token_unchecked
-            .transfer(&alice_account, &bob_account, &alice.pubkey(), 1, &[&alice])
-            .await
-            .unwrap();
-    }
-
-    // checked is ok
-    token
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-
-    // self transfer is ok
-    token
-        .transfer(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            1,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn self_owned() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    run_self_owned(context, TestMode::All).await;
-}
-
-#[tokio::test]
-async fn self_owned_with_extension() {
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: 100u16,
-            maximum_fee: 1_000_000u64,
-        }])
-        .await
-        .unwrap();
-    run_self_owned(context, TestMode::CheckedOnly).await;
-}
-
-#[tokio::test]
-async fn transfer_with_fee_on_mint_without_fee_configured() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let TokenContext {
-        mint_authority,
-        token,
-        alice,
-        bob,
-        ..
-    } = context.token_context.unwrap();
-
-    let alice_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&alice_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-    let bob_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&bob_account, &bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint some tokens
-    let amount = 10;
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-
-    // success if expected fee is 0
-    token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            1,
-            0,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // fail for anything else
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            2,
-            1,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::FeeMismatch as u32)
-            )
-        )))
-    );
-}
diff --git a/token/program-2022-test/tests/transfer_fee.rs b/token/program-2022-test/tests/transfer_fee.rs
deleted file mode 100644
index 2249cac0337..00000000000
--- a/token/program-2022-test/tests/transfer_fee.rs
+++ /dev/null
@@ -1,1715 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    program_test::{TestContext, TokenContext},
-    solana_program_test::tokio,
-    solana_sdk::{
-        instruction::InstructionError, program_option::COption, pubkey::Pubkey, signature::Signer,
-        signer::keypair::Keypair, transaction::TransactionError, transport::TransportError,
-    },
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            transfer_fee::{
-                TransferFee, TransferFeeAmount, TransferFeeConfig, MAX_FEE_BASIS_POINTS,
-            },
-            BaseStateWithExtensions,
-        },
-        instruction,
-    },
-    spl_token_client::{
-        client::ProgramBanksClientProcessTransaction,
-        token::{ExtensionInitializationParams, Token, TokenError as TokenClientError},
-    },
-    std::convert::TryInto,
-};
-
-const TEST_MAXIMUM_FEE: u64 = 10_000_000;
-const TEST_FEE_BASIS_POINTS: u16 = 250;
-
-fn test_transfer_fee() -> TransferFee {
-    TransferFee {
-        epoch: 0.into(),
-        transfer_fee_basis_points: TEST_FEE_BASIS_POINTS.into(),
-        maximum_fee: TEST_MAXIMUM_FEE.into(),
-    }
-}
-
-fn test_transfer_fee_config() -> TransferFeeConfig {
-    let transfer_fee = test_transfer_fee();
-    TransferFeeConfig {
-        transfer_fee_config_authority: COption::Some(Pubkey::new_unique()).try_into().unwrap(),
-        withdraw_withheld_authority: COption::Some(Pubkey::new_unique()).try_into().unwrap(),
-        withheld_amount: 0.into(),
-        older_transfer_fee: transfer_fee,
-        newer_transfer_fee: transfer_fee,
-    }
-}
-
-struct TransferFeeConfigWithKeypairs {
-    transfer_fee_config: TransferFeeConfig,
-    transfer_fee_config_authority: Keypair,
-    withdraw_withheld_authority: Keypair,
-}
-
-fn test_transfer_fee_config_with_keypairs() -> TransferFeeConfigWithKeypairs {
-    let transfer_fee = test_transfer_fee();
-    let transfer_fee_config_authority = Keypair::new();
-    let withdraw_withheld_authority = Keypair::new();
-    let transfer_fee_config = TransferFeeConfig {
-        transfer_fee_config_authority: COption::Some(transfer_fee_config_authority.pubkey())
-            .try_into()
-            .unwrap(),
-        withdraw_withheld_authority: COption::Some(withdraw_withheld_authority.pubkey())
-            .try_into()
-            .unwrap(),
-        withheld_amount: 0.into(),
-        older_transfer_fee: transfer_fee,
-        newer_transfer_fee: transfer_fee,
-    };
-    TransferFeeConfigWithKeypairs {
-        transfer_fee_config,
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-    }
-}
-
-struct TokenWithAccounts {
-    context: TestContext,
-    token: Token<ProgramBanksClientProcessTransaction>,
-    token_unchecked: Token<ProgramBanksClientProcessTransaction>,
-    transfer_fee_config: TransferFeeConfig,
-    withdraw_withheld_authority: Keypair,
-    freeze_authority: Keypair,
-    alice: Keypair,
-    alice_account: Pubkey,
-    bob_account: Pubkey,
-}
-
-async fn create_mint_with_accounts(alice_amount: u64) -> TokenWithAccounts {
-    let TransferFeeConfigWithKeypairs {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        transfer_fee_config,
-        ..
-    } = test_transfer_fee_config_with_keypairs();
-    let mut context = TestContext::new().await;
-    let transfer_fee_basis_points = u16::from(
-        transfer_fee_config
-            .newer_transfer_fee
-            .transfer_fee_basis_points,
-    );
-    let maximum_fee = u64::from(transfer_fee_config.newer_transfer_fee.maximum_fee);
-    context
-        .init_token_with_freezing_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.pubkey().into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.pubkey().into(),
-            transfer_fee_basis_points,
-            maximum_fee,
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        mint_authority,
-        freeze_authority,
-        token,
-        token_unchecked,
-        alice,
-        bob,
-        ..
-    } = context.token_context.take().unwrap();
-
-    // token account is self-owned just to test another case
-    token
-        .create_auxiliary_token_account(&alice, &alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice.pubkey();
-    let bob_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&bob_account, &bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint tokens
-    token
-        .mint_to(
-            &alice_account,
-            &mint_authority.pubkey(),
-            alice_amount,
-            &[&mint_authority],
-        )
-        .await
-        .unwrap();
-    TokenWithAccounts {
-        context,
-        token,
-        token_unchecked,
-        transfer_fee_config,
-        withdraw_withheld_authority,
-        freeze_authority: freeze_authority.unwrap(),
-        alice,
-        alice_account,
-        bob_account,
-    }
-}
-
-#[tokio::test]
-async fn success_init() {
-    let TransferFeeConfig {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        newer_transfer_fee,
-        ..
-    } = test_transfer_fee_config();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.into(),
-            transfer_fee_basis_points: newer_transfer_fee.transfer_fee_basis_points.into(),
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap();
-    let TokenContext {
-        decimals,
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    assert_eq!(state.base.decimals, decimals);
-    assert_eq!(
-        state.base.mint_authority,
-        COption::Some(mint_authority.pubkey())
-    );
-    assert_eq!(state.base.supply, 0);
-    assert!(state.base.is_initialized);
-    assert_eq!(state.base.freeze_authority, COption::None);
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.transfer_fee_config_authority,
-        transfer_fee_config_authority,
-    );
-    assert_eq!(
-        extension.withdraw_withheld_authority,
-        withdraw_withheld_authority,
-    );
-    assert_eq!(extension.newer_transfer_fee, newer_transfer_fee);
-    assert_eq!(extension.older_transfer_fee, newer_transfer_fee);
-}
-
-#[tokio::test]
-async fn fail_init_default_pubkey_as_authority() {
-    let TransferFeeConfig {
-        transfer_fee_config_authority,
-        newer_transfer_fee,
-        ..
-    } = test_transfer_fee_config();
-    let mut context = TestContext::new().await;
-    let err = context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.into(),
-            withdraw_withheld_authority: Some(Pubkey::default()),
-            transfer_fee_basis_points: newer_transfer_fee.transfer_fee_basis_points.into(),
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(1, InstructionError::InvalidArgument)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_init_fee_too_high() {
-    let TransferFeeConfig {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        newer_transfer_fee,
-        ..
-    } = test_transfer_fee_config();
-    let mut context = TestContext::new().await;
-    let err = context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.into(),
-            transfer_fee_basis_points: MAX_FEE_BASIS_POINTS + 1,
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::TransferFeeExceedsMaximum as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_fee() {
-    let TransferFeeConfigWithKeypairs {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        transfer_fee_config: TransferFeeConfig {
-            newer_transfer_fee, ..
-        },
-        ..
-    } = test_transfer_fee_config_with_keypairs();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.pubkey().into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.pubkey().into(),
-            transfer_fee_basis_points: newer_transfer_fee.transfer_fee_basis_points.into(),
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap();
-
-    // warp to first normal slot to easily calculate epochs
-    let (first_normal_slot, slots_per_epoch) = {
-        let context = context.context.lock().await;
-        (
-            context.genesis_config().epoch_schedule.first_normal_slot,
-            context.genesis_config().epoch_schedule.slots_per_epoch,
-        )
-    };
-
-    context
-        .context
-        .lock()
-        .await
-        .warp_to_slot(first_normal_slot)
-        .unwrap();
-
-    let token = context.token_context.unwrap().token;
-
-    // set to something new, old fee not touched
-    let new_transfer_fee_basis_points = MAX_FEE_BASIS_POINTS;
-    let new_maximum_fee = u64::MAX;
-    token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            new_transfer_fee_basis_points,
-            new_maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.newer_transfer_fee.transfer_fee_basis_points,
-        new_transfer_fee_basis_points.into()
-    );
-    assert_eq!(
-        extension.newer_transfer_fee.maximum_fee,
-        new_maximum_fee.into()
-    );
-    assert_eq!(extension.older_transfer_fee, newer_transfer_fee);
-
-    // set again, old fee still not touched
-    let new_transfer_fee_basis_points = 0;
-    let new_maximum_fee = 0;
-    token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            new_transfer_fee_basis_points,
-            new_maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.newer_transfer_fee.transfer_fee_basis_points,
-        new_transfer_fee_basis_points.into()
-    );
-    assert_eq!(
-        extension.newer_transfer_fee.maximum_fee,
-        new_maximum_fee.into()
-    );
-    assert_eq!(extension.older_transfer_fee, newer_transfer_fee);
-
-    // warp forward one epoch, old fee still not touched when set
-    let new_transfer_fee_basis_points = 10;
-    let new_maximum_fee = 10;
-    context
-        .context
-        .lock()
-        .await
-        .warp_to_slot(first_normal_slot + slots_per_epoch)
-        .unwrap();
-    token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            new_transfer_fee_basis_points,
-            new_maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.newer_transfer_fee.transfer_fee_basis_points,
-        new_transfer_fee_basis_points.into()
-    );
-    assert_eq!(
-        extension.newer_transfer_fee.maximum_fee,
-        new_maximum_fee.into()
-    );
-    assert_eq!(extension.older_transfer_fee, newer_transfer_fee);
-
-    // warp forward two epochs, old fee is replaced on set
-    let newer_transfer_fee = extension.newer_transfer_fee;
-    context
-        .context
-        .lock()
-        .await
-        .warp_to_slot(first_normal_slot + 3 * slots_per_epoch)
-        .unwrap();
-    let new_transfer_fee_basis_points = MAX_FEE_BASIS_POINTS;
-    let new_maximum_fee = u64::MAX;
-    token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            new_transfer_fee_basis_points,
-            new_maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.newer_transfer_fee.transfer_fee_basis_points,
-        new_transfer_fee_basis_points.into()
-    );
-    assert_eq!(
-        extension.newer_transfer_fee.maximum_fee,
-        new_maximum_fee.into()
-    );
-    assert_eq!(extension.older_transfer_fee, newer_transfer_fee);
-
-    // fail, wrong signer
-    let error = token
-        .set_transfer_fee(
-            &withdraw_withheld_authority.pubkey(),
-            new_transfer_fee_basis_points,
-            new_maximum_fee,
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // fail, set too high
-    let error = token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            MAX_FEE_BASIS_POINTS + 1,
-            new_maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::TransferFeeExceedsMaximum as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_unsupported_mint() {
-    let mut context = TestContext::new().await;
-    context.init_token_with_mint(vec![]).await.unwrap();
-    let TokenContext {
-        mint_authority,
-        token,
-        ..
-    } = context.token_context.unwrap();
-    let transfer_fee_basis_points = u16::MAX;
-    let maximum_fee = u64::MAX;
-    let error = token
-        .set_transfer_fee(
-            &mint_authority.pubkey(),
-            transfer_fee_basis_points,
-            maximum_fee,
-            &[&mint_authority],
-        )
-        .await
-        .err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-    let error = token
-        .harvest_withheld_tokens_to_mint(&[])
-        .await
-        .err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-    let error = token
-        .withdraw_withheld_tokens_from_mint(
-            &Pubkey::new_unique(),
-            &mint_authority.pubkey(),
-            &[&mint_authority],
-        )
-        .await
-        .err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidAccountData)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_transfer_fee_config_authority() {
-    let TransferFeeConfigWithKeypairs {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        transfer_fee_config: TransferFeeConfig {
-            newer_transfer_fee, ..
-        },
-        ..
-    } = test_transfer_fee_config_with_keypairs();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.pubkey().into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.pubkey().into(),
-            transfer_fee_basis_points: newer_transfer_fee.transfer_fee_basis_points.into(),
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap();
-    let token = context.token_context.unwrap().token;
-
-    let new_authority = Keypair::new();
-    let wrong = Keypair::new();
-
-    // fail, wrong signer
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::TransferFeeConfig,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &transfer_fee_config_authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::TransferFeeConfig,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.transfer_fee_config_authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // assert new_authority can update transfer fee config, and old cannot
-    let transfer_fee_basis_points = MAX_FEE_BASIS_POINTS;
-    let maximum_fee = u64::MAX;
-    let err = token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            transfer_fee_basis_points,
-            maximum_fee,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-    token
-        .set_transfer_fee(
-            &new_authority.pubkey(),
-            transfer_fee_basis_points,
-            maximum_fee,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::TransferFeeConfig,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.transfer_fee_config_authority,
-        None.try_into().unwrap(),
-    );
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&transfer_fee_config_authority.pubkey()),
-            instruction::AuthorityType::TransferFeeConfig,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-
-    // fail update transfer fee config
-    let err = token
-        .set_transfer_fee(
-            &transfer_fee_config_authority.pubkey(),
-            0,
-            0,
-            &[&transfer_fee_config_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_withdraw_withheld_authority() {
-    let TransferFeeConfigWithKeypairs {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        transfer_fee_config: TransferFeeConfig {
-            newer_transfer_fee, ..
-        },
-        ..
-    } = test_transfer_fee_config_with_keypairs();
-    let mut context = TestContext::new().await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: transfer_fee_config_authority.pubkey().into(),
-            withdraw_withheld_authority: withdraw_withheld_authority.pubkey().into(),
-            transfer_fee_basis_points: newer_transfer_fee.transfer_fee_basis_points.into(),
-            maximum_fee: newer_transfer_fee.maximum_fee.into(),
-        }])
-        .await
-        .unwrap();
-    let token = context.token_context.unwrap().token;
-
-    let new_authority = Keypair::new();
-    let wrong = Keypair::new();
-
-    // fail, wrong signer
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::WithheldWithdraw,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &withdraw_withheld_authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::WithheldWithdraw,
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.withdraw_withheld_authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // new authority can withdraw tokens
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &new_authority.pubkey())
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &new_authority.pubkey(),
-            &[&account],
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    // old one cannot
-    let error = token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::WithheldWithdraw,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(
-        extension.withdraw_withheld_authority,
-        None.try_into().unwrap(),
-    );
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&withdraw_withheld_authority.pubkey()),
-            instruction::AuthorityType::WithheldWithdraw,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-
-    // assert no authority can withdraw withheld fees
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, &new_authority.pubkey())
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    let error = token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-    let error = token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &new_authority.pubkey(),
-            &[&account],
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn transfer_checked() {
-    let maximum_fee = TEST_MAXIMUM_FEE;
-    let mut alice_amount = maximum_fee * 100;
-    let TokenWithAccounts {
-        token,
-        token_unchecked,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        bob_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // fail unchecked always
-    let error = token_unchecked
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            maximum_fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintRequiredForTransfer as u32)
-            )
-        )))
-    );
-
-    // fail because amount too high
-    let error = token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            alice_amount + 1,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-
-    let mut withheld_amount = 0;
-    let mut transferred_amount = 0;
-
-    // success, clean calculation for transfer fee
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, maximum_fee)
-        .unwrap();
-    token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            maximum_fee,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    alice_amount -= maximum_fee;
-    withheld_amount += fee;
-    transferred_amount += maximum_fee - fee;
-
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transferred_amount);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, withheld_amount.into());
-
-    // success, rounded up transfer fee
-    let transfer_amount = maximum_fee - 1;
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, transfer_amount)
-        .unwrap();
-    token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            transfer_amount,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    alice_amount -= transfer_amount;
-    withheld_amount += fee;
-    transferred_amount += transfer_amount - fee;
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transferred_amount);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, withheld_amount.into());
-
-    // success, maximum fee kicks in
-    let transfer_amount = 1 + maximum_fee * (MAX_FEE_BASIS_POINTS as u64)
-        / (u16::from(
-            transfer_fee_config
-                .newer_transfer_fee
-                .transfer_fee_basis_points,
-        ) as u64);
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, transfer_amount)
-        .unwrap();
-    assert_eq!(fee, maximum_fee); // sanity
-    token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            transfer_amount,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    alice_amount -= transfer_amount;
-    withheld_amount += fee;
-    transferred_amount += transfer_amount - fee;
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transferred_amount);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, withheld_amount.into());
-
-    // transfer down to 1 token
-    token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            alice_amount - 1,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    transferred_amount += alice_amount - 1 - maximum_fee;
-    alice_amount = 1;
-    withheld_amount += maximum_fee;
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transferred_amount);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, withheld_amount.into());
-
-    // final transfer, only move tokens to withheld amount, nothing received
-    token
-        .transfer(&alice_account, &bob_account, &alice.pubkey(), 1, &[&alice])
-        .await
-        .unwrap();
-    withheld_amount += 1;
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, 0);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transferred_amount);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, withheld_amount.into());
-}
-
-#[tokio::test]
-async fn transfer_checked_with_fee() {
-    let maximum_fee = TEST_MAXIMUM_FEE;
-    let alice_amount = maximum_fee * 100;
-    let TokenWithAccounts {
-        token,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        bob_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // incorrect fee, too high
-    let transfer_amount = maximum_fee;
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, transfer_amount)
-        .unwrap()
-        + 1;
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            transfer_amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::FeeMismatch as u32)
-            )
-        )))
-    );
-
-    // incorrect fee, too low
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, transfer_amount)
-        .unwrap()
-        - 1;
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            transfer_amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::FeeMismatch as u32)
-            )
-        )))
-    );
-
-    // correct fee, not enough tokens
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, alice_amount + 1)
-        .unwrap()
-        - 1;
-    let error = token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            alice_amount + 1,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::InsufficientFunds as u32)
-            )
-        )))
-    );
-
-    // correct fee
-    let fee = transfer_fee_config
-        .calculate_epoch_fee(0, transfer_amount)
-        .unwrap();
-    token
-        .transfer_with_fee(
-            &alice_account,
-            &bob_account,
-            &alice.pubkey(),
-            transfer_amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount - transfer_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let bob_state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(bob_state.base.amount, transfer_amount - fee);
-    let extension = bob_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, fee.into());
-}
-
-#[tokio::test]
-async fn no_fees_from_self_transfer() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        token,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // self transfer, no fee assessed
-    let fee = transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    token
-        .transfer_with_fee(
-            &alice_account,
-            &alice_account,
-            &alice.pubkey(),
-            amount,
-            fee,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-    let alice_state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(alice_state.base.amount, alice_amount);
-    let extension = alice_state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-}
-
-async fn create_and_transfer_to_account(
-    token: &Token<ProgramBanksClientProcessTransaction>,
-    source: &Pubkey,
-    authority: &Keypair,
-    owner: &Pubkey,
-    amount: u64,
-) -> Pubkey {
-    let account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&account, owner)
-        .await
-        .unwrap();
-    let account = account.pubkey();
-    token
-        .transfer(source, &account, &authority.pubkey(), amount, &[authority])
-        .await
-        .unwrap();
-    account
-}
-
-#[tokio::test]
-async fn harvest_withheld_tokens_to_mint() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        mut context,
-        token,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // harvest from zero accounts
-    token.harvest_withheld_tokens_to_mint(&[]).await.unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-
-    // harvest from one account
-    let accumulated_fees = transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    token
-        .harvest_withheld_tokens_to_mint(&[&account])
-        .await
-        .unwrap();
-    let state = token.get_account_info(&account).await.unwrap();
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, accumulated_fees.into());
-
-    // no fail harvesting from account belonging to different mint, but nothing
-    // happens
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(Pubkey::new_unique()),
-            transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-            maximum_fee: TEST_MAXIMUM_FEE,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-    token
-        .harvest_withheld_tokens_to_mint(&[&account])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-}
-
-#[tokio::test]
-async fn max_harvest_withheld_tokens_to_mint() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        token,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // harvest from max accounts, which is around 35, AKA 34 accounts + 1 mint
-    // see https://docs.solana.com/proposals/transactions-v2#problem
-    let mut accounts = vec![];
-    let max_accounts = 34;
-    for _ in 0..max_accounts {
-        let account =
-            create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-                .await;
-        accounts.push(account);
-    }
-    let accounts: Vec<_> = accounts.iter().collect();
-    let accumulated_fees =
-        max_accounts * transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    token
-        .harvest_withheld_tokens_to_mint(&accounts)
-        .await
-        .unwrap();
-    for account in accounts {
-        let state = token.get_account_info(account).await.unwrap();
-        let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-        assert_eq!(extension.withheld_amount, 0.into());
-    }
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, accumulated_fees.into());
-}
-
-#[tokio::test]
-async fn max_withdraw_withheld_tokens_from_accounts() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        token,
-        withdraw_withheld_authority,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // withdraw from max accounts, which is around 35: 1 mint, 1 destination, 1
-    // authority, 32 accounts
-    // see https://docs.solana.com/proposals/transactions-v2#problem
-    let destination = Keypair::new();
-    token
-        .create_auxiliary_token_account(&destination, &alice.pubkey())
-        .await
-        .unwrap();
-    let destination = destination.pubkey();
-    let mut accounts = vec![];
-    let max_accounts = 32;
-    for _ in 0..max_accounts {
-        let account =
-            create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-                .await;
-        accounts.push(account);
-    }
-    let accounts: Vec<_> = accounts.iter().collect();
-    let accumulated_fees =
-        max_accounts * transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &destination,
-            &withdraw_withheld_authority.pubkey(),
-            &accounts,
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    for account in accounts {
-        let state = token.get_account_info(account).await.unwrap();
-        let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-        assert_eq!(extension.withheld_amount, 0.into());
-    }
-    let state = token.get_account_info(&destination).await.unwrap();
-    assert_eq!(state.base.amount, accumulated_fees);
-}
-
-#[tokio::test]
-async fn withdraw_withheld_tokens_from_mint() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        mut context,
-        token,
-        transfer_fee_config,
-        withdraw_withheld_authority,
-        freeze_authority,
-        alice,
-        alice_account,
-        bob_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // no tokens withheld on mint
-    token
-        .withdraw_withheld_tokens_from_mint(
-            &alice_account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(state.base.amount, alice_amount);
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-
-    // transfer + harvest to mint
-    let fee = transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-
-    let state = token.get_account_info(&account).await.unwrap();
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, fee.into());
-
-    token
-        .harvest_withheld_tokens_to_mint(&[&account])
-        .await
-        .unwrap();
-
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, fee.into());
-
-    // success
-    token
-        .withdraw_withheld_tokens_from_mint(
-            &bob_account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_account_info(&bob_account).await.unwrap();
-    assert_eq!(state.base.amount, fee);
-    let state = token.get_account_info(&account).await.unwrap();
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-
-    // fail wrong signer
-    let error = token
-        .withdraw_withheld_tokens_from_mint(&alice_account, &alice.pubkey(), &[&alice])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // fail frozen account
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    token
-        .freeze(&account, &freeze_authority.pubkey(), &[&freeze_authority])
-        .await
-        .unwrap();
-    let error = token
-        .withdraw_withheld_tokens_from_mint(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AccountFrozen as u32)
-            )
-        )))
-    );
-
-    // set to none, fail
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    token
-        .set_authority(
-            token.get_address(),
-            &withdraw_withheld_authority.pubkey(),
-            None,
-            instruction::AuthorityType::WithheldWithdraw,
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let error = token
-        .withdraw_withheld_tokens_from_mint(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::NoAuthorityExists as u32)
-            )
-        )))
-    );
-
-    // fail on new mint with mint mismatch
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-            transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-            maximum_fee: TEST_MAXIMUM_FEE,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-    let error = token
-        .withdraw_withheld_tokens_from_mint(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn withdraw_withheld_tokens_from_accounts() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        mut context,
-        token,
-        withdraw_withheld_authority,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // wrong signer
-    let wrong_signer = Keypair::new();
-    let error = token
-        .withdraw_withheld_tokens_from_accounts(
-            &alice_account,
-            &wrong_signer.pubkey(),
-            &[],
-            &[&wrong_signer],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // withdraw from zero accounts
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &alice_account,
-            &withdraw_withheld_authority.pubkey(),
-            &[],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(state.base.amount, alice_amount);
-
-    // self-harvest from one account
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_account_info(&account).await.unwrap();
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    // we transferred to this account, and then withdrew the fee to it, so it's
-    // like doing a fee-less transfer!
-    assert_eq!(extension.withheld_amount, 0.into());
-    assert_eq!(state.base.amount, amount);
-
-    // harvest again from the same account
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &alice_account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_account_info(&account).await.unwrap();
-    let extension = state.get_extension::<TransferFeeAmount>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-    assert_eq!(state.base.amount, amount);
-    let state = token.get_account_info(&alice_account).await.unwrap();
-    assert_eq!(state.base.amount, alice_amount - amount);
-
-    // no fail harvesting from account belonging to different mint, but nothing
-    // happens
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-    context
-        .init_token_with_mint(vec![ExtensionInitializationParams::TransferFeeConfig {
-            transfer_fee_config_authority: Some(Pubkey::new_unique()),
-            withdraw_withheld_authority: Some(withdraw_withheld_authority.pubkey()),
-            transfer_fee_basis_points: TEST_FEE_BASIS_POINTS,
-            maximum_fee: TEST_MAXIMUM_FEE,
-        }])
-        .await
-        .unwrap();
-    let TokenContext { token, .. } = context.token_context.take().unwrap();
-    let withdraw_account = Keypair::new();
-    token
-        .create_auxiliary_token_account(&withdraw_account, &alice.pubkey())
-        .await
-        .unwrap();
-    let withdraw_account = withdraw_account.pubkey();
-    token
-        .withdraw_withheld_tokens_from_accounts(
-            &withdraw_account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferFeeConfig>().unwrap();
-    assert_eq!(extension.withheld_amount, 0.into());
-
-    // fail withdrawing into account on different mint
-    let error = token
-        .withdraw_withheld_tokens_from_accounts(
-            &account,
-            &withdraw_withheld_authority.pubkey(),
-            &[&withdraw_account],
-            &[&withdraw_withheld_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::MintMismatch as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn fail_close_with_withheld() {
-    let amount = TEST_MAXIMUM_FEE;
-    let alice_amount = amount * 100;
-    let TokenWithAccounts {
-        token,
-        transfer_fee_config,
-        alice,
-        alice_account,
-        ..
-    } = create_mint_with_accounts(alice_amount).await;
-
-    // accrue withheld fees on new account
-    let account =
-        create_and_transfer_to_account(&token, &alice_account, &alice, &alice.pubkey(), amount)
-            .await;
-
-    // empty the account
-    let fee = transfer_fee_config.calculate_epoch_fee(0, amount).unwrap();
-    token
-        .transfer(
-            &account,
-            &alice_account,
-            &alice.pubkey(),
-            amount - fee,
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    // fail to close
-    let error = token
-        .close_account(&account, &Pubkey::new_unique(), &alice.pubkey(), &[&alice])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        error,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AccountHasWithheldTransferFees as u32)
-            )
-        )))
-    );
-
-    // harvest the fees to the mint
-    token
-        .harvest_withheld_tokens_to_mint(&[&account])
-        .await
-        .unwrap();
-
-    // successfully close
-    token
-        .close_account(&account, &Pubkey::new_unique(), &alice.pubkey(), &[&alice])
-        .await
-        .unwrap();
-}
diff --git a/token/program-2022-test/tests/transfer_hook.rs b/token/program-2022-test/tests/transfer_hook.rs
deleted file mode 100644
index 5d9f301591e..00000000000
--- a/token/program-2022-test/tests/transfer_hook.rs
+++ /dev/null
@@ -1,915 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod program_test;
-use {
-    futures_util::TryFutureExt,
-    program_test::{
-        ConfidentialTokenAccountBalances, ConfidentialTokenAccountMeta, TestContext, TokenContext,
-    },
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        account::Account,
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        transaction::TransactionError,
-        transport::TransportError,
-    },
-    spl_tlv_account_resolution::{account::ExtraAccountMeta, seeds::Seed},
-    spl_token_2022::{
-        error::TokenError,
-        extension::{
-            transfer_hook::{TransferHook, TransferHookAccount},
-            BaseStateWithExtensions,
-        },
-        instruction, offchain, onchain,
-        processor::Processor,
-    },
-    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
-    spl_transfer_hook_interface::{
-        get_extra_account_metas_address, offchain::add_extra_account_metas_for_execute,
-    },
-    std::{convert::TryInto, sync::Arc},
-};
-
-/// Test program to fail transfer hook, conforms to transfer-hook-interface
-pub fn process_instruction_fail(
-    _program_id: &Pubkey,
-    _accounts: &[AccountInfo],
-    _input: &[u8],
-) -> ProgramResult {
-    Err(ProgramError::InvalidInstructionData)
-}
-
-/// Test program to check signer / write downgrade for repeated accounts,
-/// conforms to transfer-hook-interface
-pub fn process_instruction_downgrade(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    _input: &[u8],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let source_account_info = next_account_info(account_info_iter)?;
-    let _mint_info = next_account_info(account_info_iter)?;
-    let _destination_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let _extra_account_metas_info = next_account_info(account_info_iter)?;
-
-    let source_account_info_again = next_account_info(account_info_iter)?;
-    let authority_info_again = next_account_info(account_info_iter)?;
-
-    if source_account_info.key != source_account_info_again.key {
-        return Err(ProgramError::InvalidAccountData);
-    }
-
-    if source_account_info_again.is_writable {
-        return Err(ProgramError::InvalidAccountData);
-    }
-
-    if authority_info.key != authority_info_again.key {
-        return Err(ProgramError::InvalidAccountData);
-    }
-
-    if authority_info.is_signer {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    Ok(())
-}
-
-/// Test program to transfer two types of tokens with transfer hooks at once
-pub fn process_instruction_swap(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    _input: &[u8],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let source_a_account_info = next_account_info(account_info_iter)?;
-    let mint_a_info = next_account_info(account_info_iter)?;
-    let destination_a_account_info = next_account_info(account_info_iter)?;
-    let authority_a_info = next_account_info(account_info_iter)?;
-    let token_program_a_info = next_account_info(account_info_iter)?;
-
-    let source_b_account_info = next_account_info(account_info_iter)?;
-    let mint_b_info = next_account_info(account_info_iter)?;
-    let destination_b_account_info = next_account_info(account_info_iter)?;
-    let authority_b_info = next_account_info(account_info_iter)?;
-    let token_program_b_info = next_account_info(account_info_iter)?;
-
-    let remaining_accounts = account_info_iter.as_slice();
-
-    onchain::invoke_transfer_checked(
-        token_program_a_info.key,
-        source_a_account_info.clone(),
-        mint_a_info.clone(),
-        destination_a_account_info.clone(),
-        authority_a_info.clone(),
-        remaining_accounts,
-        1,
-        9,
-        &[],
-    )?;
-
-    onchain::invoke_transfer_checked(
-        token_program_b_info.key,
-        source_b_account_info.clone(),
-        mint_b_info.clone(),
-        destination_b_account_info.clone(),
-        authority_b_info.clone(),
-        remaining_accounts,
-        1,
-        9,
-        &[],
-    )?;
-
-    Ok(())
-}
-
-async fn setup_accounts(
-    token_context: &TokenContext,
-    alice_account: Keypair,
-    bob_account: Keypair,
-    amount: u64,
-) -> (Pubkey, Pubkey) {
-    token_context
-        .token
-        .create_auxiliary_token_account(&alice_account, &token_context.alice.pubkey())
-        .await
-        .unwrap();
-    let alice_account = alice_account.pubkey();
-    token_context
-        .token
-        .create_auxiliary_token_account(&bob_account, &token_context.bob.pubkey())
-        .await
-        .unwrap();
-    let bob_account = bob_account.pubkey();
-
-    // mint tokens
-    token_context
-        .token
-        .mint_to(
-            &alice_account,
-            &token_context.mint_authority.pubkey(),
-            amount,
-            &[&token_context.mint_authority],
-        )
-        .await
-        .unwrap();
-    (alice_account, bob_account)
-}
-
-fn setup_program_test(program_id: &Pubkey) -> ProgramTest {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test.add_program(
-        "my_transfer_hook",
-        *program_id,
-        processor!(spl_transfer_hook_example::processor::process),
-    );
-    program_test
-}
-
-fn add_validation_account(program_test: &mut ProgramTest, mint: &Pubkey, program_id: &Pubkey) {
-    let validation_address = get_extra_account_metas_address(mint, program_id);
-    let extra_account_metas = vec![
-        AccountMeta {
-            pubkey: Pubkey::new_unique(),
-            is_signer: false,
-            is_writable: false,
-        }
-        .into(),
-        AccountMeta {
-            pubkey: Pubkey::new_unique(),
-            is_signer: false,
-            is_writable: false,
-        }
-        .into(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::AccountKey { index: 0 }, // source
-                Seed::AccountKey { index: 2 }, // destination
-                Seed::AccountKey { index: 4 }, // validation state
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: vec![1, 2, 3, 4, 5, 6],
-                },
-                Seed::AccountKey { index: 2 }, // destination
-                Seed::AccountKey { index: 5 }, // extra meta 1
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-    ];
-    program_test.add_account(
-        validation_address,
-        Account {
-            lamports: 1_000_000_000, // a lot, just to be safe
-            data: spl_transfer_hook_example::state::example_data(&extra_account_metas).unwrap(),
-            owner: *program_id,
-            ..Account::default()
-        },
-    );
-}
-
-async fn setup(mint: Keypair, program_id: &Pubkey, authority: &Pubkey) -> TestContext {
-    let mut program_test = setup_program_test(program_id);
-    add_validation_account(&mut program_test, &mint.pubkey(), program_id);
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: Some(*authority),
-                program_id: Some(*program_id),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-async fn setup_with_confidential_transfers(
-    mint: Keypair,
-    program_id: &Pubkey,
-    authority: &Pubkey,
-) -> TestContext {
-    let mut program_test = setup_program_test(program_id);
-    add_validation_account(&mut program_test, &mint.pubkey(), program_id);
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![
-                ExtensionInitializationParams::TransferHook {
-                    authority: Some(*authority),
-                    program_id: Some(*program_id),
-                },
-                ExtensionInitializationParams::ConfidentialTransferMint {
-                    authority: Some(*authority),
-                    auto_approve_new_accounts: true,
-                    auditor_elgamal_pubkey: None,
-                },
-            ],
-            None,
-        )
-        .await
-        .unwrap();
-    context
-}
-
-#[tokio::test]
-async fn success_init() {
-    let authority = Pubkey::new_unique();
-    let program_id = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &program_id, &authority)
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-
-    let state = token.get_mint_info().await.unwrap();
-    assert!(state.base.is_initialized);
-    let extension = state.get_extension::<TransferHook>().unwrap();
-    assert_eq!(extension.authority, Some(authority).try_into().unwrap());
-    assert_eq!(extension.program_id, Some(program_id).try_into().unwrap());
-}
-
-#[tokio::test]
-async fn fail_init_all_none() {
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    let err = context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            Keypair::new(),
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: None,
-                program_id: None,
-            }],
-            None,
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                1,
-                InstructionError::Custom(TokenError::InvalidInstruction as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn set_authority() {
-    let authority = Keypair::new();
-    let program_id = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &program_id, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_authority = Keypair::new();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &wrong.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::TransferHookProgramId,
-            &[&wrong],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .set_authority(
-            token.get_address(),
-            &authority.pubkey(),
-            Some(&new_authority.pubkey()),
-            instruction::AuthorityType::TransferHookProgramId,
-            &[&authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferHook>().unwrap();
-    assert_eq!(
-        extension.authority,
-        Some(new_authority.pubkey()).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            None,
-            instruction::AuthorityType::TransferHookProgramId,
-            &[&new_authority],
-        )
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferHook>().unwrap();
-    assert_eq!(extension.authority, None.try_into().unwrap(),);
-
-    // fail set again
-    let err = token
-        .set_authority(
-            token.get_address(),
-            &new_authority.pubkey(),
-            Some(&authority.pubkey()),
-            instruction::AuthorityType::TransferHookProgramId,
-            &[&new_authority],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::AuthorityTypeNotSupported as u32)
-            )
-        )))
-    );
-}
-
-#[tokio::test]
-async fn update_transfer_hook_program_id() {
-    let authority = Keypair::new();
-    let program_id = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token = setup(mint_keypair, &program_id, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap()
-        .token;
-    let new_program_id = Pubkey::new_unique();
-
-    // fail, wrong signature
-    let wrong = Keypair::new();
-    let err = token
-        .update_transfer_hook_program_id(&wrong.pubkey(), Some(new_program_id), &[&wrong])
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(TokenError::OwnerMismatch as u32)
-            )
-        )))
-    );
-
-    // success
-    token
-        .update_transfer_hook_program_id(&authority.pubkey(), Some(new_program_id), &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferHook>().unwrap();
-    assert_eq!(
-        extension.program_id,
-        Some(new_program_id).try_into().unwrap(),
-    );
-
-    // set to none
-    token
-        .update_transfer_hook_program_id(&authority.pubkey(), None, &[&authority])
-        .await
-        .unwrap();
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<TransferHook>().unwrap();
-    assert_eq!(extension.program_id, None.try_into().unwrap(),);
-}
-
-#[tokio::test]
-async fn success_transfer() {
-    let authority = Keypair::new();
-    let program_id = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token_context = setup(mint_keypair, &program_id, &authority.pubkey())
-        .await
-        .token_context
-        .take()
-        .unwrap();
-    let amount = 10;
-    let (alice_account, bob_account) =
-        setup_accounts(&token_context, Keypair::new(), Keypair::new(), amount).await;
-
-    token_context
-        .token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &token_context.alice.pubkey(),
-            amount,
-            &[&token_context.alice],
-        )
-        .await
-        .unwrap();
-
-    let destination = token_context
-        .token
-        .get_account_info(&bob_account)
-        .await
-        .unwrap();
-    assert_eq!(destination.base.amount, amount);
-
-    // the example program checks that the transferring flag was set to true,
-    // so make sure that it was correctly unset by the token program
-    assert_eq!(
-        destination
-            .get_extension::<TransferHookAccount>()
-            .unwrap()
-            .transferring,
-        false.into()
-    );
-    let source = token_context
-        .token
-        .get_account_info(&alice_account)
-        .await
-        .unwrap();
-    assert_eq!(
-        source
-            .get_extension::<TransferHookAccount>()
-            .unwrap()
-            .transferring,
-        false.into()
-    );
-}
-
-#[tokio::test]
-async fn fail_transfer_hook_program() {
-    let authority = Pubkey::new_unique();
-    let program_id = Pubkey::new_unique();
-    let mint = Keypair::new();
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test.add_program(
-        "my_transfer_hook",
-        program_id,
-        processor!(process_instruction_fail),
-    );
-    let validation_address = get_extra_account_metas_address(&mint.pubkey(), &program_id);
-    program_test.add_account(
-        validation_address,
-        Account {
-            lamports: 1_000_000_000, // a lot, just to be safe
-            data: spl_transfer_hook_example::state::example_data(&[]).unwrap(),
-            owner: program_id,
-            ..Account::default()
-        },
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: Some(authority),
-                program_id: Some(program_id),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    let token_context = context.token_context.take().unwrap();
-
-    let amount = 10;
-    let (alice_account, bob_account) =
-        setup_accounts(&token_context, Keypair::new(), Keypair::new(), amount).await;
-
-    let err = token_context
-        .token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &token_context.alice.pubkey(),
-            amount,
-            &[&token_context.alice],
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(
-        err,
-        TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::InvalidInstructionData)
-        )))
-    );
-}
-
-#[tokio::test]
-async fn success_downgrade_writable_and_signer_accounts() {
-    let authority = Pubkey::new_unique();
-    let program_id = Pubkey::new_unique();
-    let mint = Keypair::new();
-    let mut program_test = ProgramTest::default();
-    program_test.prefer_bpf(false);
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(Processor::process),
-    );
-    program_test.add_program(
-        "my_transfer_hook",
-        program_id,
-        processor!(process_instruction_downgrade),
-    );
-    let alice = Keypair::new();
-    let alice_account = Keypair::new();
-    let validation_address = get_extra_account_metas_address(&mint.pubkey(), &program_id);
-    let extra_account_metas = vec![
-        AccountMeta {
-            pubkey: alice_account.pubkey(),
-            is_signer: false,
-            is_writable: true,
-        }
-        .into(),
-        AccountMeta {
-            pubkey: alice.pubkey(),
-            is_signer: true,
-            is_writable: false,
-        }
-        .into(),
-    ];
-    program_test.add_account(
-        validation_address,
-        Account {
-            lamports: 1_000_000_000, // a lot, just to be safe
-            data: spl_transfer_hook_example::state::example_data(&extra_account_metas).unwrap(),
-            owner: program_id,
-            ..Account::default()
-        },
-    );
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context = TestContext {
-        context,
-        token_context: None,
-    };
-    context
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint,
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: Some(authority),
-                program_id: Some(program_id),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    let mut token_context = context.token_context.take().unwrap();
-    token_context.alice = alice;
-
-    let amount = 10;
-    let (alice_account, bob_account) =
-        setup_accounts(&token_context, alice_account, Keypair::new(), amount).await;
-
-    token_context
-        .token
-        .transfer(
-            &alice_account,
-            &bob_account,
-            &token_context.alice.pubkey(),
-            amount,
-            &[&token_context.alice],
-        )
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn success_transfers_using_onchain_helper() {
-    let authority = Pubkey::new_unique();
-    let program_id = Pubkey::new_unique();
-    let mint_a_keypair = Keypair::new();
-    let mint_a = mint_a_keypair.pubkey();
-    let mint_b_keypair = Keypair::new();
-    let mint_b = mint_b_keypair.pubkey();
-    let amount = 10;
-
-    let swap_program_id = Pubkey::new_unique();
-    let mut program_test = setup_program_test(&program_id);
-    program_test.add_program(
-        "my_swap",
-        swap_program_id,
-        processor!(process_instruction_swap),
-    );
-    add_validation_account(&mut program_test, &mint_a, &program_id);
-    add_validation_account(&mut program_test, &mint_b, &program_id);
-
-    let context = program_test.start_with_context().await;
-    let context = Arc::new(tokio::sync::Mutex::new(context));
-    let mut context_a = TestContext {
-        context: context.clone(),
-        token_context: None,
-    };
-    context_a
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint_a_keypair,
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: Some(authority),
-                program_id: Some(program_id),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    let token_a_context = context_a.token_context.unwrap();
-    let (source_a_account, destination_a_account) =
-        setup_accounts(&token_a_context, Keypair::new(), Keypair::new(), amount).await;
-    let authority_a = token_a_context.alice;
-    let token_a = token_a_context.token;
-    let mut context_b = TestContext {
-        context,
-        token_context: None,
-    };
-    context_b
-        .init_token_with_mint_keypair_and_freeze_authority(
-            mint_b_keypair,
-            vec![ExtensionInitializationParams::TransferHook {
-                authority: Some(authority),
-                program_id: Some(program_id),
-            }],
-            None,
-        )
-        .await
-        .unwrap();
-    let token_b_context = context_b.token_context.unwrap();
-    let (source_b_account, destination_b_account) =
-        setup_accounts(&token_b_context, Keypair::new(), Keypair::new(), amount).await;
-    let authority_b = token_b_context.alice;
-    let account_metas = vec![
-        AccountMeta::new(source_a_account, false),
-        AccountMeta::new_readonly(mint_a, false),
-        AccountMeta::new(destination_a_account, false),
-        AccountMeta::new_readonly(authority_a.pubkey(), true),
-        AccountMeta::new_readonly(spl_token_2022::id(), false),
-        AccountMeta::new(source_b_account, false),
-        AccountMeta::new_readonly(mint_b, false),
-        AccountMeta::new(destination_b_account, false),
-        AccountMeta::new_readonly(authority_b.pubkey(), true),
-        AccountMeta::new_readonly(spl_token_2022::id(), false),
-    ];
-
-    let mut instruction = Instruction::new_with_bytes(swap_program_id, &[], account_metas);
-
-    add_extra_account_metas_for_execute(
-        &mut instruction,
-        &program_id,
-        &source_a_account,
-        &mint_a,
-        &destination_a_account,
-        &authority_a.pubkey(),
-        amount,
-        |address| {
-            token_a.get_account(address).map_ok_or_else(
-                |e| match e {
-                    TokenClientError::AccountNotFound => Ok(None),
-                    _ => Err(offchain::AccountFetchError::from(e)),
-                },
-                |acc| Ok(Some(acc.data)),
-            )
-        },
-    )
-    .await
-    .unwrap();
-    add_extra_account_metas_for_execute(
-        &mut instruction,
-        &program_id,
-        &source_b_account,
-        &mint_b,
-        &destination_b_account,
-        &authority_b.pubkey(),
-        amount,
-        |address| {
-            token_a.get_account(address).map_ok_or_else(
-                |e| match e {
-                    TokenClientError::AccountNotFound => Ok(None),
-                    _ => Err(offchain::AccountFetchError::from(e)),
-                },
-                |acc| Ok(Some(acc.data)),
-            )
-        },
-    )
-    .await
-    .unwrap();
-
-    token_a
-        .process_ixs(&[instruction], &[&authority_a, &authority_b])
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn success_confidential_transfer() {
-    let authority = Keypair::new();
-    let program_id = Pubkey::new_unique();
-    let mint_keypair = Keypair::new();
-    let token_context =
-        setup_with_confidential_transfers(mint_keypair, &program_id, &authority.pubkey())
-            .await
-            .token_context
-            .take()
-            .unwrap();
-    let amount = 10;
-
-    let TokenContext {
-        token,
-        alice,
-        bob,
-        mint_authority,
-        decimals,
-        ..
-    } = token_context;
-
-    let alice_meta = ConfidentialTokenAccountMeta::new_with_tokens(
-        &token,
-        &alice,
-        None,
-        false,
-        false,
-        &mint_authority,
-        amount,
-        decimals,
-    )
-    .await;
-
-    let bob_meta = ConfidentialTokenAccountMeta::new(&token, &bob, Some(2), false, false).await;
-
-    token
-        .confidential_transfer_transfer(
-            &alice_meta.token_account,
-            &bob_meta.token_account,
-            &alice.pubkey(),
-            None,
-            amount,
-            None,
-            &alice_meta.elgamal_keypair,
-            &alice_meta.aes_key,
-            bob_meta.elgamal_keypair.pubkey(),
-            None, // auditor
-            &[&alice],
-        )
-        .await
-        .unwrap();
-
-    let destination = token
-        .get_account_info(&bob_meta.token_account)
-        .await
-        .unwrap();
-    alice_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: 0,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-    bob_meta
-        .check_balances(
-            &token,
-            ConfidentialTokenAccountBalances {
-                pending_balance_lo: amount,
-                pending_balance_hi: 0,
-                available_balance: 0,
-                decryptable_available_balance: 0,
-            },
-        )
-        .await;
-
-    // the example program checks that the transferring flag was set to true,
-    // so make sure that it was correctly unset by the token program
-    assert_eq!(
-        destination
-            .get_extension::<TransferHookAccount>()
-            .unwrap()
-            .transferring,
-        false.into()
-    );
-    let source = token
-        .get_account_info(&alice_meta.token_account)
-        .await
-        .unwrap();
-    assert_eq!(
-        source
-            .get_extension::<TransferHookAccount>()
-            .unwrap()
-            .transferring,
-        false.into()
-    );
-}
diff --git a/token/program-2022/Cargo.toml b/token/program-2022/Cargo.toml
deleted file mode 100644
index c123231d531..00000000000
--- a/token/program-2022/Cargo.toml
+++ /dev/null
@@ -1,57 +0,0 @@
-[package]
-name = "spl-token-2022"
-version = "3.0.2"
-description = "Solana Program Library Token 2022"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-exclude = ["js/**"]
-
-[features]
-no-entrypoint = []
-test-sbf = []
-serde-traits = ["dep:serde", "dep:serde_with", "dep:base64", "spl-pod/serde-traits"]
-default = ["confidential-hook", "token-group", "zk-ops"]
-# Remove this feature once the underlying syscalls are released on all networks
-zk-ops = []
-# Remove this feature once the token group implementation has been audited
-token-group = []
-# Remove this feature once the confidential transfer hook has been audited
-confidential-hook = []
-
-[dependencies]
-arrayref = "0.3.7"
-bytemuck = { version = "1.16.0", features = ["derive"] }
-num-derive = "0.4"
-num-traits = "0.2"
-num_enum = "0.7.2"
-solana-program = ">=1.18.11,<=2"
-solana-security-txt = "1.1.1"
-solana-zk-token-sdk = ">=1.18.11,<=2"
-spl-memo = { version = "4.0", path = "../../memo/program", features = [ "no-entrypoint" ] }
-spl-token = { version = "4.0",  path = "../program", features = ["no-entrypoint"] }
-spl-token-group-interface = { version = "0.2.3", path = "../../token-group/interface" }
-spl-token-metadata-interface = { version = "0.3.3", path = "../../token-metadata/interface" }
-spl-transfer-hook-interface = { version = "0.6.3", path = "../transfer-hook/interface" }
-spl-type-length-value = { version = "0.4.3", path = "../../libraries/type-length-value" }
-spl-pod = { version = "0.2.2", path = "../../libraries/pod" }
-thiserror = "1.0"
-serde = { version = "1.0.203", optional = true }
-serde_with = { version = "3.8.1", optional = true }
-base64 = { version = "0.22.1", optional = true }
-
-[dev-dependencies]
-lazy_static = "1.4.0"
-proptest = "1.4"
-serial_test = "3.1.1"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-tlv-account-resolution = { version = "0.6.3", path = "../../libraries/tlv-account-resolution" }
-serde_json = "1.0.117"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token/program-2022/README.md b/token/program-2022/README.md
deleted file mode 100644
index 54289de68e4..00000000000
--- a/token/program-2022/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Token-2022 program
-
-A token program on the Solana blockchain, usable for fungible and non-fungible tokens.
-
-This program provides an interface and implementation that third parties can
-utilize to create and use their tokens.
-
-Full documentation is available at https://spl.solana.com/token-2022
-
-## Audit
-
-The repository [README](https://github.com/solana-labs/solana-program-library#audits)
-contains information about program audits.
diff --git a/token/program-2022/Xargo.toml b/token/program-2022/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/token/program-2022/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/token/program-2022/inc/token.h b/token/program-2022/inc/token.h
deleted file mode 100644
index 145c0c5e07b..00000000000
--- a/token/program-2022/inc/token.h
+++ /dev/null
@@ -1,687 +0,0 @@
-/* Autogenerated SPL Token program C Bindings */
-
-#pragma once
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-/**
- * Minimum number of multisignature signers (min N)
- */
-#define Token_MIN_SIGNERS 1
-
-/**
- * Maximum number of multisignature signers (max N)
- */
-#define Token_MAX_SIGNERS 11
-
-/**
- * Account state.
- */
-enum Token_AccountState
-#ifdef __cplusplus
-  : uint8_t
-#endif // __cplusplus
- {
-    /**
-     * Account is not yet initialized
-     */
-    Token_AccountState_Uninitialized,
-    /**
-     * Account is initialized; the account owner and/or delegate may perform permitted operations
-     * on this account
-     */
-    Token_AccountState_Initialized,
-    /**
-     * Account has been frozen by the mint freeze authority. Neither the account owner nor
-     * the delegate are able to perform operations on this account.
-     */
-    Token_AccountState_Frozen,
-};
-#ifndef __cplusplus
-typedef uint8_t Token_AccountState;
-#endif // __cplusplus
-
-/**
- * Specifies the authority type for SetAuthority instructions
- */
-enum Token_AuthorityType
-#ifdef __cplusplus
-  : uint8_t
-#endif // __cplusplus
- {
-    /**
-     * Authority to mint new tokens
-     */
-    Token_AuthorityType_MintTokens,
-    /**
-     * Authority to freeze any account associated with the Mint
-     */
-    Token_AuthorityType_FreezeAccount,
-    /**
-     * Owner of a given token account
-     */
-    Token_AuthorityType_AccountOwner,
-    /**
-     * Authority to close a token account
-     */
-    Token_AuthorityType_CloseAccount,
-};
-#ifndef __cplusplus
-typedef uint8_t Token_AuthorityType;
-#endif // __cplusplus
-
-typedef uint8_t Token_Pubkey[32];
-
-/**
- * A C representation of Rust's `std::option::Option`
- */
-typedef enum Token_COption_Pubkey_Tag {
-    /**
-     * No value
-     */
-    Token_COption_Pubkey_None_Pubkey,
-    /**
-     * Some value `T`
-     */
-    Token_COption_Pubkey_Some_Pubkey,
-} Token_COption_Pubkey_Tag;
-
-typedef struct Token_COption_Pubkey {
-    Token_COption_Pubkey_Tag tag;
-    union {
-        struct {
-            Token_Pubkey some;
-        };
-    };
-} Token_COption_Pubkey;
-
-/**
- * Instructions supported by the token program.
- */
-typedef enum Token_TokenInstruction_Tag {
-    /**
-     * Initializes a new mint and optionally deposits all the newly minted
-     * tokens in an account.
-     *
-     * The `InitializeMint` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]` The mint to initialize.
-     *   1. `[]` Rent sysvar
-     *
-     */
-    Token_TokenInstruction_InitializeMint,
-    /**
-     * Initializes a new account to hold tokens.  If this account is associated
-     * with the native mint then the token balance of the initialized account
-     * will be equal to the amount of SOL in the account. If this account is
-     * associated with another mint, that mint must be initialized before this
-     * command can succeed.
-     *
-     * The `InitializeAccount` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The account to initialize.
-     *   1. `[]` The mint this account will be associated with.
-     *   2. `[]` The new account's owner/multisignature.
-     *   3. `[]` Rent sysvar
-     */
-    Token_TokenInstruction_InitializeAccount,
-    /**
-     * Initializes a multisignature account with N provided signers.
-     *
-     * Multisignature accounts can used in place of any single owner/delegate
-     * accounts in any token instruction that require an owner/delegate to be
-     * present.  The variant field represents the number of signers (M)
-     * required to validate this multisignature account.
-     *
-     * The `InitializeMultisig` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]` The multisignature account to initialize.
-     *   1. `[]` Rent sysvar
-     *   2. ..2+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-     *      11.
-     */
-    Token_TokenInstruction_InitializeMultisig,
-    /**
-     * Transfers tokens from one account to another either directly or via a
-     * delegate.  If this account is associated with the native mint then equal
-     * amounts of SOL and Tokens will be transferred to the destination
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[writable]` The destination account.
-     *   2. `[signer]` The source account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[writable]` The destination account.
-     *   2. `[]` The source account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_Transfer,
-    /**
-     * Approves a delegate.  A delegate is given the authority over tokens on
-     * behalf of the source account's owner.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The delegate.
-     *   2. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The delegate.
-     *   2. `[]` The source account's multisignature owner.
-     *   3. ..3+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_Approve,
-    /**
-     * Revokes the delegate's authority.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The source account's multisignature owner.
-     *   2. ..2+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_Revoke,
-    /**
-     * Sets a new authority of a mint or account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint or account to change the authority of.
-     *   1. `[signer]` The current authority of the mint or account.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint or account to change the authority of.
-     *   1. `[]` The mint's or account's current multisignature authority.
-     *   2. ..2+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_SetAuthority,
-    /**
-     * Mints new tokens to an account.  The native mint does not support
-     * minting.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[signer]` The mint's minting authority.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[]` The mint's multisignature mint-tokens authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_MintTo,
-    /**
-     * Burns tokens by removing them from an account.  `Burn` does not support
-     * accounts associated with the native mint, use `CloseAccount` instead.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[signer]` The account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[]` The account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_Burn,
-    /**
-     * Close an account by transferring all its SOL to the destination account.
-     * Non-native accounts may only be closed if its token amount is zero.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to close.
-     *   1. `[writable]` The destination account.
-     *   2. `[signer]` The account's owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to close.
-     *   1. `[writable]` The destination account.
-     *   2. `[]` The account's multisignature owner.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_CloseAccount,
-    /**
-     * Freeze an Initialized account using the Mint's freeze_authority (if
-     * set).
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[signer]` The mint freeze authority.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[]` The mint's multisignature freeze authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_FreezeAccount,
-    /**
-     * Thaw a Frozen account using the Mint's freeze_authority (if set).
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[signer]` The mint freeze authority.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[]` The mint's multisignature freeze authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_ThawAccount,
-    /**
-     * Transfers tokens from one account to another either directly or via a
-     * delegate.  If this account is associated with the native mint then equal
-     * amounts of SOL and Tokens will be transferred to the destination
-     * account.
-     *
-     * This instruction differs from Transfer in that the token mint and
-     * decimals value is checked by the caller.  This may be useful when
-     * creating transactions offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[writable]` The destination account.
-     *   3. `[signer]` The source account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[writable]` The destination account.
-     *   3. `[]` The source account's multisignature owner/delegate.
-     *   4. ..4+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_TransferChecked,
-    /**
-     * Approves a delegate.  A delegate is given the authority over tokens on
-     * behalf of the source account's owner.
-     *
-     * This instruction differs from Approve in that the token mint and
-     * decimals value is checked by the caller.  This may be useful when
-     * creating transactions offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[]` The delegate.
-     *   3. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[]` The delegate.
-     *   3. `[]` The source account's multisignature owner.
-     *   4. ..4+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_ApproveChecked,
-    /**
-     * Mints new tokens to an account.  The native mint does not support
-     * minting.
-     *
-     * This instruction differs from MintTo in that the decimals value is
-     * checked by the caller.  This may be useful when creating transactions
-     * offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[signer]` The mint's minting authority.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[]` The mint's multisignature mint-tokens authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_MintToChecked,
-    /**
-     * Burns tokens by removing them from an account.  `BurnChecked` does not
-     * support accounts associated with the native mint, use `CloseAccount`
-     * instead.
-     *
-     * This instruction differs from Burn in that the decimals value is checked
-     * by the caller. This may be useful when creating transactions offline or
-     * within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[signer]` The account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[]` The account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_BurnChecked,
-    /**
-     * Like InitializeAccount, but the owner pubkey is passed via instruction data
-     * rather than the accounts list. This variant may be preferable when using
-     * Cross Program Invocation from an instruction that does not need the owner's
-     * `AccountInfo` otherwise.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The account to initialize.
-     *   1. `[]` The mint this account will be associated with.
-     *   3. `[]` Rent sysvar
-     */
-    Token_TokenInstruction_InitializeAccount2,
-    /**
-     * Given a wrapped / native token account (a token account containing SOL)
-     * updates its amount field based on the account's underlying `lamports`.
-     * This is useful if a non-wrapped SOL account uses `system_instruction::transfer`
-     * to move lamports to a wrapped token account, and needs to have its token
-     * `amount` field updated.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The native token account to sync with its underlying lamports.
-     */
-    Token_TokenInstruction_SyncNative,
-} Token_TokenInstruction_Tag;
-
-typedef struct Token_TokenInstruction_Token_InitializeMint_Body {
-    /**
-     * Number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-    /**
-     * The authority/multisignature to mint tokens.
-     */
-    Token_Pubkey mint_authority;
-    /**
-     * The freeze authority/multisignature of the mint.
-     */
-    struct Token_COption_Pubkey freeze_authority;
-} Token_TokenInstruction_Token_InitializeMint_Body;
-
-typedef struct Token_TokenInstruction_Token_InitializeMultisig_Body {
-    /**
-     * The number of signers (M) required to validate this multisignature
-     * account.
-     */
-    uint8_t m;
-} Token_TokenInstruction_Token_InitializeMultisig_Body;
-
-typedef struct Token_TokenInstruction_Token_Transfer_Body {
-    /**
-     * The amount of tokens to transfer.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Transfer_Body;
-
-typedef struct Token_TokenInstruction_Token_Approve_Body {
-    /**
-     * The amount of tokens the delegate is approved for.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Approve_Body;
-
-typedef struct Token_TokenInstruction_Token_SetAuthority_Body {
-    /**
-     * The type of authority to update.
-     */
-    Token_AuthorityType authority_type;
-    /**
-     * The new authority
-     */
-    struct Token_COption_Pubkey new_authority;
-} Token_TokenInstruction_Token_SetAuthority_Body;
-
-typedef struct Token_TokenInstruction_Token_MintTo_Body {
-    /**
-     * The amount of new tokens to mint.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_MintTo_Body;
-
-typedef struct Token_TokenInstruction_Token_Burn_Body {
-    /**
-     * The amount of tokens to burn.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Burn_Body;
-
-typedef struct Token_TokenInstruction_Token_TransferChecked_Body {
-    /**
-     * The amount of tokens to transfer.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_TransferChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_ApproveChecked_Body {
-    /**
-     * The amount of tokens the delegate is approved for.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_ApproveChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_MintToChecked_Body {
-    /**
-     * The amount of new tokens to mint.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_MintToChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_BurnChecked_Body {
-    /**
-     * The amount of tokens to burn.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_BurnChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_InitializeAccount2_Body {
-    /**
-     * The new account's owner/multisignature.
-     */
-    Token_Pubkey owner;
-} Token_TokenInstruction_Token_InitializeAccount2_Body;
-
-typedef struct Token_TokenInstruction {
-    Token_TokenInstruction_Tag tag;
-    union {
-        Token_TokenInstruction_Token_InitializeMint_Body initialize_mint;
-        Token_TokenInstruction_Token_InitializeMultisig_Body initialize_multisig;
-        Token_TokenInstruction_Token_Transfer_Body transfer;
-        Token_TokenInstruction_Token_Approve_Body approve;
-        Token_TokenInstruction_Token_SetAuthority_Body set_authority;
-        Token_TokenInstruction_Token_MintTo_Body mint_to;
-        Token_TokenInstruction_Token_Burn_Body burn;
-        Token_TokenInstruction_Token_TransferChecked_Body transfer_checked;
-        Token_TokenInstruction_Token_ApproveChecked_Body approve_checked;
-        Token_TokenInstruction_Token_MintToChecked_Body mint_to_checked;
-        Token_TokenInstruction_Token_BurnChecked_Body burn_checked;
-        Token_TokenInstruction_Token_InitializeAccount2_Body initialize_account2;
-    };
-} Token_TokenInstruction;
-
-/**
- * Mint data.
- */
-typedef struct Token_Mint {
-    /**
-     * Optional authority used to mint new tokens. The mint authority may only be provided during
-     * mint creation. If no mint authority is present then the mint has a fixed supply and no
-     * further tokens may be minted.
-     */
-    struct Token_COption_Pubkey mint_authority;
-    /**
-     * Total supply of tokens.
-     */
-    uint64_t supply;
-    /**
-     * Number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-    /**
-     * Is `true` if this structure has been initialized
-     */
-    bool is_initialized;
-    /**
-     * Optional authority to freeze token accounts.
-     */
-    struct Token_COption_Pubkey freeze_authority;
-} Token_Mint;
-
-/**
- * A C representation of Rust's `std::option::Option`
- */
-typedef enum Token_COption_u64_Tag {
-    /**
-     * No value
-     */
-    Token_COption_u64_None_u64,
-    /**
-     * Some value `T`
-     */
-    Token_COption_u64_Some_u64,
-} Token_COption_u64_Tag;
-
-typedef struct Token_COption_u64 {
-    Token_COption_u64_Tag tag;
-    union {
-        struct {
-            uint64_t some;
-        };
-    };
-} Token_COption_u64;
-
-/**
- * Account data.
- */
-typedef struct Token_Account {
-    /**
-     * The mint associated with this account
-     */
-    Token_Pubkey mint;
-    /**
-     * The owner of this account.
-     */
-    Token_Pubkey owner;
-    /**
-     * The amount of tokens this account holds.
-     */
-    uint64_t amount;
-    /**
-     * If `delegate` is `Some` then `delegated_amount` represents
-     * the amount authorized by the delegate
-     */
-    struct Token_COption_Pubkey delegate;
-    /**
-     * The account's state
-     */
-    Token_AccountState state;
-    /**
-     * If is_some, this is a native token, and the value logs the rent-exempt reserve. An Account
-     * is required to be rent-exempt, so the value is used by the Processor to ensure that wrapped
-     * SOL accounts do not drop below this threshold.
-     */
-    struct Token_COption_u64 is_native;
-    /**
-     * The amount delegated
-     */
-    uint64_t delegated_amount;
-    /**
-     * Optional authority to close the account.
-     */
-    struct Token_COption_Pubkey close_authority;
-} Token_Account;
-
-/**
- * Multisignature data.
- */
-typedef struct Token_Multisig {
-    /**
-     * Number of signers required
-     */
-    uint8_t m;
-    /**
-     * Number of valid signers
-     */
-    uint8_t n;
-    /**
-     * Is `true` if this structure has been initialized
-     */
-    bool is_initialized;
-    /**
-     * Signer public keys
-     */
-    Token_Pubkey signers[Token_MAX_SIGNERS];
-} Token_Multisig;
diff --git a/token/program-2022/program-id.md b/token/program-2022/program-id.md
deleted file mode 100644
index 7d999512781..00000000000
--- a/token/program-2022/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
diff --git a/token/program-2022/src/entrypoint.rs b/token/program-2022/src/entrypoint.rs
deleted file mode 100644
index d7a0825e3bd..00000000000
--- a/token/program-2022/src/entrypoint.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Program entrypoint
-
-use {
-    crate::{error::TokenError, processor::Processor},
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    solana_security_txt::security_txt,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<TokenError>();
-        return Err(error);
-    }
-    Ok(())
-}
-
-security_txt! {
-    // Required fields
-    name: "SPL Token-2022",
-    project_url: "https://spl.solana.com/token-2022",
-    contacts: "link:https://github.com/solana-labs/solana-program-library/security/advisories/new,mailto:security@solana.com,discord:https://solana.com/discord",
-    policy: "https://github.com/solana-labs/solana-program-library/blob/master/SECURITY.md",
-
-    // Optional Fields
-    preferred_languages: "en",
-    source_code: "https://github.com/solana-labs/solana-program-library/tree/master/token/program-2022",
-    source_revision: "15ebdb6440a4585a908ee3d91429561d64afebf6",
-    source_release: "token-2022-v1.0.0",
-    auditors: "https://github.com/solana-labs/security-audits#token-2022"
-}
diff --git a/token/program-2022/src/error.rs b/token/program-2022/src/error.rs
deleted file mode 100644
index ff004f0ffb7..00000000000
--- a/token/program-2022/src/error.rs
+++ /dev/null
@@ -1,423 +0,0 @@
-//! Error types
-
-use {
-    num_derive::FromPrimitive,
-    solana_program::{
-        decode_error::DecodeError,
-        msg,
-        program_error::{PrintProgramError, ProgramError},
-    },
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the Token program.
-#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
-pub enum TokenError {
-    // 0
-    /// Lamport balance below rent-exempt threshold.
-    #[error("Lamport balance below rent-exempt threshold")]
-    NotRentExempt,
-    /// Insufficient funds for the operation requested.
-    #[error("Insufficient funds")]
-    InsufficientFunds,
-    /// Invalid Mint.
-    #[error("Invalid Mint")]
-    InvalidMint,
-    /// Account not associated with this Mint.
-    #[error("Account not associated with this Mint")]
-    MintMismatch,
-    /// Owner does not match.
-    #[error("Owner does not match")]
-    OwnerMismatch,
-
-    // 5
-    /// This token's supply is fixed and new tokens cannot be minted.
-    #[error("Fixed supply")]
-    FixedSupply,
-    /// The account cannot be initialized because it is already being used.
-    #[error("Already in use")]
-    AlreadyInUse,
-    /// Invalid number of provided signers.
-    #[error("Invalid number of provided signers")]
-    InvalidNumberOfProvidedSigners,
-    /// Invalid number of required signers.
-    #[error("Invalid number of required signers")]
-    InvalidNumberOfRequiredSigners,
-    /// State is uninitialized.
-    #[error("State is uninitialized")]
-    UninitializedState,
-
-    // 10
-    /// Instruction does not support native tokens
-    #[error("Instruction does not support native tokens")]
-    NativeNotSupported,
-    /// Non-native account can only be closed if its balance is zero
-    #[error("Non-native account can only be closed if its balance is zero")]
-    NonNativeHasBalance,
-    /// Invalid instruction
-    #[error("Invalid instruction")]
-    InvalidInstruction,
-    /// State is invalid for requested operation.
-    #[error("State is invalid for requested operation")]
-    InvalidState,
-    /// Operation overflowed
-    #[error("Operation overflowed")]
-    Overflow,
-
-    // 15
-    /// Account does not support specified authority type.
-    #[error("Account does not support specified authority type")]
-    AuthorityTypeNotSupported,
-    /// This token mint cannot freeze accounts.
-    #[error("This token mint cannot freeze accounts")]
-    MintCannotFreeze,
-    /// Account is frozen; all account operations will fail
-    #[error("Account is frozen")]
-    AccountFrozen,
-    /// Mint decimals mismatch between the client and mint
-    #[error("The provided decimals value different from the Mint decimals")]
-    MintDecimalsMismatch,
-    /// Instruction does not support non-native tokens
-    #[error("Instruction does not support non-native tokens")]
-    NonNativeNotSupported,
-
-    // 20
-    /// Extension type does not match already existing extensions
-    #[error("Extension type does not match already existing extensions")]
-    ExtensionTypeMismatch,
-    /// Extension does not match the base type provided
-    #[error("Extension does not match the base type provided")]
-    ExtensionBaseMismatch,
-    /// Extension already initialized on this account
-    #[error("Extension already initialized on this account")]
-    ExtensionAlreadyInitialized,
-    /// An account can only be closed if its confidential balance is zero
-    #[error("An account can only be closed if its confidential balance is zero")]
-    ConfidentialTransferAccountHasBalance,
-    /// Account not approved for confidential transfers
-    #[error("Account not approved for confidential transfers")]
-    ConfidentialTransferAccountNotApproved,
-
-    // 25
-    /// Account not accepting deposits or transfers
-    #[error("Account not accepting deposits or transfers")]
-    ConfidentialTransferDepositsAndTransfersDisabled,
-    /// ElGamal public key mismatch
-    #[error("ElGamal public key mismatch")]
-    ConfidentialTransferElGamalPubkeyMismatch,
-    /// Balance mismatch
-    #[error("Balance mismatch")]
-    ConfidentialTransferBalanceMismatch,
-    /// Mint has non-zero supply. Burn all tokens before closing the mint.
-    #[error("Mint has non-zero supply. Burn all tokens before closing the mint")]
-    MintHasSupply,
-    /// No authority exists to perform the desired operation
-    #[error("No authority exists to perform the desired operation")]
-    NoAuthorityExists,
-
-    // 30
-    /// Transfer fee exceeds maximum of 10,000 basis points
-    #[error("Transfer fee exceeds maximum of 10,000 basis points")]
-    TransferFeeExceedsMaximum,
-    /// Mint required for this account to transfer tokens, use
-    /// `transfer_checked` or `transfer_checked_with_fee`
-    #[error("Mint required for this account to transfer tokens, use `transfer_checked` or `transfer_checked_with_fee`")]
-    MintRequiredForTransfer,
-    /// Calculated fee does not match expected fee
-    #[error("Calculated fee does not match expected fee")]
-    FeeMismatch,
-    /// Fee parameters associated with confidential transfer zero-knowledge
-    /// proofs do not match fee parameters in mint
-    #[error(
-        "Fee parameters associated with zero-knowledge proofs do not match fee parameters in mint"
-    )]
-    FeeParametersMismatch,
-    /// The owner authority cannot be changed
-    #[error("The owner authority cannot be changed")]
-    ImmutableOwner,
-
-    // 35
-    /// An account can only be closed if its withheld fee balance is zero,
-    /// harvest fees to the mint and try again
-    #[error("An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again")]
-    AccountHasWithheldTransferFees,
-    /// No memo in previous instruction; required for recipient to receive a
-    /// transfer
-    #[error("No memo in previous instruction; required for recipient to receive a transfer")]
-    NoMemo,
-    /// Transfer is disabled for this mint
-    #[error("Transfer is disabled for this mint")]
-    NonTransferable,
-    /// Non-transferable tokens can't be minted to an account without immutable
-    /// ownership
-    #[error("Non-transferable tokens can't be minted to an account without immutable ownership")]
-    NonTransferableNeedsImmutableOwnership,
-    /// The total number of `Deposit` and `Transfer` instructions to an account
-    /// cannot exceed the associated
-    /// `maximum_pending_balance_credit_counter`
-    #[error(
-        "The total number of `Deposit` and `Transfer` instructions to an account cannot exceed
-            the associated `maximum_pending_balance_credit_counter`"
-    )]
-    MaximumPendingBalanceCreditCounterExceeded,
-
-    // 40
-    /// The deposit amount for the confidential extension exceeds the maximum
-    /// limit
-    #[error("Deposit amount exceeds maximum limit")]
-    MaximumDepositAmountExceeded,
-    /// CPI Guard cannot be enabled or disabled in CPI
-    #[error("CPI Guard cannot be enabled or disabled in CPI")]
-    CpiGuardSettingsLocked,
-    /// CPI Guard is enabled, and a program attempted to transfer user funds
-    /// without using a delegate
-    #[error("CPI Guard is enabled, and a program attempted to transfer user funds via CPI without using a delegate")]
-    CpiGuardTransferBlocked,
-    /// CPI Guard is enabled, and a program attempted to burn user funds without
-    /// using a delegate
-    #[error(
-        "CPI Guard is enabled, and a program attempted to burn user funds via CPI without using a delegate"
-    )]
-    CpiGuardBurnBlocked,
-    /// CPI Guard is enabled, and a program attempted to close an account
-    /// without returning lamports to owner
-    #[error("CPI Guard is enabled, and a program attempted to close an account via CPI without returning lamports to owner")]
-    CpiGuardCloseAccountBlocked,
-
-    // 45
-    /// CPI Guard is enabled, and a program attempted to approve a delegate
-    #[error("CPI Guard is enabled, and a program attempted to approve a delegate via CPI")]
-    CpiGuardApproveBlocked,
-    /// CPI Guard is enabled, and a program attempted to add or replace an
-    /// authority
-    #[error(
-        "CPI Guard is enabled, and a program attempted to add or replace an authority via CPI"
-    )]
-    CpiGuardSetAuthorityBlocked,
-    /// Account ownership cannot be changed while CPI Guard is enabled
-    #[error("Account ownership cannot be changed while CPI Guard is enabled")]
-    CpiGuardOwnerChangeBlocked,
-    /// Extension not found in account data
-    #[error("Extension not found in account data")]
-    ExtensionNotFound,
-    /// Account does not accept non-confidential transfers
-    #[error("Non-confidential transfers disabled")]
-    NonConfidentialTransfersDisabled,
-
-    // 50
-    /// An account can only be closed if the confidential withheld fee is zero
-    #[error("An account can only be closed if the confidential withheld fee is zero")]
-    ConfidentialTransferFeeAccountHasWithheldFee,
-    /// A mint or an account is initialized to an invalid combination of
-    /// extensions
-    #[error("A mint or an account is initialized to an invalid combination of extensions")]
-    InvalidExtensionCombination,
-    /// Extension allocation with overwrite must use the same length
-    #[error("Extension allocation with overwrite must use the same length")]
-    InvalidLengthForAlloc,
-    /// Failed to decrypt a confidential transfer account
-    #[error("Failed to decrypt a confidential transfer account")]
-    AccountDecryption,
-    /// Failed to generate a zero-knowledge proof needed for a token instruction
-    #[error("Failed to generate proof")]
-    ProofGeneration,
-
-    // 55
-    /// An invalid proof instruction offset was provided
-    #[error("An invalid proof instruction offset was provided")]
-    InvalidProofInstructionOffset,
-    /// Harvest of withheld tokens to mint is disabled
-    #[error("Harvest of withheld tokens to mint is disabled")]
-    HarvestToMintDisabled,
-    /// Split proof context state accounts not supported for instruction
-    #[error("Split proof context state accounts not supported for instruction")]
-    SplitProofContextStateAccountsNotSupported,
-    /// Not enough proof context state accounts provided
-    #[error("Not enough proof context state accounts provided")]
-    NotEnoughProofContextStateAccounts,
-    /// Ciphertext is malformed
-    #[error("Ciphertext is malformed")]
-    MalformedCiphertext,
-
-    // 60
-    /// Ciphertext arithmetic failed
-    #[error("Ciphertext arithmetic failed")]
-    CiphertextArithmeticFailed,
-}
-impl From<TokenError> for ProgramError {
-    fn from(e: TokenError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for TokenError {
-    fn type_of() -> &'static str {
-        "TokenError"
-    }
-}
-
-impl PrintProgramError for TokenError {
-    fn print<E>(&self)
-    where
-        E: 'static + std::error::Error + DecodeError<E> + num_traits::FromPrimitive,
-    {
-        match self {
-            TokenError::NotRentExempt => msg!("Error: Lamport balance below rent-exempt threshold"),
-            TokenError::InsufficientFunds => msg!("Error: insufficient funds"),
-            TokenError::InvalidMint => msg!("Error: Invalid Mint"),
-            TokenError::MintMismatch => msg!("Error: Account not associated with this Mint"),
-            TokenError::OwnerMismatch => msg!("Error: owner does not match"),
-            TokenError::FixedSupply => msg!("Error: the total supply of this token is fixed"),
-            TokenError::AlreadyInUse => msg!("Error: account or token already in use"),
-            TokenError::InvalidNumberOfProvidedSigners => {
-                msg!("Error: Invalid number of provided signers")
-            }
-            TokenError::InvalidNumberOfRequiredSigners => {
-                msg!("Error: Invalid number of required signers")
-            }
-            TokenError::UninitializedState => msg!("Error: State is uninitialized"),
-            TokenError::NativeNotSupported => {
-                msg!("Error: Instruction does not support native tokens")
-            }
-            TokenError::NonNativeHasBalance => {
-                msg!("Error: Non-native account can only be closed if its balance is zero")
-            }
-            TokenError::InvalidInstruction => msg!("Error: Invalid instruction"),
-            TokenError::InvalidState => msg!("Error: Invalid account state for operation"),
-            TokenError::Overflow => msg!("Error: Operation overflowed"),
-            TokenError::AuthorityTypeNotSupported => {
-                msg!("Error: Account does not support specified authority type")
-            }
-            TokenError::MintCannotFreeze => msg!("Error: This token mint cannot freeze accounts"),
-            TokenError::AccountFrozen => msg!("Error: Account is frozen"),
-            TokenError::MintDecimalsMismatch => {
-                msg!("Error: decimals different from the Mint decimals")
-            }
-            TokenError::NonNativeNotSupported => {
-                msg!("Error: Instruction does not support non-native tokens")
-            }
-            TokenError::ExtensionTypeMismatch => {
-                msg!("Error: New extension type does not match already existing extensions")
-            }
-            TokenError::ExtensionBaseMismatch => {
-                msg!("Error: Extension does not match the base type provided")
-            }
-            TokenError::ExtensionAlreadyInitialized => {
-                msg!("Error: Extension already initialized on this account")
-            }
-            TokenError::ConfidentialTransferAccountHasBalance => {
-                msg!("Error: An account can only be closed if its confidential balance is zero")
-            }
-            TokenError::ConfidentialTransferAccountNotApproved => {
-                msg!("Error: Account not approved for confidential transfers")
-            }
-            TokenError::ConfidentialTransferDepositsAndTransfersDisabled => {
-                msg!("Error: Account not accepting deposits or transfers")
-            }
-            TokenError::ConfidentialTransferElGamalPubkeyMismatch => {
-                msg!("Error: ElGamal public key mismatch")
-            }
-            TokenError::ConfidentialTransferBalanceMismatch => {
-                msg!("Error: Balance mismatch")
-            }
-            TokenError::MintHasSupply => {
-                msg!("Error: Mint has non-zero supply. Burn all tokens before closing the mint")
-            }
-            TokenError::NoAuthorityExists => {
-                msg!("Error: No authority exists to perform the desired operation");
-            }
-            TokenError::TransferFeeExceedsMaximum => {
-                msg!("Error: Transfer fee exceeds maximum of 10,000 basis points");
-            }
-            TokenError::MintRequiredForTransfer => {
-                msg!("Mint required for this account to transfer tokens, use `transfer_checked` or `transfer_checked_with_fee`");
-            }
-            TokenError::FeeMismatch => {
-                msg!("Calculated fee does not match expected fee");
-            }
-            TokenError::FeeParametersMismatch => {
-                msg!("Fee parameters associated with zero-knowledge proofs do not match fee parameters in mint")
-            }
-            TokenError::ImmutableOwner => {
-                msg!("The owner authority cannot be changed");
-            }
-            TokenError::AccountHasWithheldTransferFees => {
-                msg!("Error: An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again");
-            }
-            TokenError::NoMemo => {
-                msg!("Error: No memo in previous instruction; required for recipient to receive a transfer");
-            }
-            TokenError::NonTransferable => {
-                msg!("Transfer is disabled for this mint");
-            }
-            TokenError::NonTransferableNeedsImmutableOwnership => {
-                msg!("Non-transferable tokens can't be minted to an account without immutable ownership");
-            }
-            TokenError::MaximumPendingBalanceCreditCounterExceeded => {
-                msg!("The total number of `Deposit` and `Transfer` instructions to an account cannot exceed the associated `maximum_pending_balance_credit_counter`");
-            }
-            TokenError::MaximumDepositAmountExceeded => {
-                msg!("Deposit amount exceeds maximum limit")
-            }
-            TokenError::CpiGuardSettingsLocked => {
-                msg!("CPI Guard status cannot be changed in CPI")
-            }
-            TokenError::CpiGuardTransferBlocked => {
-                msg!("CPI Guard is enabled, and a program attempted to transfer user funds without using a delegate")
-            }
-            TokenError::CpiGuardBurnBlocked => {
-                msg!("CPI Guard is enabled, and a program attempted to burn user funds without using a delegate")
-            }
-            TokenError::CpiGuardCloseAccountBlocked => {
-                msg!("CPI Guard is enabled, and a program attempted to close an account without returning lamports to owner")
-            }
-            TokenError::CpiGuardApproveBlocked => {
-                msg!("CPI Guard is enabled, and a program attempted to approve a delegate")
-            }
-            TokenError::CpiGuardSetAuthorityBlocked => {
-                msg!("CPI Guard is enabled, and a program attempted to add or change an authority")
-            }
-            TokenError::CpiGuardOwnerChangeBlocked => {
-                msg!("Account ownership cannot be changed while CPI Guard is enabled")
-            }
-            TokenError::ExtensionNotFound => {
-                msg!("Extension not found in account data")
-            }
-            TokenError::NonConfidentialTransfersDisabled => {
-                msg!("Non-confidential transfers disabled")
-            }
-            TokenError::ConfidentialTransferFeeAccountHasWithheldFee => {
-                msg!("Account has non-zero confidential withheld fee")
-            }
-            TokenError::InvalidExtensionCombination => {
-                msg!("Mint or account is initialized to an invalid combination of extensions")
-            }
-            TokenError::InvalidLengthForAlloc => {
-                msg!("Extension allocation with overwrite must use the same length")
-            }
-            TokenError::AccountDecryption => {
-                msg!("Failed to decrypt a confidential transfer account")
-            }
-            TokenError::ProofGeneration => {
-                msg!("Failed to generate proof")
-            }
-            TokenError::InvalidProofInstructionOffset => {
-                msg!("An invalid proof instruction offset was provided")
-            }
-            TokenError::HarvestToMintDisabled => {
-                msg!("Harvest of withheld tokens to mint is disabled")
-            }
-            TokenError::SplitProofContextStateAccountsNotSupported => {
-                msg!("Split proof context state accounts not supported for instruction")
-            }
-            TokenError::NotEnoughProofContextStateAccounts => {
-                msg!("Not enough proof context state accounts provided")
-            }
-            TokenError::MalformedCiphertext => {
-                msg!("Ciphertext is malformed")
-            }
-            TokenError::CiphertextArithmeticFailed => {
-                msg!("Ciphertext arithmetic failed")
-            }
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/account_info.rs b/token/program-2022/src/extension/confidential_transfer/account_info.rs
deleted file mode 100644
index bfa88b73b3e..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/account_info.rs
+++ /dev/null
@@ -1,374 +0,0 @@
-use {
-    crate::{
-        error::TokenError,
-        extension::confidential_transfer::{
-            ciphertext_extraction::SourceDecryptHandles,
-            split_proof_generation::transfer_split_proof_data, ConfidentialTransferAccount,
-            DecryptableBalance, EncryptedBalance, PENDING_BALANCE_LO_BIT_LENGTH,
-        },
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_zk_token_sdk::{
-        encryption::{
-            auth_encryption::{AeCiphertext, AeKey},
-            elgamal::{ElGamalKeypair, ElGamalPubkey, ElGamalSecretKey},
-        },
-        instruction::{
-            transfer::{FeeParameters, TransferData, TransferWithFeeData},
-            withdraw::WithdrawData,
-            zero_balance::ZeroBalanceProofData,
-            BatchedGroupedCiphertext2HandlesValidityProofData, BatchedRangeProofU128Data,
-            CiphertextCommitmentEqualityProofData,
-        },
-    },
-    spl_pod::primitives::PodU64,
-};
-
-/// Confidential transfer extension information needed to construct an
-/// `EmptyAccount` instruction.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct EmptyAccountAccountInfo {
-    /// The available balance
-    pub(crate) available_balance: EncryptedBalance,
-}
-impl EmptyAccountAccountInfo {
-    /// Create the `EmptyAccount` instruction account information from
-    /// `ConfidentialTransferAccount`.
-    pub fn new(account: &ConfidentialTransferAccount) -> Self {
-        Self {
-            available_balance: account.available_balance,
-        }
-    }
-
-    /// Create an empty account proof data.
-    pub fn generate_proof_data(
-        &self,
-        elgamal_keypair: &ElGamalKeypair,
-    ) -> Result<ZeroBalanceProofData, TokenError> {
-        let available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-
-        ZeroBalanceProofData::new(elgamal_keypair, &available_balance)
-            .map_err(|_| TokenError::ProofGeneration)
-    }
-}
-
-/// Confidential Transfer extension information needed to construct an
-/// `ApplyPendingBalance` instruction.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ApplyPendingBalanceAccountInfo {
-    /// The total number of `Deposit` and `Transfer` instructions that have
-    /// credited `pending_balance`
-    pub(crate) pending_balance_credit_counter: PodU64,
-    /// The low 16 bits of the pending balance (encrypted by `elgamal_pubkey`)
-    pub(crate) pending_balance_lo: EncryptedBalance,
-    /// The high 48 bits of the pending balance (encrypted by `elgamal_pubkey`)
-    pub(crate) pending_balance_hi: EncryptedBalance,
-    /// The decryptable available balance
-    pub(crate) decryptable_available_balance: DecryptableBalance,
-}
-impl ApplyPendingBalanceAccountInfo {
-    /// Create the `ApplyPendingBalance` instruction account information from
-    /// `ConfidentialTransferAccount`.
-    pub fn new(account: &ConfidentialTransferAccount) -> Self {
-        Self {
-            pending_balance_credit_counter: account.pending_balance_credit_counter,
-            pending_balance_lo: account.pending_balance_lo,
-            pending_balance_hi: account.pending_balance_hi,
-            decryptable_available_balance: account.decryptable_available_balance,
-        }
-    }
-
-    /// Return the pending balance credit counter of the account.
-    pub fn pending_balance_credit_counter(&self) -> u64 {
-        self.pending_balance_credit_counter.into()
-    }
-
-    fn decrypted_pending_balance_lo(
-        &self,
-        elgamal_secret_key: &ElGamalSecretKey,
-    ) -> Result<u64, TokenError> {
-        let pending_balance_lo = self
-            .pending_balance_lo
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        elgamal_secret_key
-            .decrypt_u32(&pending_balance_lo)
-            .ok_or(TokenError::AccountDecryption)
-    }
-
-    fn decrypted_pending_balance_hi(
-        &self,
-        elgamal_secret_key: &ElGamalSecretKey,
-    ) -> Result<u64, TokenError> {
-        let pending_balance_hi = self
-            .pending_balance_hi
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        elgamal_secret_key
-            .decrypt_u32(&pending_balance_hi)
-            .ok_or(TokenError::AccountDecryption)
-    }
-
-    fn decrypted_available_balance(&self, aes_key: &AeKey) -> Result<u64, TokenError> {
-        let decryptable_available_balance = self
-            .decryptable_available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        aes_key
-            .decrypt(&decryptable_available_balance)
-            .ok_or(TokenError::AccountDecryption)
-    }
-
-    /// Update the decryptable available balance.
-    pub fn new_decryptable_available_balance(
-        &self,
-        elgamal_secret_key: &ElGamalSecretKey,
-        aes_key: &AeKey,
-    ) -> Result<AeCiphertext, TokenError> {
-        let decrypted_pending_balance_lo = self.decrypted_pending_balance_lo(elgamal_secret_key)?;
-        let decrypted_pending_balance_hi = self.decrypted_pending_balance_hi(elgamal_secret_key)?;
-        let pending_balance =
-            combine_balances(decrypted_pending_balance_lo, decrypted_pending_balance_hi)
-                .ok_or(TokenError::AccountDecryption)?;
-        let current_available_balance = self.decrypted_available_balance(aes_key)?;
-        let new_decrypted_available_balance = current_available_balance
-            .checked_add(pending_balance)
-            .unwrap(); // total balance cannot exceed `u64`
-
-        Ok(aes_key.encrypt(new_decrypted_available_balance))
-    }
-}
-
-/// Confidential Transfer extension information needed to construct a `Withdraw`
-/// instruction.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct WithdrawAccountInfo {
-    /// The available balance (encrypted by `encrypiton_pubkey`)
-    pub available_balance: EncryptedBalance,
-    /// The decryptable available balance
-    pub decryptable_available_balance: DecryptableBalance,
-}
-impl WithdrawAccountInfo {
-    /// Create the `ApplyPendingBalance` instruction account information from
-    /// `ConfidentialTransferAccount`.
-    pub fn new(account: &ConfidentialTransferAccount) -> Self {
-        Self {
-            available_balance: account.available_balance,
-            decryptable_available_balance: account.decryptable_available_balance,
-        }
-    }
-
-    fn decrypted_available_balance(&self, aes_key: &AeKey) -> Result<u64, TokenError> {
-        let decryptable_available_balance = self
-            .decryptable_available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        aes_key
-            .decrypt(&decryptable_available_balance)
-            .ok_or(TokenError::AccountDecryption)
-    }
-
-    /// Create a withdraw proof data.
-    pub fn generate_proof_data(
-        &self,
-        withdraw_amount: u64,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-    ) -> Result<WithdrawData, TokenError> {
-        let current_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_decrypted_available_balance = self.decrypted_available_balance(aes_key)?;
-
-        WithdrawData::new(
-            withdraw_amount,
-            elgamal_keypair,
-            current_decrypted_available_balance,
-            &current_available_balance,
-        )
-        .map_err(|_| TokenError::ProofGeneration)
-    }
-
-    /// Update the decryptable available balance.
-    pub fn new_decryptable_available_balance(
-        &self,
-        withdraw_amount: u64,
-        aes_key: &AeKey,
-    ) -> Result<AeCiphertext, TokenError> {
-        let current_decrypted_available_balance = self.decrypted_available_balance(aes_key)?;
-        let new_decrypted_available_balance = current_decrypted_available_balance
-            .checked_sub(withdraw_amount)
-            .ok_or(TokenError::InsufficientFunds)?;
-
-        Ok(aes_key.encrypt(new_decrypted_available_balance))
-    }
-}
-
-/// Confidential Transfer extension information needed to construct a `Transfer`
-/// instruction.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct TransferAccountInfo {
-    /// The available balance (encrypted by `encrypiton_pubkey`)
-    pub available_balance: EncryptedBalance,
-    /// The decryptable available balance
-    pub decryptable_available_balance: DecryptableBalance,
-}
-impl TransferAccountInfo {
-    /// Create the `Transfer` instruction account information from
-    /// `ConfidentialTransferAccount`.
-    pub fn new(account: &ConfidentialTransferAccount) -> Self {
-        Self {
-            available_balance: account.available_balance,
-            decryptable_available_balance: account.decryptable_available_balance,
-        }
-    }
-
-    fn decrypted_available_balance(&self, aes_key: &AeKey) -> Result<u64, TokenError> {
-        let decryptable_available_balance = self
-            .decryptable_available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        aes_key
-            .decrypt(&decryptable_available_balance)
-            .ok_or(TokenError::AccountDecryption)
-    }
-
-    /// Create a transfer proof data.
-    pub fn generate_transfer_proof_data(
-        &self,
-        transfer_amount: u64,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-    ) -> Result<TransferData, TokenError> {
-        let current_source_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_source_decrypted_available_balance =
-            self.decrypted_available_balance(aes_key)?;
-
-        let default_auditor_pubkey = ElGamalPubkey::default();
-        let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-        TransferData::new(
-            transfer_amount,
-            (
-                current_source_decrypted_available_balance,
-                &current_source_available_balance,
-            ),
-            elgamal_keypair,
-            (destination_elgamal_pubkey, auditor_elgamal_pubkey),
-        )
-        .map_err(|_| TokenError::ProofGeneration)
-    }
-
-    /// Create a transfer proof data that is split into equality, ciphertext
-    /// validity, and range proofs.
-    pub fn generate_split_transfer_proof_data(
-        &self,
-        transfer_amount: u64,
-        source_elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-    ) -> Result<
-        (
-            CiphertextCommitmentEqualityProofData,
-            BatchedGroupedCiphertext2HandlesValidityProofData,
-            BatchedRangeProofU128Data,
-            SourceDecryptHandles,
-        ),
-        TokenError,
-    > {
-        let current_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_decryptable_available_balance = self
-            .decryptable_available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-
-        transfer_split_proof_data(
-            &current_available_balance,
-            &current_decryptable_available_balance,
-            transfer_amount,
-            source_elgamal_keypair,
-            aes_key,
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-        )
-    }
-
-    /// Create a transfer with fee proof data
-    #[allow(clippy::too_many_arguments)]
-    pub fn generate_transfer_with_fee_proof_data(
-        &self,
-        transfer_amount: u64,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-        fee_rate_basis_points: u16,
-        maximum_fee: u64,
-    ) -> Result<TransferWithFeeData, TokenError> {
-        let current_source_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_source_decrypted_available_balance =
-            self.decrypted_available_balance(aes_key)?;
-
-        let default_auditor_pubkey = ElGamalPubkey::default();
-        let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-        let fee_parameters = FeeParameters {
-            fee_rate_basis_points,
-            maximum_fee,
-        };
-
-        TransferWithFeeData::new(
-            transfer_amount,
-            (
-                current_source_decrypted_available_balance,
-                &current_source_available_balance,
-            ),
-            elgamal_keypair,
-            (destination_elgamal_pubkey, auditor_elgamal_pubkey),
-            fee_parameters,
-            withdraw_withheld_authority_elgamal_pubkey,
-        )
-        .map_err(|_| TokenError::ProofGeneration)
-    }
-
-    /// Update the decryptable available balance.
-    pub fn new_decryptable_available_balance(
-        &self,
-        transfer_amount: u64,
-        aes_key: &AeKey,
-    ) -> Result<AeCiphertext, TokenError> {
-        let current_decrypted_available_balance = self.decrypted_available_balance(aes_key)?;
-        let new_decrypted_available_balance = current_decrypted_available_balance
-            .checked_sub(transfer_amount)
-            .ok_or(TokenError::InsufficientFunds)?;
-
-        Ok(aes_key.encrypt(new_decrypted_available_balance))
-    }
-}
-
-fn combine_balances(balance_lo: u64, balance_hi: u64) -> Option<u64> {
-    balance_hi
-        .checked_shl(PENDING_BALANCE_LO_BIT_LENGTH)?
-        .checked_add(balance_lo)
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/ciphertext_extraction.rs b/token/program-2022/src/extension/confidential_transfer/ciphertext_extraction.rs
deleted file mode 100644
index 85f9fd0b031..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/ciphertext_extraction.rs
+++ /dev/null
@@ -1,685 +0,0 @@
-//! Ciphertext extraction and proof related helper logic
-//!
-//! This submodule should be removed with the next upgrade to the Solana program
-
-use crate::{
-    extension::{
-        confidential_transfer::*, confidential_transfer_fee::EncryptedFee,
-        transfer_fee::TransferFee,
-    },
-    solana_program::program_error::ProgramError,
-    solana_zk_token_sdk::{
-        curve25519::{
-            ristretto::{self, PodRistrettoPoint},
-            scalar::PodScalar,
-        },
-        instruction::{
-            transfer::{TransferProofContext, TransferWithFeeProofContext},
-            BatchedGroupedCiphertext2HandlesValidityProofContext, BatchedRangeProofContext,
-            CiphertextCommitmentEqualityProofContext, FeeSigmaProofContext,
-        },
-        zk_token_elgamal::pod::{
-            DecryptHandle, FeeEncryption, GroupedElGamalCiphertext2Handles,
-            GroupedElGamalCiphertext3Handles, PedersenCommitment, TransferAmountCiphertext,
-        },
-    },
-};
-#[cfg(feature = "serde-traits")]
-use {
-    crate::serialization::decrypthandle_fromstr,
-    serde::{Deserialize, Serialize},
-};
-
-/// Extract the commitment component from a grouped ciphertext with 2 handles.
-///
-/// A grouped ciphertext with 2 handles consists of the following 32-bytes
-/// components that are serialized in order:
-///   1. The `commitment` component that encodes the fee amount.
-///   3. The `decryption handle` component with respect to the destination
-///      public key.
-///   4. The `decryption handle` component with respect to the withdraw withheld
-///      authority public key.
-///
-/// The fee commitment component consists of the first 32-byte.
-pub(crate) fn extract_commitment_from_grouped_ciphertext(
-    transfer_amount_ciphertext: &GroupedElGamalCiphertext2Handles,
-) -> PedersenCommitment {
-    let transfer_amount_ciphertext_bytes = bytemuck::bytes_of(transfer_amount_ciphertext);
-    let transfer_amount_commitment_bytes =
-        transfer_amount_ciphertext_bytes[..32].try_into().unwrap();
-    PedersenCommitment(transfer_amount_commitment_bytes)
-}
-
-/// Extract the transfer amount ciphertext encrypted under the source ElGamal
-/// public key.
-///
-/// A transfer amount ciphertext consists of the following 32-byte components
-/// that are serialized in order:
-///   1. The `commitment` component that encodes the transfer amount.
-///   2. The `decryption handle` component with respect to the source public
-///      key.
-///   3. The `decryption handle` component with respect to the destination
-///      public key.
-///   4. The `decryption handle` component with respect to the auditor public
-///      key.
-///
-/// An ElGamal ciphertext for the source consists of the `commitment` component
-/// and the `decryption handle` component with respect to the source.
-pub fn transfer_amount_source_ciphertext(
-    transfer_amount_ciphertext: &TransferAmountCiphertext,
-) -> ElGamalCiphertext {
-    let transfer_amount_ciphertext_bytes = bytemuck::bytes_of(transfer_amount_ciphertext);
-
-    let mut source_ciphertext_bytes = [0u8; 64];
-    source_ciphertext_bytes[..32].copy_from_slice(&transfer_amount_ciphertext_bytes[..32]);
-    source_ciphertext_bytes[32..].copy_from_slice(&transfer_amount_ciphertext_bytes[32..64]);
-
-    ElGamalCiphertext(source_ciphertext_bytes)
-}
-
-/// Extract the transfer amount ciphertext encrypted under the destination
-/// ElGamal public key.
-///
-/// A transfer amount ciphertext consists of the following 32-byte components
-/// that are serialized in order:
-///   1. The `commitment` component that encodes the transfer amount.
-///   2. The `decryption handle` component with respect to the source public
-///      key.
-///   3. The `decryption handle` component with respect to the destination
-///      public key.
-///   4. The `decryption handle` component with respect to the auditor public
-///      key.
-///
-/// An ElGamal ciphertext for the destination consists of the `commitment`
-/// component and the `decryption handle` component with respect to the
-/// destination public key.
-#[cfg(feature = "zk-ops")]
-pub(crate) fn transfer_amount_destination_ciphertext(
-    transfer_amount_ciphertext: &TransferAmountCiphertext,
-) -> ElGamalCiphertext {
-    let transfer_amount_ciphertext_bytes = bytemuck::bytes_of(transfer_amount_ciphertext);
-
-    let mut destination_ciphertext_bytes = [0u8; 64];
-    destination_ciphertext_bytes[..32].copy_from_slice(&transfer_amount_ciphertext_bytes[..32]);
-    destination_ciphertext_bytes[32..].copy_from_slice(&transfer_amount_ciphertext_bytes[64..96]);
-
-    ElGamalCiphertext(destination_ciphertext_bytes)
-}
-
-/// Extract the fee amount ciphertext encrypted under the destination ElGamal
-/// public key.
-///
-/// A fee encryption amount consists of the following 32-byte components that
-/// are serialized in order:
-///   1. The `commitment` component that encodes the fee amount.
-///   2. The `decryption handle` component with respect to the destination
-///      public key.
-///   3. The `decryption handle` component with respect to the withdraw withheld
-///      authority public key.
-///
-/// An ElGamal ciphertext for the destination consists of the `commitment`
-/// component and the `decryption handle` component with respect to the
-/// destination public key.
-#[cfg(feature = "zk-ops")]
-pub(crate) fn fee_amount_destination_ciphertext(
-    transfer_amount_ciphertext: &EncryptedFee,
-) -> ElGamalCiphertext {
-    let transfer_amount_ciphertext_bytes = bytemuck::bytes_of(transfer_amount_ciphertext);
-
-    let mut source_ciphertext_bytes = [0u8; 64];
-    source_ciphertext_bytes[..32].copy_from_slice(&transfer_amount_ciphertext_bytes[..32]);
-    source_ciphertext_bytes[32..].copy_from_slice(&transfer_amount_ciphertext_bytes[32..64]);
-
-    ElGamalCiphertext(source_ciphertext_bytes)
-}
-
-/// Extract the transfer amount ciphertext encrypted under the withdraw withheld
-/// authority ElGamal public key.
-///
-/// A fee encryption amount consists of the following 32-byte components that
-/// are serialized in order:
-///   1. The `commitment` component that encodes the fee amount.
-///   2. The `decryption handle` component with respect to the destination
-///      public key.
-///   3. The `decryption handle` component with respect to the withdraw withheld
-///      authority public key.
-///
-/// An ElGamal ciphertext for the destination consists of the `commitment`
-/// component and the `decryption handle` component with respect to the withdraw
-/// withheld authority public key.
-#[cfg(feature = "zk-ops")]
-pub(crate) fn fee_amount_withdraw_withheld_authority_ciphertext(
-    transfer_amount_ciphertext: &EncryptedFee,
-) -> ElGamalCiphertext {
-    let transfer_amount_ciphertext_bytes = bytemuck::bytes_of(transfer_amount_ciphertext);
-
-    let mut destination_ciphertext_bytes = [0u8; 64];
-    destination_ciphertext_bytes[..32].copy_from_slice(&transfer_amount_ciphertext_bytes[..32]);
-    destination_ciphertext_bytes[32..].copy_from_slice(&transfer_amount_ciphertext_bytes[64..96]);
-
-    ElGamalCiphertext(destination_ciphertext_bytes)
-}
-
-#[cfg(feature = "zk-ops")]
-pub(crate) fn transfer_amount_encryption_from_decrypt_handle(
-    source_decrypt_handle: &DecryptHandle,
-    grouped_ciphertext: &GroupedElGamalCiphertext2Handles,
-) -> TransferAmountCiphertext {
-    let source_decrypt_handle_bytes = bytemuck::bytes_of(source_decrypt_handle);
-    let grouped_ciphertext_bytes = bytemuck::bytes_of(grouped_ciphertext);
-
-    let mut transfer_amount_ciphertext_bytes = [0u8; 128];
-    transfer_amount_ciphertext_bytes[..32].copy_from_slice(&grouped_ciphertext_bytes[..32]);
-    transfer_amount_ciphertext_bytes[32..64].copy_from_slice(source_decrypt_handle_bytes);
-    transfer_amount_ciphertext_bytes[64..128].copy_from_slice(&grouped_ciphertext_bytes[32..96]);
-
-    TransferAmountCiphertext(GroupedElGamalCiphertext3Handles(
-        transfer_amount_ciphertext_bytes,
-    ))
-}
-
-/// The transfer public keys associated with a transfer.
-#[cfg(feature = "zk-ops")]
-pub struct TransferPubkeysInfo {
-    /// Source ElGamal public key
-    pub source: ElGamalPubkey,
-    /// Destination ElGamal public key
-    pub destination: ElGamalPubkey,
-    /// Auditor ElGamal public key
-    pub auditor: ElGamalPubkey,
-}
-
-/// The proof context information needed to process a [Transfer] instruction.
-#[cfg(feature = "zk-ops")]
-pub struct TransferProofContextInfo {
-    /// Ciphertext containing the low 16 bits of the transafer amount
-    pub ciphertext_lo: TransferAmountCiphertext,
-    /// Ciphertext containing the high 32 bits of the transafer amount
-    pub ciphertext_hi: TransferAmountCiphertext,
-    /// The transfer public keys associated with a transfer
-    pub transfer_pubkeys: TransferPubkeysInfo,
-    /// The new source available balance ciphertext
-    pub new_source_ciphertext: ElGamalCiphertext,
-}
-
-#[cfg(feature = "zk-ops")]
-impl From<TransferProofContext> for TransferProofContextInfo {
-    fn from(context: TransferProofContext) -> Self {
-        let transfer_pubkeys = TransferPubkeysInfo {
-            source: context.transfer_pubkeys.source,
-            destination: context.transfer_pubkeys.destination,
-            auditor: context.transfer_pubkeys.auditor,
-        };
-
-        TransferProofContextInfo {
-            ciphertext_lo: context.ciphertext_lo,
-            ciphertext_hi: context.ciphertext_hi,
-            transfer_pubkeys,
-            new_source_ciphertext: context.new_source_ciphertext,
-        }
-    }
-}
-
-#[cfg(feature = "zk-ops")]
-impl TransferProofContextInfo {
-    /// Create a transfer proof context information needed to process a
-    /// [Transfer] instruction from split proof contexts after verifying
-    /// their consistency.
-    pub fn verify_and_extract(
-        equality_proof_context: &CiphertextCommitmentEqualityProofContext,
-        ciphertext_validity_proof_context: &BatchedGroupedCiphertext2HandlesValidityProofContext,
-        range_proof_context: &BatchedRangeProofContext,
-        source_decrypt_handles: &SourceDecryptHandles,
-    ) -> Result<Self, ProgramError> {
-        // The equality proof context consists of the source ElGamal public key, the new
-        // source available balance ciphertext, and the new source available
-        // commitment. The public key and ciphertext should be returned as parts
-        // of `TransferProofContextInfo` and the commitment should be checked
-        // with range proof for consistency.
-        let CiphertextCommitmentEqualityProofContext {
-            pubkey: source_pubkey,
-            ciphertext: new_source_ciphertext,
-            commitment: new_source_commitment,
-        } = equality_proof_context;
-
-        // The ciphertext validity proof context consists of the destination ElGamal
-        // public key, auditor ElGamal public key, and the transfer amount
-        // ciphertexts. All of these fields should be returned as part of
-        // `TransferProofContextInfo`. In addition, the commitments pertaining
-        // to the transfer amount ciphertexts should be checked with range proof for
-        // consistency.
-        let BatchedGroupedCiphertext2HandlesValidityProofContext {
-            destination_pubkey,
-            auditor_pubkey,
-            grouped_ciphertext_lo: transfer_amount_ciphertext_lo,
-            grouped_ciphertext_hi: transfer_amount_ciphertext_hi,
-        } = ciphertext_validity_proof_context;
-
-        // The range proof context consists of the Pedersen commitments and bit-lengths
-        // for which the range proof is proved. The commitments must consist of
-        // three commitments pertaining to the new source available balance, the
-        // low bits of the transfer amount, and high bits of the transfer
-        // amount. These commitments must be checked for bit lengths `64`, `16`,
-        // and `32`.
-        let BatchedRangeProofContext {
-            commitments: range_proof_commitments,
-            bit_lengths: range_proof_bit_lengths,
-        } = range_proof_context;
-
-        // check that the range proof was created for the correct set of Pedersen
-        // commitments
-        let transfer_amount_commitment_lo =
-            extract_commitment_from_grouped_ciphertext(transfer_amount_ciphertext_lo);
-        let transfer_amount_commitment_hi =
-            extract_commitment_from_grouped_ciphertext(transfer_amount_ciphertext_hi);
-
-        let expected_commitments = [
-            *new_source_commitment,
-            transfer_amount_commitment_lo,
-            transfer_amount_commitment_hi,
-            // the fourth dummy commitment can be any commitment
-        ];
-
-        if !range_proof_commitments
-            .iter()
-            .zip(expected_commitments.iter())
-            .all(|(proof_commitment, expected_commitment)| proof_commitment == expected_commitment)
-        {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        // check that the range proof was created for the correct number of bits
-        const REMAINING_BALANCE_BIT_LENGTH: u8 = 64;
-        const TRANSFER_AMOUNT_LO_BIT_LENGTH: u8 = 16;
-        const TRANSFER_AMOUNT_HI_BIT_LENGTH: u8 = 32;
-        const PADDING_BIT_LENGTH: u8 = 16;
-        let expected_bit_lengths = [
-            REMAINING_BALANCE_BIT_LENGTH,
-            TRANSFER_AMOUNT_LO_BIT_LENGTH,
-            TRANSFER_AMOUNT_HI_BIT_LENGTH,
-            PADDING_BIT_LENGTH,
-        ]
-        .iter();
-
-        if !range_proof_bit_lengths
-            .iter()
-            .zip(expected_bit_lengths)
-            .all(|(proof_len, expected_len)| proof_len == expected_len)
-        {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        let transfer_pubkeys = TransferPubkeysInfo {
-            source: *source_pubkey,
-            destination: *destination_pubkey,
-            auditor: *auditor_pubkey,
-        };
-
-        let transfer_amount_ciphertext_lo = transfer_amount_encryption_from_decrypt_handle(
-            &source_decrypt_handles.lo,
-            transfer_amount_ciphertext_lo,
-        );
-
-        let transfer_amount_ciphertext_hi = transfer_amount_encryption_from_decrypt_handle(
-            &source_decrypt_handles.hi,
-            transfer_amount_ciphertext_hi,
-        );
-
-        Ok(Self {
-            ciphertext_lo: transfer_amount_ciphertext_lo,
-            ciphertext_hi: transfer_amount_ciphertext_hi,
-            transfer_pubkeys,
-            new_source_ciphertext: *new_source_ciphertext,
-        })
-    }
-}
-
-/// The transfer public keys associated with a transfer with fee.
-#[cfg(feature = "zk-ops")]
-pub struct TransferWithFeePubkeysInfo {
-    /// Source ElGamal public key
-    pub source: ElGamalPubkey,
-    /// Destination ElGamal public key
-    pub destination: ElGamalPubkey,
-    /// Auditor ElGamal public key
-    pub auditor: ElGamalPubkey,
-    /// Withdraw withheld authority public key
-    pub withdraw_withheld_authority: ElGamalPubkey,
-}
-
-/// The proof context information needed to process a [Transfer] instruction
-/// with fee.
-#[cfg(feature = "zk-ops")]
-pub struct TransferWithFeeProofContextInfo {
-    /// Group encryption of the low 16 bits of the transfer amount
-    pub ciphertext_lo: TransferAmountCiphertext,
-    /// Group encryption of the high 48 bits of the transfer amount
-    pub ciphertext_hi: TransferAmountCiphertext,
-    /// The public encryption keys associated with the transfer: source, dest,
-    /// auditor, and withdraw withheld authority
-    pub transfer_with_fee_pubkeys: TransferWithFeePubkeysInfo,
-    /// The final spendable ciphertext after the transfer,
-    pub new_source_ciphertext: ElGamalCiphertext,
-    /// The transfer fee encryption of the low 16 bits of the transfer fee
-    /// amount
-    pub fee_ciphertext_lo: EncryptedFee,
-    /// The transfer fee encryption of the hi 32 bits of the transfer fee amount
-    pub fee_ciphertext_hi: EncryptedFee,
-}
-
-#[cfg(feature = "zk-ops")]
-impl From<TransferWithFeeProofContext> for TransferWithFeeProofContextInfo {
-    fn from(context: TransferWithFeeProofContext) -> Self {
-        let transfer_with_fee_pubkeys = TransferWithFeePubkeysInfo {
-            source: context.transfer_with_fee_pubkeys.source,
-            destination: context.transfer_with_fee_pubkeys.destination,
-            auditor: context.transfer_with_fee_pubkeys.auditor,
-            withdraw_withheld_authority: context
-                .transfer_with_fee_pubkeys
-                .withdraw_withheld_authority,
-        };
-
-        TransferWithFeeProofContextInfo {
-            ciphertext_lo: context.ciphertext_lo,
-            ciphertext_hi: context.ciphertext_hi,
-            transfer_with_fee_pubkeys,
-            new_source_ciphertext: context.new_source_ciphertext,
-            fee_ciphertext_lo: context.fee_ciphertext_lo,
-            fee_ciphertext_hi: context.fee_ciphertext_hi,
-        }
-    }
-}
-
-#[cfg(feature = "zk-ops")]
-impl TransferWithFeeProofContextInfo {
-    /// Create a transfer proof context information needed to process a
-    /// [Transfer] instruction from split proof contexts after verifying
-    /// their consistency.
-    pub fn verify_and_extract(
-        equality_proof_context: &CiphertextCommitmentEqualityProofContext,
-        transfer_amount_ciphertext_validity_proof_context: &BatchedGroupedCiphertext2HandlesValidityProofContext,
-        fee_sigma_proof_context: &FeeSigmaProofContext,
-        fee_ciphertext_validity_proof_context: &BatchedGroupedCiphertext2HandlesValidityProofContext,
-        range_proof_context: &BatchedRangeProofContext,
-        source_decrypt_handles: &SourceDecryptHandles,
-        fee_parameters: &TransferFee,
-    ) -> Result<Self, ProgramError> {
-        // The equality proof context consists of the source ElGamal public key, the new
-        // source available balance ciphertext, and the new source available
-        // commitment. The public key and ciphertext should be returned as part
-        // of `TransferWithFeeProofContextInfo` and the commitment should be
-        // checked with range proof for consistency.
-        let CiphertextCommitmentEqualityProofContext {
-            pubkey: source_pubkey,
-            ciphertext: new_source_ciphertext,
-            commitment: new_source_commitment,
-        } = equality_proof_context;
-
-        // The transfer amount ciphertext validity proof context consists of the
-        // destination ElGamal public key, auditor ElGamal public key, and the
-        // transfer amount ciphertexts. All of these fields should be returned
-        // as part of `TransferWithFeeProofContextInfo`. In addition, the
-        // commitments pertaining to the transfer amount ciphertexts should be
-        // checked with range proof for consistency.
-        let BatchedGroupedCiphertext2HandlesValidityProofContext {
-            destination_pubkey,
-            auditor_pubkey,
-            grouped_ciphertext_lo: transfer_amount_ciphertext_lo,
-            grouped_ciphertext_hi: transfer_amount_ciphertext_hi,
-        } = transfer_amount_ciphertext_validity_proof_context;
-
-        // The fee sigma proof context consists of the fee commitment, delta commitment,
-        // claimed commitment, and max fee. The fee and claimed commitment
-        // should be checked with range proof for consistency. The delta
-        // commitment should be checked whether it is properly generated with
-        // respect to the fee parameters. The max fee should be checked for
-        // consistency with the fee parameters.
-        let FeeSigmaProofContext {
-            fee_commitment,
-            delta_commitment,
-            claimed_commitment,
-            max_fee,
-        } = fee_sigma_proof_context;
-
-        let expected_maximum_fee: u64 = fee_parameters.maximum_fee.into();
-        let proof_maximum_fee: u64 = (*max_fee).into();
-        if expected_maximum_fee != proof_maximum_fee {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        // The transfer fee ciphertext validity proof context consists of the
-        // destination ElGamal public key, withdraw withheld authority ElGamal
-        // public key, and the transfer fee ciphertexts. The rest of the fields
-        // should be return as part of `TransferWithFeeProofContextInfo`. In
-        // addition, the destination public key should be checked for
-        // consistency with the destination public key contained in the transfer amount
-        // ciphertext validity proof, and the commitments pertaining to the transfer fee
-        // amount ciphertexts should be checked with range proof for
-        // consistency.
-        let BatchedGroupedCiphertext2HandlesValidityProofContext {
-            destination_pubkey: destination_pubkey_from_transfer_fee_validity_proof,
-            auditor_pubkey: withdraw_withheld_authority_pubkey,
-            grouped_ciphertext_lo: fee_ciphertext_lo,
-            grouped_ciphertext_hi: fee_ciphertext_hi,
-        } = fee_ciphertext_validity_proof_context;
-
-        if destination_pubkey != destination_pubkey_from_transfer_fee_validity_proof {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        // The range proof context consists of the Pedersen commitments and bit-lengths
-        // for which the range proof is proved. The commitments must consist of
-        // seven commitments pertaining to
-        // - the new source available balance (64 bits)
-        // - the low bits of the transfer amount (16 bits)
-        // - the high bits of the transfer amount (32 bits)
-        // - the delta amount for the fee (48 bits)
-        // - the complement of the delta amount for the fee (48 bits)
-        // - the low bits of the fee amount (16 bits)
-        // - the high bits of the fee amount (32 bits)
-        let BatchedRangeProofContext {
-            commitments: range_proof_commitments,
-            bit_lengths: range_proof_bit_lengths,
-        } = range_proof_context;
-
-        // check that the range proof was created for the correct set of Pedersen
-        // commitments
-        let transfer_amount_commitment_lo =
-            extract_commitment_from_grouped_ciphertext(transfer_amount_ciphertext_lo);
-        let transfer_amount_commitment_hi =
-            extract_commitment_from_grouped_ciphertext(transfer_amount_ciphertext_hi);
-
-        let fee_commitment_lo = extract_commitment_from_grouped_ciphertext(fee_ciphertext_lo);
-        let fee_commitment_hi = extract_commitment_from_grouped_ciphertext(fee_ciphertext_hi);
-
-        const MAX_FEE_BASIS_POINTS: u64 = 10_000;
-        let max_fee_basis_points_scalar = u64_to_scalar(MAX_FEE_BASIS_POINTS);
-        let max_fee_basis_points_commitment =
-            ristretto::multiply_ristretto(&max_fee_basis_points_scalar, &G)
-                .ok_or(TokenError::CiphertextArithmeticFailed)?;
-        let claimed_complement_commitment = ristretto::subtract_ristretto(
-            &max_fee_basis_points_commitment,
-            &(*claimed_commitment).into(),
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        let expected_commitments = [
-            *new_source_commitment,
-            transfer_amount_commitment_lo,
-            transfer_amount_commitment_hi,
-            *claimed_commitment,
-            claimed_complement_commitment.into(),
-            fee_commitment_lo,
-            fee_commitment_hi,
-        ];
-
-        if !range_proof_commitments
-            .iter()
-            .zip(expected_commitments.iter())
-            .all(|(proof_commitment, expected_commitment)| proof_commitment == expected_commitment)
-        {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        // check that the range proof was created for the correct number of bits
-        const REMAINING_BALANCE_BIT_LENGTH: u8 = 64;
-        const TRANSFER_AMOUNT_LO_BIT_LENGTH: u8 = 16;
-        const TRANSFER_AMOUNT_HI_BIT_LENGTH: u8 = 32;
-        const DELTA_BIT_LENGTH: u8 = 48;
-        const FEE_AMOUNT_LO_BIT_LENGTH: u8 = 16;
-        const FEE_AMOUNT_HI_BIT_LENGTH: u8 = 32;
-
-        let expected_bit_lengths = [
-            REMAINING_BALANCE_BIT_LENGTH,
-            TRANSFER_AMOUNT_LO_BIT_LENGTH,
-            TRANSFER_AMOUNT_HI_BIT_LENGTH,
-            DELTA_BIT_LENGTH,
-            DELTA_BIT_LENGTH,
-            FEE_AMOUNT_LO_BIT_LENGTH,
-            FEE_AMOUNT_HI_BIT_LENGTH,
-        ]
-        .iter();
-
-        if !range_proof_bit_lengths
-            .iter()
-            .zip(expected_bit_lengths)
-            .all(|(proof_len, expected_len)| proof_len == expected_len)
-        {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        // check consistency between fee sigma and fee ciphertext validity proofs
-        let sigma_proof_fee_commitment_point: PodRistrettoPoint = (*fee_commitment).into();
-        let validity_proof_fee_point =
-            combine_lo_hi_pedersen_points(&fee_commitment_lo.into(), &fee_commitment_hi.into())
-                .ok_or(TokenError::CiphertextArithmeticFailed)?;
-        if validity_proof_fee_point != sigma_proof_fee_commitment_point {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        verify_delta_commitment(
-            &transfer_amount_commitment_lo,
-            &transfer_amount_commitment_hi,
-            fee_commitment,
-            delta_commitment,
-            fee_parameters.transfer_fee_basis_points.into(),
-        )?;
-
-        // create transfer with fee proof context info and return
-        let transfer_with_fee_pubkeys = TransferWithFeePubkeysInfo {
-            source: *source_pubkey,
-            destination: *destination_pubkey,
-            auditor: *auditor_pubkey,
-            withdraw_withheld_authority: *withdraw_withheld_authority_pubkey,
-        };
-
-        let transfer_amount_ciphertext_lo = transfer_amount_encryption_from_decrypt_handle(
-            &source_decrypt_handles.lo,
-            transfer_amount_ciphertext_lo,
-        );
-
-        let transfer_amount_ciphertext_hi = transfer_amount_encryption_from_decrypt_handle(
-            &source_decrypt_handles.hi,
-            transfer_amount_ciphertext_hi,
-        );
-
-        Ok(Self {
-            ciphertext_lo: transfer_amount_ciphertext_lo,
-            ciphertext_hi: transfer_amount_ciphertext_hi,
-            transfer_with_fee_pubkeys,
-            new_source_ciphertext: *new_source_ciphertext,
-            fee_ciphertext_lo: FeeEncryption(*fee_ciphertext_lo),
-            fee_ciphertext_hi: FeeEncryption(*fee_ciphertext_hi),
-        })
-    }
-}
-
-/// The ElGamal ciphertext decryption handle pertaining to the low and high bits
-/// of the transfer amount under the source public key of the transfer.
-///
-/// The `TransferProofContext` contains decryption handles for the low and high
-/// bits of the transfer amount. However, these decryption handles were
-/// (mistakenly) removed from the split proof contexts as a form of
-/// optimization. These components should be added back into these split proofs
-/// in `zk-token-sdk`. Until this modifications is made, include
-/// `SourceDecryptHandle` in the transfer instruction data.
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct SourceDecryptHandles {
-    /// The ElGamal decryption handle pertaining to the low 16 bits of the
-    /// transfer amount.
-    #[cfg_attr(feature = "serde-traits", serde(with = "decrypthandle_fromstr"))]
-    pub lo: DecryptHandle,
-    /// The ElGamal decryption handle pertaining to the low 32 bits of the
-    /// transfer amount.
-    #[cfg_attr(feature = "serde-traits", serde(with = "decrypthandle_fromstr"))]
-    pub hi: DecryptHandle,
-}
-
-/// Ristretto generator point for curve25519
-const G: PodRistrettoPoint = PodRistrettoPoint([
-    226, 242, 174, 10, 106, 188, 78, 113, 168, 132, 169, 97, 197, 0, 81, 95, 88, 227, 11, 106, 165,
-    130, 221, 141, 182, 166, 89, 69, 224, 141, 45, 118,
-]);
-
-/// Convert a `u16` amount into a curve25519 scalar
-fn u16_to_scalar(amount: u16) -> PodScalar {
-    let mut bytes = [0u8; 32];
-    bytes[..2].copy_from_slice(&amount.to_le_bytes());
-    PodScalar(bytes)
-}
-
-/// Convert a `u64` amount into a curve25519 scalar
-fn u64_to_scalar(amount: u64) -> PodScalar {
-    let mut bytes = [0u8; 32];
-    bytes[..8].copy_from_slice(&amount.to_le_bytes());
-    PodScalar(bytes)
-}
-
-/// Combine lo and hi Pedersen commitment points
-fn combine_lo_hi_pedersen_points(
-    point_lo: &PodRistrettoPoint,
-    point_hi: &PodRistrettoPoint,
-) -> Option<PodRistrettoPoint> {
-    const SCALING_CONSTANT: u64 = 65536;
-    let scaling_constant_scalar = u64_to_scalar(SCALING_CONSTANT);
-    let scaled_point_hi = ristretto::multiply_ristretto(&scaling_constant_scalar, point_hi)?;
-    ristretto::add_ristretto(point_lo, &scaled_point_hi)
-}
-
-/// Compute fee delta commitment
-fn verify_delta_commitment(
-    transfer_amount_commitment_lo: &PedersenCommitment,
-    transfer_amount_commitment_hi: &PedersenCommitment,
-    fee_commitment: &PedersenCommitment,
-    proof_delta_commitment: &PedersenCommitment,
-    transfer_fee_basis_points: u16,
-) -> Result<(), ProgramError> {
-    let transfer_amount_point = combine_lo_hi_pedersen_points(
-        &(*transfer_amount_commitment_lo).into(),
-        &(*transfer_amount_commitment_hi).into(),
-    )
-    .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    let transfer_fee_basis_points_scalar = u16_to_scalar(transfer_fee_basis_points);
-    let scaled_transfer_amount_point =
-        ristretto::multiply_ristretto(&transfer_fee_basis_points_scalar, &transfer_amount_point)
-            .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-    const MAX_FEE_BASIS_POINTS: u64 = 10_000;
-    let max_fee_basis_points_scalar = u64_to_scalar(MAX_FEE_BASIS_POINTS);
-    let fee_point: PodRistrettoPoint = (*fee_commitment).into();
-    let scaled_fee_point = ristretto::multiply_ristretto(&max_fee_basis_points_scalar, &fee_point)
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-    let expected_delta_commitment_point =
-        ristretto::subtract_ristretto(&scaled_fee_point, &scaled_transfer_amount_point)
-            .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-    let proof_delta_commitment_point = (*proof_delta_commitment).into();
-    if expected_delta_commitment_point != proof_delta_commitment_point {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    Ok(())
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/instruction.rs b/token/program-2022/src/extension/confidential_transfer/instruction.rs
deleted file mode 100644
index ac73574f5a9..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/instruction.rs
+++ /dev/null
@@ -1,1518 +0,0 @@
-#[cfg(not(target_os = "solana"))]
-use solana_zk_token_sdk::encryption::auth_encryption::AeCiphertext;
-pub use solana_zk_token_sdk::{
-    zk_token_proof_instruction::*, zk_token_proof_state::ProofContextState,
-};
-#[cfg(feature = "serde-traits")]
-use {
-    crate::serialization::aeciphertext_fromstr,
-    serde::{Deserialize, Serialize},
-};
-use {
-    crate::{
-        check_program_account,
-        extension::confidential_transfer::{ciphertext_extraction::SourceDecryptHandles, *},
-        instruction::{encode_instruction, TokenInstruction},
-        proof::ProofLocation,
-    },
-    bytemuck::Zeroable, // `Pod` comes from zk_token_proof_instruction
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        sysvar,
-    },
-};
-
-/// Confidential Transfer extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
-#[repr(u8)]
-pub enum ConfidentialTransferInstruction {
-    /// Initializes confidential transfers for a mint.
-    ///
-    /// The `ConfidentialTransferInstruction::InitializeMint` instruction
-    /// requires no signers and MUST be included within the same Transaction
-    /// as `TokenInstruction::InitializeMint`. Otherwise another party can
-    /// initialize the configuration.
-    ///
-    /// The instruction fails if the `TokenInstruction::InitializeMint`
-    /// instruction has already executed for the mint.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The SPL Token mint.
-    ///
-    /// Data expected by this instruction:
-    ///   `InitializeMintData`
-    InitializeMint,
-
-    /// Updates the confidential transfer mint configuration for a mint.
-    ///
-    /// Use `TokenInstruction::SetAuthority` to update the confidential transfer
-    /// mint authority.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The SPL Token mint.
-    ///   1. `[signer]` Confidential transfer mint authority.
-    ///
-    /// Data expected by this instruction:
-    ///   `UpdateMintData`
-    UpdateMint,
-
-    /// Configures confidential transfers for a token account.
-    ///
-    /// The instruction fails if the confidential transfers are already
-    /// configured, or if the mint was not initialized with confidential
-    /// transfer support.
-    ///
-    /// The instruction fails if the `TokenInstruction::InitializeAccount`
-    /// instruction has not yet successfully executed for the token account.
-    ///
-    /// Upon success, confidential and non-confidential deposits and transfers
-    /// are enabled. Use the `DisableConfidentialCredits` and
-    /// `DisableNonConfidentialCredits` instructions to disable.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by the `VerifyPubkeyValidityProof` instruction of the
-    /// `zk_token_proof` program in the same transaction or the address of a
-    /// context state account for the proof must be provided.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writeable]` The SPL Token account.
-    ///   1. `[]` The corresponding SPL Token mint.
-    ///   2. `[]` Instructions sysvar if `VerifyPubkeyValidityProof` is included
-    ///      in the same transaction or context state account if
-    ///      `VerifyPubkeyValidityProof` is pre-verified into a context state
-    ///      account.
-    ///   3. `[signer]` The single source account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writeable]` The SPL Token account.
-    ///   1. `[]` The corresponding SPL Token mint.
-    ///   2. `[]` Instructions sysvar if `VerifyPubkeyValidityProof` is included
-    ///      in the same transaction or context state account if
-    ///      `VerifyPubkeyValidityProof` is pre-verified into a context state
-    ///      account.
-    ///   3. `[]` The multisig source account owner.
-    ///   4.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `ConfigureAccountInstructionData`
-    ConfigureAccount,
-
-    /// Approves a token account for confidential transfers.
-    ///
-    /// Approval is only required when the
-    /// `ConfidentialTransferMint::approve_new_accounts` field is set in the
-    /// SPL Token mint.  This instruction must be executed after the account
-    /// owner configures their account for confidential transfers with
-    /// `ConfidentialTransferInstruction::ConfigureAccount`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The SPL Token account to approve.
-    ///   1. `[]` The SPL Token mint.
-    ///   2. `[signer]` Confidential transfer mint authority.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    ApproveAccount,
-
-    /// Empty the available balance in a confidential token account.
-    ///
-    /// A token account that is extended for confidential transfers can only be
-    /// closed if the pending and available balance ciphertexts are emptied.
-    /// The pending balance can be emptied
-    /// via the `ConfidentialTransferInstruction::ApplyPendingBalance`
-    /// instruction. Use the `ConfidentialTransferInstruction::EmptyAccount`
-    /// instruction to empty the available balance ciphertext.
-    ///
-    /// Note that a newly configured account is always empty, so this
-    /// instruction is not required prior to account closing if no
-    /// instructions beyond
-    /// `ConfidentialTransferInstruction::ConfigureAccount` have affected the
-    /// token account.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by the `VerifyZeroBalanceProof` instruction of the
-    /// `zk_token_proof` program in the same transaction or the address of a
-    /// context state account for the proof must be provided.
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` Instructions sysvar if `VerifyZeroBalanceProof` is included in
-    ///      the same transaction or context state account if
-    ///      `VerifyZeroBalanceProof` is pre-verified into a context state
-    ///      account.
-    ///   2. `[signer]` The single account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` Instructions sysvar if `VerifyZeroBalanceProof` is included in
-    ///      the same transaction or context state account if
-    ///      `VerifyZeroBalanceProof` is pre-verified into a context state
-    ///      account.
-    ///   2. `[]` The multisig account owner.
-    ///   3.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `EmptyAccountInstructionData`
-    EmptyAccount,
-
-    /// Deposit SPL Tokens into the pending balance of a confidential token
-    /// account.
-    ///
-    /// The account owner can then invoke the `ApplyPendingBalance` instruction
-    /// to roll the deposit into their available balance at a time of their
-    /// choosing.
-    ///
-    /// Fails if the source or destination accounts are frozen.
-    /// Fails if the associated mint is extended as `NonTransferable`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The token mint.
-    ///   2. `[signer]` The single account owner or delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The multisig account owner or delegate.
-    ///   3.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `DepositInstructionData`
-    Deposit,
-
-    /// Withdraw SPL Tokens from the available balance of a confidential token
-    /// account.
-    ///
-    /// Fails if the source or destination accounts are frozen.
-    /// Fails if the associated mint is extended as `NonTransferable`.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by the `VerifyWithdraw` instruction of the
-    /// `zk_token_proof` program in the same transaction or the address of a
-    /// context state account for the proof must be provided.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` Instructions sysvar if `VerifyWithdraw` is included in the
-    ///      same transaction or context state account if `VerifyWithdraw` is
-    ///      pre-verified into a context state account.
-    ///   3. `[signer]` The single source account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` Instructions sysvar if `VerifyWithdraw` is included in the
-    ///      same transaction or context state account if `VerifyWithdraw` is
-    ///      pre-verified into a context state account.
-    ///   3. `[]` The multisig  source account owner.
-    ///   4.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `WithdrawInstructionData`
-    Withdraw,
-
-    /// Transfer tokens confidentially.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by either the `VerifyTransfer` or
-    /// `VerifyTransferWithFee` instruction of the `zk_token_proof`
-    /// program in the same transaction or the address of a context state
-    /// account for the proof must be provided.
-    ///
-    /// Fails if the associated mint is extended as `NonTransferable`.
-    ///
-    ///   * Single owner/delegate
-    ///   1. `[writable]` The source SPL Token account.
-    ///   2. `[]` The token mint.
-    ///   3. `[writable]` The destination SPL Token account.
-    ///   4. `[]` Instructions sysvar if `VerifyTransfer` or
-    ///      `VerifyTransferWithFee` is included in the same transaction or
-    ///      context state account if these proofs are pre-verified into a
-    ///      context state account.
-    ///   5. `[signer]` The single source account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   1. `[writable]` The source SPL Token account.
-    ///   2. `[]` The token mint.
-    ///   3. `[writable]` The destination SPL Token account.
-    ///   4. `[]` Instructions sysvar if `VerifyTransfer` or
-    ///      `VerifyTransferWithFee` is included in the same transaction or
-    ///      context state account if these proofs are pre-verified into a
-    ///      context state account.
-    ///   5. `[]` The multisig  source account owner.
-    ///   6.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `TransferInstructionData`
-    Transfer,
-
-    /// Applies the pending balance to the available balance, based on the
-    /// history of `Deposit` and/or `Transfer` instructions.
-    ///
-    /// After submitting `ApplyPendingBalance`, the client should compare
-    /// `ConfidentialTransferAccount::expected_pending_balance_credit_counter`
-    /// with
-    /// `ConfidentialTransferAccount::actual_applied_pending_balance_instructions`.  If they are
-    /// equal then the
-    /// `ConfidentialTransferAccount::decryptable_available_balance` is
-    /// consistent with `ConfidentialTransferAccount::available_balance`. If
-    /// they differ then there is more pending balance to be applied.
-    ///
-    /// Account expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[signer]` The single account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The multisig account owner.
-    ///   2.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   `ApplyPendingBalanceData`
-    ApplyPendingBalance,
-
-    /// Configure a confidential extension account to accept incoming
-    /// confidential transfers.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[signer]` Single authority.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` Multisig authority.
-    ///   2.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    EnableConfidentialCredits,
-
-    /// Configure a confidential extension account to reject any incoming
-    /// confidential transfers.
-    ///
-    /// If the `allow_non_confidential_credits` field is `true`, then the base
-    /// account can still receive non-confidential transfers.
-    ///
-    /// This instruction can be used to disable confidential payments after a
-    /// token account has already been extended for confidential transfers.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[signer]` The single account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The multisig account owner.
-    ///   2.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    DisableConfidentialCredits,
-
-    /// Configure an account with the confidential extension to accept incoming
-    /// non-confidential transfers.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[signer]` The single account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The multisig account owner.
-    ///   2.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    EnableNonConfidentialCredits,
-
-    /// Configure an account with the confidential extension to reject any
-    /// incoming non-confidential transfers.
-    ///
-    /// This instruction can be used to configure a confidential extension
-    /// account to exclusively receive confidential payments.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[signer]` The single account owner.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The SPL Token account.
-    ///   1. `[]` The multisig account owner.
-    ///   2.. `[signer]` Required M signer accounts for the SPL Token Multisig
-    /// account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    DisableNonConfidentialCredits,
-
-    /// Transfer tokens confidentially with zero-knowledge proofs that are split
-    /// into smaller components.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by suitable zero-knowledge proof context accounts listed
-    /// below.
-    ///
-    /// The same restrictions for the `Transfer` applies to
-    /// `TransferWithSplitProofs`. Namely, the instruction fails if the
-    /// associated mint is extended as `NonTransferable`.
-    ///
-    ///   * Transfer without fee
-    ///   1. `[writable]` The source SPL Token account.
-    ///   2. `[]` The token mint.
-    ///   3. `[writable]` The destination SPL Token account.
-    ///   4. `[]` Context state account for
-    ///      `VerifyCiphertextCommitmentEqualityProof`.
-    ///   5. `[]` Context state account for
-    ///      `VerifyBatchedGroupedCiphertext2HandlesValidityProof`.
-    ///   6. `[]` Context state account for `VerifyBatchedRangeProofU128`.
-    ///   If `close_split_context_state_on_execution` is set, all context state
-    ///     accounts must be `writable` and the following sequence
-    ///     of accounts that are marked with asterisk are needed:
-    ///   7*. `[]` The destination account for lamports from the context state
-    ///      accounts.
-    ///   8*. `[signer]` The context state account owner.
-    ///   9*. `[]` The zk token proof program.
-    ///   10. `[signer]` The source account owner.
-    ///
-    ///   * Transfer with fee
-    ///   1. `[writable]` The source SPL Token account.
-    ///   2. `[]` The token mint.
-    ///   3. `[writable]` The destination SPL Token account.
-    ///   4. `[]` Context state account for
-    ///      `VerifyCiphertextCommitmentEqualityProof`.
-    ///   5. `[]` Context state account for
-    ///      `VerifyBatchedGroupedCiphertext2HandlesValidityProof`.
-    ///   6. `[]` Context state account for `VerifyFeeSigmaProof`.
-    ///   7. `[]` Context state account for
-    ///      `VerifyBatchedGroupedCiphertext2HandlesValidityProof`.
-    ///   8. `[]` Context state account for `VerifyBatchedRangeProofU256`.
-    ///   If `close_split_context_state_on_execution` is set, all context state
-    ///     accounts must be  `writable` and the following sequence
-    ///     of accounts that are marked with asterisk are needed:
-    ///   9*. `[]` The destination account for lamports from the context state
-    ///       accounts.
-    ///   10*. `[signer]` The context state account owner.
-    ///   11*. `[]` The zk token proof program.
-    ///   12. `[signer]` The source account owner.
-    ///
-    /// Data expected by this instruction:
-    ///   `TransferWithSplitProofsInstructionData`
-    TransferWithSplitProofs,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::InitializeMint`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeMintData {
-    /// Authority to modify the `ConfidentialTransferMint` configuration and to
-    /// approve new accounts.
-    pub authority: OptionalNonZeroPubkey,
-    /// Determines if newly configured accounts must be approved by the
-    /// `authority` before they may be used by the user.
-    pub auto_approve_new_accounts: PodBool,
-    /// New authority to decode any transfer amount in a confidential transfer.
-    pub auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::UpdateMint`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct UpdateMintData {
-    /// Determines if newly configured accounts must be approved by the
-    /// `authority` before they may be used by the user.
-    pub auto_approve_new_accounts: PodBool,
-    /// New authority to decode any transfer amount in a confidential transfer.
-    pub auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::ConfigureAccount`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct ConfigureAccountInstructionData {
-    /// The decryptable balance (always 0) once the configure account succeeds
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub decryptable_zero_balance: DecryptableBalance,
-    /// The maximum number of despots and transfers that an account can receiver
-    /// before the `ApplyPendingBalance` is executed
-    pub maximum_pending_balance_credit_counter: PodU64,
-    /// Relative location of the `ProofInstruction::ZeroBalanceProof`
-    /// instruction to the `ConfigureAccount` instruction in the
-    /// transaction. If the offset is `0`, then use a context state account
-    /// for the proof.
-    pub proof_instruction_offset: i8,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::EmptyAccount`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct EmptyAccountInstructionData {
-    /// Relative location of the `ProofInstruction::VerifyCloseAccount`
-    /// instruction to the `EmptyAccount` instruction in the transaction. If
-    /// the offset is `0`, then use a context state account for the proof.
-    pub proof_instruction_offset: i8,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::Deposit`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct DepositInstructionData {
-    /// The amount of tokens to deposit
-    pub amount: PodU64,
-    /// Expected number of base 10 digits to the right of the decimal place
-    pub decimals: u8,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::Withdraw`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct WithdrawInstructionData {
-    /// The amount of tokens to withdraw
-    pub amount: PodU64,
-    /// Expected number of base 10 digits to the right of the decimal place
-    pub decimals: u8,
-    /// The new decryptable balance if the withdrawal succeeds
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_decryptable_available_balance: DecryptableBalance,
-    /// Relative location of the `ProofInstruction::VerifyWithdraw` instruction
-    /// to the `Withdraw` instruction in the transaction. If the offset is
-    /// `0`, then use a context state account for the proof.
-    pub proof_instruction_offset: i8,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::Transfer`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct TransferInstructionData {
-    /// The new source decryptable balance if the transfer succeeds
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_source_decryptable_available_balance: DecryptableBalance,
-    /// Relative location of the `ProofInstruction::VerifyTransfer` instruction
-    /// to the `Transfer` instruction in the transaction. If the offset is
-    /// `0`, then use a context state account for the proof.
-    pub proof_instruction_offset: i8,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::ApplyPendingBalance`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct ApplyPendingBalanceData {
-    /// The expected number of pending balance credits since the last successful
-    /// `ApplyPendingBalance` instruction
-    pub expected_pending_balance_credit_counter: PodU64,
-    /// The new decryptable balance if the pending balance is applied
-    /// successfully
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_decryptable_available_balance: DecryptableBalance,
-}
-
-/// Data expected by `ConfidentialTransferInstruction::TransferWithSplitProofs`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct TransferWithSplitProofsInstructionData {
-    /// The new source decryptable balance if the transfer succeeds
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_source_decryptable_available_balance: DecryptableBalance,
-    /// If true, execute no op when an associated context state account is not
-    /// initialized. Otherwise, fail on an uninitialized context state
-    /// account.
-    pub no_op_on_uninitialized_split_context_state: PodBool,
-    /// Close associated context states after a complete execution of the
-    /// transfer instruction.
-    pub close_split_context_state_on_execution: PodBool,
-    /// The ElGamal decryption handle pertaining to the low and high bits of the
-    /// transfer amount. This field is used when the transfer proofs are
-    /// split and verified as smaller components.
-    ///
-    /// NOTE: This field is to be removed in the next Solana upgrade.
-    pub source_decrypt_handles: SourceDecryptHandles,
-}
-
-/// Type for split transfer (without fee) instruction proof context state
-/// account addresses intended to be used as parameters to functions.
-#[derive(Clone, Copy)]
-pub struct TransferSplitContextStateAccounts<'a> {
-    /// The context state account address for an equality proof needed for a
-    /// transfer.
-    pub equality_proof: &'a Pubkey,
-    /// The context state account address for a ciphertext validity proof needed
-    /// for a transfer.
-    pub ciphertext_validity_proof: &'a Pubkey,
-    /// The context state account address for a range proof needed for a
-    /// transfer.
-    pub range_proof: &'a Pubkey,
-    /// The context state accounts authority
-    pub authority: &'a Pubkey,
-    /// No op if an associated split proof context state account is not
-    /// initialized.
-    pub no_op_on_uninitialized_split_context_state: bool,
-    /// Accounts needed if `close_split_context_state_on_execution` flag is
-    /// enabled.
-    pub close_split_context_state_accounts: Option<CloseSplitContextStateAccounts<'a>>,
-}
-
-/// Type for split transfer (with fee) instruction proof context state account
-/// addresses intended to be used as parameters to functions.
-#[derive(Clone, Copy)]
-pub struct TransferWithFeeSplitContextStateAccounts<'a> {
-    /// The context state account address for an equality proof needed for a
-    /// transfer with fee.
-    pub equality_proof: &'a Pubkey,
-    /// The context state account address for a transfer amount ciphertext
-    /// validity proof needed for a transfer with fee.
-    pub transfer_amount_ciphertext_validity_proof: &'a Pubkey,
-    /// The context state account address for a fee sigma proof needed for a
-    /// transfer with fee.
-    pub fee_sigma_proof: &'a Pubkey,
-    /// The context state account address for a fee ciphertext validity proof
-    /// needed for a transfer with fee.
-    pub fee_ciphertext_validity_proof: &'a Pubkey,
-    /// The context state account address for a range proof needed for a
-    /// transfer with fee.
-    pub range_proof: &'a Pubkey,
-    /// The context state accounts authority
-    pub authority: &'a Pubkey,
-    /// No op if an associated split proof context state account is not
-    /// initialized.
-    pub no_op_on_uninitialized_split_context_state: bool,
-    /// Accounts needed if `close_split_context_state_on_execution` flag is
-    /// enabled.
-    pub close_split_context_state_accounts: Option<CloseSplitContextStateAccounts<'a>>,
-}
-
-/// Accounts needed if `close_split_context_state_on_execution` flag is enabled
-/// on a transfer.
-#[derive(Clone, Copy)]
-pub struct CloseSplitContextStateAccounts<'a> {
-    /// The lamport destination account.
-    pub lamport_destination: &'a Pubkey,
-    /// The ZK Token proof program.
-    pub zk_token_proof_program: &'a Pubkey,
-}
-
-/// Create a `InitializeMint` instruction
-pub fn initialize_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    auto_approve_new_accounts: bool,
-    auditor_elgamal_pubkey: Option<ElGamalPubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::InitializeMint,
-        &InitializeMintData {
-            authority: authority.try_into()?,
-            auto_approve_new_accounts: auto_approve_new_accounts.into(),
-            auditor_elgamal_pubkey: auditor_elgamal_pubkey.try_into()?,
-        },
-    ))
-}
-
-/// Create a `UpdateMint` instruction
-pub fn update_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    auto_approve_new_accounts: bool,
-    auditor_elgamal_pubkey: Option<ElGamalPubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::UpdateMint,
-        &UpdateMintData {
-            auto_approve_new_accounts: auto_approve_new_accounts.into(),
-            auditor_elgamal_pubkey: auditor_elgamal_pubkey.try_into()?,
-        },
-    ))
-}
-
-/// Create a `ConfigureAccount` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-#[allow(clippy::too_many_arguments)]
-pub fn inner_configure_account(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    mint: &Pubkey,
-    decryptable_zero_balance: AeCiphertext,
-    maximum_pending_balance_credit_counter: u64,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<PubkeyValidityData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    let mut accounts = vec![
-        AccountMeta::new(*token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::ConfigureAccount,
-        &ConfigureAccountInstructionData {
-            decryptable_zero_balance: decryptable_zero_balance.into(),
-            maximum_pending_balance_credit_counter: maximum_pending_balance_credit_counter.into(),
-            proof_instruction_offset,
-        },
-    ))
-}
-
-/// Create a `ConfigureAccount` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn configure_account(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    mint: &Pubkey,
-    decryptable_zero_balance: AeCiphertext,
-    maximum_pending_balance_credit_counter: u64,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<PubkeyValidityData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_configure_account(
-        token_program_id,
-        token_account,
-        mint,
-        decryptable_zero_balance,
-        maximum_pending_balance_credit_counter,
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the
-        // `ConfigureAccount` instruction. This means that the proof instruction
-        // offset must be always be 1. To use an arbitrary proof instruction
-        // offset, use the `inner_configure_account` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_pubkey_validity(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create an `ApproveAccount` instruction
-pub fn approve_account(
-    token_program_id: &Pubkey,
-    account_to_approve: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*account_to_approve, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::ApproveAccount,
-        &(),
-    ))
-}
-
-/// Create an inner `EmptyAccount` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-pub fn inner_empty_account(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<ZeroBalanceProofData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![AccountMeta::new(*token_account, false)];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::EmptyAccount,
-        &EmptyAccountInstructionData {
-            proof_instruction_offset,
-        },
-    ))
-}
-
-/// Create a `EmptyAccount` instruction
-pub fn empty_account(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<ZeroBalanceProofData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_empty_account(
-        token_program_id,
-        token_account,
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the `EmptyAccount`
-        // instruction. This means that the proof instruction offset must be always be
-        // 1. To use an arbitrary proof instruction offset, use the
-        // `inner_empty_account` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_zero_balance(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create a `Deposit` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn deposit(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    mint: &Pubkey,
-    amount: u64,
-    decimals: u8,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::Deposit,
-        &DepositInstructionData {
-            amount: amount.into(),
-            decimals,
-        },
-    ))
-}
-
-/// Create a inner `Withdraw` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-#[allow(clippy::too_many_arguments)]
-pub fn inner_withdraw(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    mint: &Pubkey,
-    amount: u64,
-    decimals: u8,
-    new_decryptable_available_balance: DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<WithdrawData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::Withdraw,
-        &WithdrawInstructionData {
-            amount: amount.into(),
-            decimals,
-            new_decryptable_available_balance,
-            proof_instruction_offset,
-        },
-    ))
-}
-
-/// Create a `Withdraw` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn withdraw(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    mint: &Pubkey,
-    amount: u64,
-    decimals: u8,
-    new_decryptable_available_balance: AeCiphertext,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<WithdrawData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_withdraw(
-        token_program_id,
-        token_account,
-        mint,
-        amount,
-        decimals,
-        new_decryptable_available_balance.into(),
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the `Withdraw`
-        // instruction. This means that the proof instruction offset must be
-        // always be 1. To use an arbitrary proof instruction offset, use the
-        // `inner_withdraw` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_withdraw(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create a inner `Transfer` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-#[allow(clippy::too_many_arguments)]
-pub fn inner_transfer(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<TransferData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*source_token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new(*destination_token_account, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::Transfer,
-        &TransferInstructionData {
-            new_source_decryptable_available_balance,
-            proof_instruction_offset,
-        },
-    ))
-}
-
-/// Create a `Transfer` instruction with regular (no-fee) proof
-#[allow(clippy::too_many_arguments)]
-pub fn transfer(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: AeCiphertext,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<TransferData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_transfer(
-        token_program_id,
-        source_token_account,
-        mint,
-        destination_token_account,
-        new_source_decryptable_available_balance.into(),
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the `Transfer`
-        // instruction. This means that the proof instruction offset must be
-        // always be 1. To use an arbitrary proof instruction offset, use the
-        // `inner_transfer` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_transfer(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create a inner `Transfer` instruction with fee
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-#[allow(clippy::too_many_arguments)]
-pub fn inner_transfer_with_fee(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<TransferWithFeeData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*source_token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new(*destination_token_account, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::Transfer,
-        &TransferInstructionData {
-            new_source_decryptable_available_balance,
-            proof_instruction_offset,
-        },
-    ))
-}
-
-/// Create a `Transfer` instruction with fee proof
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_with_fee(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: AeCiphertext,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<TransferWithFeeData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_transfer_with_fee(
-        token_program_id,
-        source_token_account,
-        destination_token_account,
-        mint,
-        new_source_decryptable_available_balance.into(),
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the
-        // `TransferWithFee` instruction. This means that the proof instruction
-        // offset must be always be 1. To use an arbitrary proof instruction
-        // offset, use the `inner_transfer_with_fee` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_transfer_with_fee(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create a inner `ApplyPendingBalance` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-pub fn inner_apply_pending_balance(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    expected_pending_balance_credit_counter: u64,
-    new_decryptable_available_balance: DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*token_account, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::ApplyPendingBalance,
-        &ApplyPendingBalanceData {
-            expected_pending_balance_credit_counter: expected_pending_balance_credit_counter.into(),
-            new_decryptable_available_balance,
-        },
-    ))
-}
-
-/// Create a `ApplyPendingBalance` instruction
-pub fn apply_pending_balance(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    pending_balance_instructions: u64,
-    new_decryptable_available_balance: AeCiphertext,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    inner_apply_pending_balance(
-        token_program_id,
-        token_account,
-        pending_balance_instructions,
-        new_decryptable_available_balance.into(),
-        authority,
-        multisig_signers,
-    ) // calls check_program_account
-}
-
-fn enable_or_disable_balance_credits(
-    instruction: ConfidentialTransferInstruction,
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*token_account, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        instruction,
-        &(),
-    ))
-}
-
-/// Create a `EnableConfidentialCredits` instruction
-pub fn enable_confidential_credits(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    enable_or_disable_balance_credits(
-        ConfidentialTransferInstruction::EnableConfidentialCredits,
-        token_program_id,
-        token_account,
-        authority,
-        multisig_signers,
-    )
-}
-
-/// Create a `DisableConfidentialCredits` instruction
-pub fn disable_confidential_credits(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    enable_or_disable_balance_credits(
-        ConfidentialTransferInstruction::DisableConfidentialCredits,
-        token_program_id,
-        token_account,
-        authority,
-        multisig_signers,
-    )
-}
-
-/// Create a `EnableNonConfidentialCredits` instruction
-pub fn enable_non_confidential_credits(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    enable_or_disable_balance_credits(
-        ConfidentialTransferInstruction::EnableNonConfidentialCredits,
-        token_program_id,
-        token_account,
-        authority,
-        multisig_signers,
-    )
-}
-
-/// Create a `DisableNonConfidentialCredits` instruction
-pub fn disable_non_confidential_credits(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    enable_or_disable_balance_credits(
-        ConfidentialTransferInstruction::DisableNonConfidentialCredits,
-        token_program_id,
-        token_account,
-        authority,
-        multisig_signers,
-    )
-}
-
-/// Create a `TransferWithSplitProof` instruction without fee
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_with_split_proofs(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: DecryptableBalance,
-    source_account_authority: &Pubkey,
-    context_accounts: TransferSplitContextStateAccounts,
-    source_decrypt_handles: &SourceDecryptHandles,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*source_token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new(*destination_token_account, false),
-    ];
-
-    let close_split_context_state_on_execution =
-        if let Some(close_split_context_state_on_execution_accounts) =
-            context_accounts.close_split_context_state_accounts
-        {
-            // If `close_split_context_state_accounts` is set, then all context state
-            // accounts must be `writable`.
-            accounts.push(AccountMeta::new(*context_accounts.equality_proof, false));
-            accounts.push(AccountMeta::new(
-                *context_accounts.ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new(*context_accounts.range_proof, false));
-            accounts.push(AccountMeta::new(
-                *close_split_context_state_on_execution_accounts.lamport_destination,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*context_accounts.authority, true));
-            accounts.push(AccountMeta::new_readonly(
-                *close_split_context_state_on_execution_accounts.zk_token_proof_program,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*source_account_authority, true));
-            true
-        } else {
-            // If `close_split_context_state_accounts` is not set, then context state
-            // accounts can be read-only.
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.equality_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.range_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*source_account_authority, true));
-
-            false
-        };
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::TransferWithSplitProofs,
-        &TransferWithSplitProofsInstructionData {
-            new_source_decryptable_available_balance,
-            no_op_on_uninitialized_split_context_state: context_accounts
-                .no_op_on_uninitialized_split_context_state
-                .into(),
-            close_split_context_state_on_execution: close_split_context_state_on_execution.into(),
-            source_decrypt_handles: *source_decrypt_handles,
-        },
-    ))
-}
-
-/// Create a `TransferWithSplitProof` instruction with fee
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_with_fee_and_split_proofs(
-    token_program_id: &Pubkey,
-    source_token_account: &Pubkey,
-    mint: &Pubkey,
-    destination_token_account: &Pubkey,
-    new_source_decryptable_available_balance: DecryptableBalance,
-    source_account_authority: &Pubkey,
-    context_accounts: TransferWithFeeSplitContextStateAccounts,
-    source_decrypt_handles: &SourceDecryptHandles,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*source_token_account, false),
-        AccountMeta::new_readonly(*mint, false),
-        AccountMeta::new(*destination_token_account, false),
-    ];
-
-    let close_split_context_state_on_execution =
-        if let Some(close_split_context_state_on_execution_accounts) =
-            context_accounts.close_split_context_state_accounts
-        {
-            // If `close_split_context_state_accounts` is set, then all context state
-            // accounts must be `writable`.
-            accounts.push(AccountMeta::new(*context_accounts.equality_proof, false));
-            accounts.push(AccountMeta::new(
-                *context_accounts.transfer_amount_ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new(*context_accounts.fee_sigma_proof, false));
-            accounts.push(AccountMeta::new(
-                *context_accounts.fee_ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new(*context_accounts.range_proof, false));
-            accounts.push(AccountMeta::new(
-                *close_split_context_state_on_execution_accounts.lamport_destination,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*context_accounts.authority, true));
-            accounts.push(AccountMeta::new_readonly(
-                *close_split_context_state_on_execution_accounts.zk_token_proof_program,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*source_account_authority, true));
-            true
-        } else {
-            // If `close_split_context_state_accounts` is not set, then context state
-            // accounts can be read-only.
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.equality_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.transfer_amount_ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.fee_sigma_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.fee_ciphertext_validity_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(
-                *context_accounts.range_proof,
-                false,
-            ));
-            accounts.push(AccountMeta::new_readonly(*source_account_authority, true));
-            false
-        };
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferExtension,
-        ConfidentialTransferInstruction::TransferWithSplitProofs,
-        &TransferWithSplitProofsInstructionData {
-            new_source_decryptable_available_balance,
-            no_op_on_uninitialized_split_context_state: context_accounts
-                .no_op_on_uninitialized_split_context_state
-                .into(),
-            close_split_context_state_on_execution: close_split_context_state_on_execution.into(),
-            source_decrypt_handles: *source_decrypt_handles,
-        },
-    ))
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/mod.rs b/token/program-2022/src/extension/confidential_transfer/mod.rs
deleted file mode 100644
index c2f177d1acf..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/mod.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use {
-    crate::{
-        error::TokenError,
-        extension::{Extension, ExtensionType},
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::entrypoint::ProgramResult,
-    solana_zk_token_sdk::zk_token_elgamal::pod::{AeCiphertext, ElGamalCiphertext, ElGamalPubkey},
-    spl_pod::{
-        bytemuck::pod_from_bytes,
-        optional_keys::{OptionalNonZeroElGamalPubkey, OptionalNonZeroPubkey},
-        primitives::{PodBool, PodU64},
-    },
-};
-
-/// Maximum bit length of any deposit or transfer amount
-///
-/// Any deposit or transfer amount must be less than 2^48
-pub const MAXIMUM_DEPOSIT_TRANSFER_AMOUNT: u64 = (u16::MAX as u64) + (1 << 16) * (u32::MAX as u64);
-
-/// Bit length of the low bits of pending balance plaintext
-pub const PENDING_BALANCE_LO_BIT_LENGTH: u32 = 16;
-
-/// Confidential Transfer Extension instructions
-pub mod instruction;
-
-/// Confidential Transfer Extension processor
-pub mod processor;
-
-/// Helper functions to verify zero-knowledge proofs in the Confidential
-/// Transfer Extension
-pub mod verify_proof;
-
-/// Helper functions to generate split zero-knowledge proofs for confidential
-/// transfers in the Confidential Transfer Extension.
-///
-/// The logic in this submodule should belong to the `solana-zk-token-sdk` and
-/// will be removed with the next upgrade to the Solana program.
-#[cfg(not(target_os = "solana"))]
-pub mod split_proof_generation;
-
-/// Confidential Transfer Extension account information needed for instructions
-#[cfg(not(target_os = "solana"))]
-pub mod account_info;
-
-/// Ciphertext extraction and proof related helper logic
-///
-/// This submodule should be removed with the next upgrade to the Solana program
-pub mod ciphertext_extraction;
-
-/// ElGamal ciphertext containing an account balance
-pub type EncryptedBalance = ElGamalCiphertext;
-/// Authenticated encryption containing an account balance
-pub type DecryptableBalance = AeCiphertext;
-
-/// Confidential transfer mint configuration
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ConfidentialTransferMint {
-    /// Authority to modify the `ConfidentialTransferMint` configuration and to
-    /// approve new accounts (if `auto_approve_new_accounts` is true)
-    ///
-    /// The legacy Token Multisig account is not supported as the authority
-    pub authority: OptionalNonZeroPubkey,
-
-    /// Indicate if newly configured accounts must be approved by the
-    /// `authority` before they may be used by the user.
-    ///
-    /// * If `true`, no approval is required and new accounts may be used
-    ///   immediately
-    /// * If `false`, the authority must approve newly configured accounts (see
-    ///   `ConfidentialTransferInstruction::ConfigureAccount`)
-    pub auto_approve_new_accounts: PodBool,
-
-    /// Authority to decode any transfer amount in a confidential transafer.
-    pub auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey,
-}
-
-impl Extension for ConfidentialTransferMint {
-    const TYPE: ExtensionType = ExtensionType::ConfidentialTransferMint;
-}
-
-/// Confidential account state
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ConfidentialTransferAccount {
-    /// `true` if this account has been approved for use. All confidential
-    /// transfer operations for the account will fail until approval is
-    /// granted.
-    pub approved: PodBool,
-
-    /// The public key associated with ElGamal encryption
-    pub elgamal_pubkey: ElGamalPubkey,
-
-    /// The low 16 bits of the pending balance (encrypted by `elgamal_pubkey`)
-    pub pending_balance_lo: EncryptedBalance,
-
-    /// The high 48 bits of the pending balance (encrypted by `elgamal_pubkey`)
-    pub pending_balance_hi: EncryptedBalance,
-
-    /// The available balance (encrypted by `encrypiton_pubkey`)
-    pub available_balance: EncryptedBalance,
-
-    /// The decryptable available balance
-    pub decryptable_available_balance: DecryptableBalance,
-
-    /// If `false`, the extended account rejects any incoming confidential
-    /// transfers
-    pub allow_confidential_credits: PodBool,
-
-    /// If `false`, the base account rejects any incoming transfers
-    pub allow_non_confidential_credits: PodBool,
-
-    /// The total number of `Deposit` and `Transfer` instructions that have
-    /// credited `pending_balance`
-    pub pending_balance_credit_counter: PodU64,
-
-    /// The maximum number of `Deposit` and `Transfer` instructions that can
-    /// credit `pending_balance` before the `ApplyPendingBalance`
-    /// instruction is executed
-    pub maximum_pending_balance_credit_counter: PodU64,
-
-    /// The `expected_pending_balance_credit_counter` value that was included in
-    /// the last `ApplyPendingBalance` instruction
-    pub expected_pending_balance_credit_counter: PodU64,
-
-    /// The actual `pending_balance_credit_counter` when the last
-    /// `ApplyPendingBalance` instruction was executed
-    pub actual_pending_balance_credit_counter: PodU64,
-}
-
-impl Extension for ConfidentialTransferAccount {
-    const TYPE: ExtensionType = ExtensionType::ConfidentialTransferAccount;
-}
-
-impl ConfidentialTransferAccount {
-    /// Check if a `ConfidentialTransferAccount` has been approved for use.
-    pub fn approved(&self) -> ProgramResult {
-        if bool::from(&self.approved) {
-            Ok(())
-        } else {
-            Err(TokenError::ConfidentialTransferAccountNotApproved.into())
-        }
-    }
-
-    /// Check if a `ConfidentialTransferAccount` is in a closable state.
-    pub fn closable(&self) -> ProgramResult {
-        if self.pending_balance_lo == EncryptedBalance::zeroed()
-            && self.pending_balance_hi == EncryptedBalance::zeroed()
-            && self.available_balance == EncryptedBalance::zeroed()
-        {
-            Ok(())
-        } else {
-            Err(TokenError::ConfidentialTransferAccountHasBalance.into())
-        }
-    }
-
-    /// Check if a base account of a `ConfidentialTransferAccount` accepts
-    /// non-confidential transfers.
-    pub fn non_confidential_transfer_allowed(&self) -> ProgramResult {
-        if bool::from(&self.allow_non_confidential_credits) {
-            Ok(())
-        } else {
-            Err(TokenError::NonConfidentialTransfersDisabled.into())
-        }
-    }
-
-    /// Checks if a `ConfidentialTransferAccount` is configured to send funds.
-    pub fn valid_as_source(&self) -> ProgramResult {
-        self.approved()
-    }
-
-    /// Checks if a confidential extension is configured to receive funds.
-    ///
-    /// A destination account can receive funds if the following conditions are
-    /// satisfied:
-    ///   1. The account is approved by the confidential transfer mint authority
-    ///   2. The account is not disabled by the account owner
-    ///   3. The number of credits into the account has not reached the maximum
-    ///      credit counter
-    pub fn valid_as_destination(&self) -> ProgramResult {
-        self.approved()?;
-
-        if !bool::from(self.allow_confidential_credits) {
-            return Err(TokenError::ConfidentialTransferDepositsAndTransfersDisabled.into());
-        }
-
-        let new_destination_pending_balance_credit_counter =
-            u64::from(self.pending_balance_credit_counter)
-                .checked_add(1)
-                .ok_or(TokenError::Overflow)?;
-        if new_destination_pending_balance_credit_counter
-            > u64::from(self.maximum_pending_balance_credit_counter)
-        {
-            return Err(TokenError::MaximumPendingBalanceCreditCounterExceeded.into());
-        }
-
-        Ok(())
-    }
-
-    /// Increments a confidential extension pending balance credit counter.
-    pub fn increment_pending_balance_credit_counter(&mut self) -> ProgramResult {
-        self.pending_balance_credit_counter = (u64::from(self.pending_balance_credit_counter)
-            .checked_add(1)
-            .ok_or(TokenError::Overflow)?)
-        .into();
-        Ok(())
-    }
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/processor.rs b/token/program-2022/src/extension/confidential_transfer/processor.rs
deleted file mode 100644
index 21fed2b3682..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/processor.rs
+++ /dev/null
@@ -1,1232 +0,0 @@
-// Remove feature once zk ops syscalls are enabled on all networks
-#[cfg(feature = "confidential-hook")]
-use crate::extension::transfer_hook;
-#[cfg(feature = "zk-ops")]
-use {
-    crate::extension::non_transferable::NonTransferableAccount,
-    solana_zk_token_sdk::zk_token_elgamal::ops as syscall,
-};
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            confidential_transfer::{ciphertext_extraction::*, instruction::*, verify_proof::*, *},
-            confidential_transfer_fee::{
-                ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig,
-                EncryptedWithheldAmount,
-            },
-            memo_transfer::{check_previous_sibling_instruction_is_memo, memo_required},
-            transfer_fee::TransferFeeConfig,
-            BaseStateWithExtensions, BaseStateWithExtensionsMut, PodStateWithExtensions,
-            PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::{PodAccount, PodMint},
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        clock::Clock,
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        sysvar::Sysvar,
-    },
-};
-
-/// Processes an [InitializeMint] instruction.
-fn process_initialize_mint(
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    auto_approve_new_account: PodBool,
-    auditor_encryption_pubkey: &OptionalNonZeroElGamalPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_info = next_account_info(account_info_iter)?;
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mut mint_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(mint_data)?;
-    let confidential_transfer_mint = mint.init_extension::<ConfidentialTransferMint>(true)?;
-
-    confidential_transfer_mint.authority = *authority;
-    confidential_transfer_mint.auto_approve_new_accounts = auto_approve_new_account;
-    confidential_transfer_mint.auditor_elgamal_pubkey = *auditor_encryption_pubkey;
-
-    Ok(())
-}
-
-/// Processes an [UpdateMint] instruction.
-fn process_update_mint(
-    accounts: &[AccountInfo],
-    auto_approve_new_account: PodBool,
-    auditor_encryption_pubkey: &OptionalNonZeroElGamalPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mut mint_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
-    let confidential_transfer_mint = mint.get_extension_mut::<ConfidentialTransferMint>()?;
-    let maybe_confidential_transfer_mint_authority: Option<Pubkey> =
-        confidential_transfer_mint.authority.into();
-    let confidential_transfer_mint_authority =
-        maybe_confidential_transfer_mint_authority.ok_or(TokenError::NoAuthorityExists)?;
-
-    if !authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    if confidential_transfer_mint_authority != *authority_info.key {
-        return Err(TokenError::OwnerMismatch.into());
-    }
-
-    confidential_transfer_mint.auto_approve_new_accounts = auto_approve_new_account;
-    confidential_transfer_mint.auditor_elgamal_pubkey = *auditor_encryption_pubkey;
-    Ok(())
-}
-
-/// Processes a [ConfigureAccount] instruction.
-fn process_configure_account(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    decryptable_zero_balance: &DecryptableBalance,
-    maximum_pending_balance_credit_counter: &PodU64,
-    proof_instruction_offset: i64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-
-    // zero-knowledge proof certifies that the supplied ElGamal public key is valid
-    let proof_context =
-        verify_configure_account_proof(account_info_iter, proof_instruction_offset)?;
-
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    if token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mut mint_info.data.borrow();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(mint_data)?;
-    let confidential_transfer_mint = mint.get_extension::<ConfidentialTransferMint>()?;
-
-    // Note: The caller is expected to use the `Reallocate` instruction to ensure
-    // there is sufficient room in their token account for the new
-    // `ConfidentialTransferAccount` extension
-    let confidential_transfer_account =
-        token_account.init_extension::<ConfidentialTransferAccount>(false)?;
-    confidential_transfer_account.approved = confidential_transfer_mint.auto_approve_new_accounts;
-    confidential_transfer_account.elgamal_pubkey = proof_context.pubkey;
-    confidential_transfer_account.maximum_pending_balance_credit_counter =
-        *maximum_pending_balance_credit_counter;
-
-    // The all-zero ciphertext [0; 64] is a valid encryption of zero
-    confidential_transfer_account.pending_balance_lo = EncryptedBalance::zeroed();
-    confidential_transfer_account.pending_balance_hi = EncryptedBalance::zeroed();
-    confidential_transfer_account.available_balance = EncryptedBalance::zeroed();
-
-    confidential_transfer_account.decryptable_available_balance = *decryptable_zero_balance;
-    confidential_transfer_account.allow_confidential_credits = true.into();
-    confidential_transfer_account.pending_balance_credit_counter = 0.into();
-    confidential_transfer_account.expected_pending_balance_credit_counter = 0.into();
-    confidential_transfer_account.actual_pending_balance_credit_counter = 0.into();
-    confidential_transfer_account.allow_non_confidential_credits = true.into();
-
-    // if the mint is extended for fees, then initialize account for confidential
-    // transfer fees
-    if mint.get_extension::<TransferFeeConfig>().is_ok() {
-        let confidential_transfer_fee_amount =
-            token_account.init_extension::<ConfidentialTransferFeeAmount>(false)?;
-        confidential_transfer_fee_amount.withheld_amount = EncryptedWithheldAmount::zeroed();
-    }
-
-    Ok(())
-}
-
-/// Processes an [ApproveAccount] instruction.
-fn process_approve_account(accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    if *mint_info.key != token_account.base.mint {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mint_info.data.borrow_mut();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(mint_data)?;
-    let confidential_transfer_mint = mint.get_extension::<ConfidentialTransferMint>()?;
-    let maybe_confidential_transfer_mint_authority: Option<Pubkey> =
-        confidential_transfer_mint.authority.into();
-    let confidential_transfer_mint_authority =
-        maybe_confidential_transfer_mint_authority.ok_or(TokenError::NoAuthorityExists)?;
-
-    if authority_info.is_signer && *authority_info.key == confidential_transfer_mint_authority {
-        let confidential_transfer_state =
-            token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-        confidential_transfer_state.approved = true.into();
-        Ok(())
-    } else {
-        Err(ProgramError::MissingRequiredSignature)
-    }
-}
-
-/// Processes an [EmptyAccount] instruction.
-fn process_empty_account(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    proof_instruction_offset: i64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-
-    // zero-knowledge proof certifies that the available balance ciphertext holds
-    // the balance of 0.
-    let proof_context = verify_empty_account_proof(account_info_iter, proof_instruction_offset)?;
-
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-
-    // Check that the encryption public key and ciphertext associated with the
-    // confidential extension account are consistent with those that were
-    // actually used to generate the zkp.
-    if confidential_transfer_account.elgamal_pubkey != proof_context.pubkey {
-        msg!("Encryption public-key mismatch");
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-    if confidential_transfer_account.available_balance != proof_context.ciphertext {
-        msg!("Available balance mismatch");
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    confidential_transfer_account.available_balance = EncryptedBalance::zeroed();
-
-    // check that all balances are all-zero ciphertexts
-    confidential_transfer_account.closable()?;
-
-    Ok(())
-}
-
-/// Processes a [Deposit] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_deposit(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    amount: u64,
-    expected_decimals: u8,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mint_info.data.borrow_mut();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(mint_data)?;
-
-    if expected_decimals != mint.base.decimals {
-        return Err(TokenError::MintDecimalsMismatch.into());
-    }
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-    if token_account
-        .get_extension::<NonTransferableAccount>()
-        .is_ok()
-    {
-        return Err(TokenError::NonTransferable.into());
-    }
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    if token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    // Wrapped SOL deposits are not supported because lamports cannot be vanished.
-    assert!(!token_account.base.is_native());
-
-    token_account.base.amount = u64::from(token_account.base.amount)
-        .checked_sub(amount)
-        .ok_or(TokenError::Overflow)?
-        .into();
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.valid_as_destination()?;
-
-    // A deposit amount must be a 48-bit number
-    let (amount_lo, amount_hi) = verify_and_split_deposit_amount(amount)?;
-
-    // Prevent unnecessary ciphertext arithmetic syscalls if `amount_lo` or
-    // `amount_hi` is zero
-    if amount_lo > 0 {
-        confidential_transfer_account.pending_balance_lo =
-            syscall::add_to(&confidential_transfer_account.pending_balance_lo, amount_lo)
-                .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    }
-    if amount_hi > 0 {
-        confidential_transfer_account.pending_balance_hi =
-            syscall::add_to(&confidential_transfer_account.pending_balance_hi, amount_hi)
-                .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    }
-
-    confidential_transfer_account.increment_pending_balance_credit_counter()?;
-
-    Ok(())
-}
-
-/// Verifies that a deposit amount is a 48-bit number and returns the least
-/// significant 16 bits and most significant 32 bits of the amount.
-#[cfg(feature = "zk-ops")]
-pub fn verify_and_split_deposit_amount(amount: u64) -> Result<(u64, u64), TokenError> {
-    if amount > MAXIMUM_DEPOSIT_TRANSFER_AMOUNT {
-        return Err(TokenError::MaximumDepositAmountExceeded);
-    }
-    let deposit_amount_lo = amount & (u16::MAX as u64);
-    let deposit_amount_hi = amount.checked_shr(u16::BITS).unwrap();
-    Ok((deposit_amount_lo, deposit_amount_hi))
-}
-
-/// Processes a [Withdraw] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_withdraw(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    amount: u64,
-    expected_decimals: u8,
-    new_decryptable_available_balance: DecryptableBalance,
-    proof_instruction_offset: i64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-
-    // zero-knowledge proof certifies that the account has enough available balance
-    // to withdraw the amount.
-    let proof_context = verify_withdraw_proof(account_info_iter, proof_instruction_offset)?;
-
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mint_info.data.borrow_mut();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(mint_data)?;
-
-    if expected_decimals != mint.base.decimals {
-        return Err(TokenError::MintDecimalsMismatch.into());
-    }
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-    if token_account
-        .get_extension::<NonTransferableAccount>()
-        .is_ok()
-    {
-        return Err(TokenError::NonTransferable.into());
-    }
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    if token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    // Wrapped SOL withdrawals are not supported because lamports cannot be
-    // apparated.
-    assert!(!token_account.base.is_native());
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.valid_as_source()?;
-
-    // Check that the encryption public key associated with the confidential
-    // extension is consistent with the public key that was actually used to
-    // generate the zkp.
-    if confidential_transfer_account.elgamal_pubkey != proof_context.pubkey {
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-
-    // Prevent unnecessary ciphertext arithmetic syscalls if the withdraw amount is
-    // zero
-    if amount > 0 {
-        confidential_transfer_account.available_balance =
-            syscall::subtract_from(&confidential_transfer_account.available_balance, amount)
-                .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    }
-    // Check that the final available balance ciphertext is consistent with the
-    // actual ciphertext for which the zero-knowledge proof was generated for.
-    if confidential_transfer_account.available_balance != proof_context.final_ciphertext {
-        return Err(TokenError::ConfidentialTransferBalanceMismatch.into());
-    }
-
-    confidential_transfer_account.decryptable_available_balance = new_decryptable_available_balance;
-    token_account.base.amount = u64::from(token_account.base.amount)
-        .checked_add(amount)
-        .ok_or(TokenError::Overflow)?
-        .into();
-
-    Ok(())
-}
-
-/// Processes a [Transfer] or [TransferWithSplitProofs] instruction.
-#[allow(clippy::too_many_arguments)]
-#[cfg(feature = "zk-ops")]
-fn process_transfer(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_source_decryptable_available_balance: DecryptableBalance,
-    proof_instruction_offset: i64,
-    split_proof_context_state_accounts: bool,
-    no_op_on_uninitialized_split_context_state: bool,
-    close_split_context_state_on_execution: bool,
-    source_decrypt_handles: &SourceDecryptHandles,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let source_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = mint_info.data.borrow_mut();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-
-    let confidential_transfer_mint = mint.get_extension::<ConfidentialTransferMint>()?;
-
-    // A `Transfer` instruction must be accompanied by a zero-knowledge proof
-    // instruction that certify the validity of the transfer amounts. The kind
-    // of zero-knowledge proof instruction depends on whether a transfer incurs
-    // a fee or not.
-    //   - If the mint is not extended for fees or the instruction is for a
-    //     self-transfer, then
-    //   transfer fee is not required.
-    //   - If the mint is extended for fees and the instruction is not a
-    //     self-transfer, then
-    //   transfer fee is required.
-    let authority_info = if mint.get_extension::<TransferFeeConfig>().is_err() {
-        // Transfer fee is not required. Decode the zero-knowledge proof as
-        // `TransferData`.
-        //
-        // The zero-knowledge proof certifies that:
-        //   1. the transfer amount is encrypted in the correct form
-        //   2. the source account has enough balance to send the transfer amount
-        let maybe_proof_context = verify_transfer_proof(
-            account_info_iter,
-            proof_instruction_offset,
-            split_proof_context_state_accounts,
-            no_op_on_uninitialized_split_context_state,
-            close_split_context_state_on_execution,
-            source_decrypt_handles,
-        )?;
-        // If `maybe_proof_context` is `None`, then this means that
-        // `no_op_on_uninitialized_split_context_state` is true and a required context
-        // state account is not yet initialized. Even if this is the case, we
-        // follow through with the rest of the transfer logic to perform all the
-        // necessary checks for a transfer to be safe.
-
-        // If `close_split_context_state_on_execution` is `true`, then the source
-        // account authority info is located after the lamport destination,
-        // context state authority, and zk token proof program account infos.
-        // Flush out these account infos.
-        if close_split_context_state_on_execution && maybe_proof_context.is_none() {
-            let _lamport_destination_account_info = next_account_info(account_info_iter)?;
-            let _context_state_authority_info = next_account_info(account_info_iter)?;
-            let _zk_token_proof_program_info = next_account_info(account_info_iter)?;
-        }
-
-        let authority_info = next_account_info(account_info_iter)?;
-
-        // Check that the auditor encryption public key associated wth the confidential
-        // mint is consistent with what was actually used to generate the zkp.
-        if let Some(ref proof_context) = maybe_proof_context {
-            if !confidential_transfer_mint
-                .auditor_elgamal_pubkey
-                .equals(&proof_context.transfer_pubkeys.auditor)
-            {
-                return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-            }
-        }
-
-        process_source_for_transfer(
-            program_id,
-            source_account_info,
-            mint_info,
-            authority_info,
-            account_info_iter.as_slice(),
-            maybe_proof_context.as_ref(),
-            new_source_decryptable_available_balance,
-        )?;
-
-        process_destination_for_transfer(
-            destination_account_info,
-            mint_info,
-            maybe_proof_context.as_ref(),
-        )?;
-
-        if maybe_proof_context.is_none() {
-            msg!(
-                "Context states not fully initialized: returning with no op; transfer is NOT yet
-            executed"
-            );
-        }
-        authority_info
-    } else {
-        // Transfer fee is required.
-        let transfer_fee_config = mint.get_extension::<TransferFeeConfig>()?;
-        let fee_parameters = transfer_fee_config.get_epoch_fee(Clock::get()?.epoch);
-
-        // Decode the zero-knowledge proof as `TransferWithFeeData`.
-        //
-        // The zero-knowledge proof certifies that:
-        //   1. the transfer amount is encrypted in the correct form
-        //   2. the source account has enough balance to send the transfer amount
-        //   3. the transfer fee is computed correctly and encrypted in the correct form
-        let maybe_proof_context = verify_transfer_with_fee_proof(
-            account_info_iter,
-            proof_instruction_offset,
-            split_proof_context_state_accounts,
-            no_op_on_uninitialized_split_context_state,
-            close_split_context_state_on_execution,
-            source_decrypt_handles,
-            fee_parameters,
-        )?;
-
-        // If `maybe_proof_context` is `None`, then this means that
-        // `no_op_on_uninitialized_split_context_state` is true and a required context
-        // state account is not yet initialized. Even if this is the case, we
-        // follow through with the rest of the transfer with fee logic to
-        // perform all the necessary checks to be safe.
-
-        // If `close_split_context_state_on_execution` is `true`, then the source
-        // account authority info is located after the lamport destination,
-        // context state authority, and zk token proof program account infos.
-        // Flush out these account infos.
-        if close_split_context_state_on_execution && maybe_proof_context.is_none() {
-            let _lamport_destination_account_info = next_account_info(account_info_iter)?;
-            let _context_state_authority_info = next_account_info(account_info_iter)?;
-            let _zk_token_proof_program_info = next_account_info(account_info_iter)?;
-        }
-
-        let authority_info = next_account_info(account_info_iter)?;
-
-        // Check that the encryption public keys associated with the mint confidential
-        // transfer and confidential transfer fee extensions are consistent with
-        // the keys that were used to generate the zkp.
-        if let Some(ref proof_context) = maybe_proof_context {
-            if !confidential_transfer_mint
-                .auditor_elgamal_pubkey
-                .equals(&proof_context.transfer_with_fee_pubkeys.auditor)
-            {
-                return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-            }
-        }
-
-        let confidential_transfer_fee_config =
-            mint.get_extension::<ConfidentialTransferFeeConfig>()?;
-
-        // Check that the withdraw withheld authority ElGamal public key in the mint is
-        // consistent with what was used to generate the zkp.
-        if let Some(ref proof_context) = maybe_proof_context {
-            if proof_context
-                .transfer_with_fee_pubkeys
-                .withdraw_withheld_authority
-                != confidential_transfer_fee_config.withdraw_withheld_authority_elgamal_pubkey
-            {
-                return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-            }
-        }
-
-        process_source_for_transfer_with_fee(
-            program_id,
-            source_account_info,
-            mint_info,
-            authority_info,
-            account_info_iter.as_slice(),
-            maybe_proof_context.as_ref(),
-            new_source_decryptable_available_balance,
-        )?;
-
-        let is_self_transfer = source_account_info.key == destination_account_info.key;
-        process_destination_for_transfer_with_fee(
-            destination_account_info,
-            mint_info,
-            maybe_proof_context.as_ref(),
-            is_self_transfer,
-        )?;
-
-        if maybe_proof_context.is_none() {
-            msg!(
-                "Context state not fully initialized: returning with no op; transfer is NOT yet executed"
-            );
-        }
-        authority_info
-    };
-
-    #[cfg(feature = "confidential-hook")]
-    if let Some(program_id) = transfer_hook::get_program_id(&mint) {
-        // set transferring flags, scope the borrow to avoid double-borrow during CPI
-        {
-            let mut source_account_data = source_account_info.data.borrow_mut();
-            let mut source_account =
-                PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-            transfer_hook::set_transferring(&mut source_account)?;
-        }
-        {
-            let mut destination_account_data = destination_account_info.data.borrow_mut();
-            let mut destination_account =
-                PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-            transfer_hook::set_transferring(&mut destination_account)?;
-        }
-
-        // can't doubly-borrow the mint data either
-        drop(mint_data);
-
-        // Since the amount is unknown during a confidential transfer, pass in
-        // u64::MAX as a convention.
-        spl_transfer_hook_interface::onchain::invoke_execute(
-            &program_id,
-            source_account_info.clone(),
-            mint_info.clone(),
-            destination_account_info.clone(),
-            authority_info.clone(),
-            account_info_iter.as_slice(),
-            u64::MAX,
-        )?;
-
-        // unset transferring flag
-        transfer_hook::unset_transferring(source_account_info)?;
-        transfer_hook::unset_transferring(destination_account_info)?;
-    }
-
-    Ok(())
-}
-
-#[cfg(feature = "zk-ops")]
-fn process_source_for_transfer(
-    program_id: &Pubkey,
-    source_account_info: &AccountInfo,
-    mint_info: &AccountInfo,
-    authority_info: &AccountInfo,
-    signers: &[AccountInfo],
-    maybe_proof_context: Option<&TransferProofContextInfo>,
-    new_source_decryptable_available_balance: DecryptableBalance,
-) -> ProgramResult {
-    check_program_account(source_account_info.owner)?;
-    let authority_info_data_len = authority_info.data_len();
-    let token_account_data = &mut source_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-    if token_account
-        .get_extension::<NonTransferableAccount>()
-        .is_ok()
-    {
-        return Err(TokenError::NonTransferable.into());
-    }
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        signers,
-    )?;
-
-    if token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.valid_as_source()?;
-
-    if let Some(proof_context) = maybe_proof_context {
-        // Check that the source encryption public key is consistent with what was
-        // actually used to generate the zkp.
-        if proof_context.transfer_pubkeys.source != confidential_transfer_account.elgamal_pubkey {
-            return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-        }
-
-        let source_transfer_amount_lo =
-            transfer_amount_source_ciphertext(&proof_context.ciphertext_lo);
-        let source_transfer_amount_hi =
-            transfer_amount_source_ciphertext(&proof_context.ciphertext_hi);
-
-        let new_source_available_balance = syscall::subtract_with_lo_hi(
-            &confidential_transfer_account.available_balance,
-            &source_transfer_amount_lo,
-            &source_transfer_amount_hi,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        // Check that the computed available balance is consistent with what was
-        // actually used to generate the zkp on the client side.
-        if new_source_available_balance != proof_context.new_source_ciphertext {
-            return Err(TokenError::ConfidentialTransferBalanceMismatch.into());
-        }
-
-        confidential_transfer_account.available_balance = new_source_available_balance;
-        confidential_transfer_account.decryptable_available_balance =
-            new_source_decryptable_available_balance;
-    }
-
-    Ok(())
-}
-
-#[cfg(feature = "zk-ops")]
-fn process_destination_for_transfer(
-    destination_account_info: &AccountInfo,
-    mint_info: &AccountInfo,
-    maybe_transfer_proof_context_info: Option<&TransferProofContextInfo>,
-) -> ProgramResult {
-    check_program_account(destination_account_info.owner)?;
-    let destination_token_account_data = &mut destination_account_info.data.borrow_mut();
-    let mut destination_token_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(destination_token_account_data)?;
-
-    if destination_token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if destination_token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    if memo_required(&destination_token_account) {
-        check_previous_sibling_instruction_is_memo()?;
-    }
-
-    let destination_confidential_transfer_account =
-        destination_token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    destination_confidential_transfer_account.valid_as_destination()?;
-
-    if let Some(proof_context) = maybe_transfer_proof_context_info {
-        if proof_context.transfer_pubkeys.destination
-            != destination_confidential_transfer_account.elgamal_pubkey
-        {
-            return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-        }
-
-        let destination_ciphertext_lo =
-            transfer_amount_destination_ciphertext(&proof_context.ciphertext_lo);
-        let destination_ciphertext_hi =
-            transfer_amount_destination_ciphertext(&proof_context.ciphertext_hi);
-
-        destination_confidential_transfer_account.pending_balance_lo = syscall::add(
-            &destination_confidential_transfer_account.pending_balance_lo,
-            &destination_ciphertext_lo,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        destination_confidential_transfer_account.pending_balance_hi = syscall::add(
-            &destination_confidential_transfer_account.pending_balance_hi,
-            &destination_ciphertext_hi,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        destination_confidential_transfer_account.increment_pending_balance_credit_counter()?;
-    }
-
-    Ok(())
-}
-
-#[allow(clippy::too_many_arguments)]
-#[cfg(feature = "zk-ops")]
-fn process_source_for_transfer_with_fee(
-    program_id: &Pubkey,
-    source_account_info: &AccountInfo,
-    mint_info: &AccountInfo,
-    authority_info: &AccountInfo,
-    signers: &[AccountInfo],
-    maybe_proof_context: Option<&TransferWithFeeProofContextInfo>,
-    new_source_decryptable_available_balance: DecryptableBalance,
-) -> ProgramResult {
-    check_program_account(source_account_info.owner)?;
-    let authority_info_data_len = authority_info.data_len();
-    let token_account_data = &mut source_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-    if token_account
-        .get_extension::<NonTransferableAccount>()
-        .is_ok()
-    {
-        return Err(TokenError::NonTransferable.into());
-    }
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        signers,
-    )?;
-
-    if token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.valid_as_source()?;
-
-    if let Some(proof_context) = maybe_proof_context {
-        // Check that the source encryption public key is consistent with what was
-        // actually used to generate the zkp.
-        if proof_context.transfer_with_fee_pubkeys.source
-            != confidential_transfer_account.elgamal_pubkey
-        {
-            return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-        }
-
-        let source_transfer_amount_lo =
-            transfer_amount_source_ciphertext(&proof_context.ciphertext_lo);
-        let source_transfer_amount_hi =
-            transfer_amount_source_ciphertext(&proof_context.ciphertext_hi);
-
-        let new_source_available_balance = syscall::subtract_with_lo_hi(
-            &confidential_transfer_account.available_balance,
-            &source_transfer_amount_lo,
-            &source_transfer_amount_hi,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        // Check that the computed available balance is consistent with what was
-        // actually used to generate the zkp on the client side.
-        if new_source_available_balance != proof_context.new_source_ciphertext {
-            return Err(TokenError::ConfidentialTransferBalanceMismatch.into());
-        }
-
-        confidential_transfer_account.available_balance = new_source_available_balance;
-        confidential_transfer_account.decryptable_available_balance =
-            new_source_decryptable_available_balance;
-    }
-
-    Ok(())
-}
-
-#[cfg(feature = "zk-ops")]
-fn process_destination_for_transfer_with_fee(
-    destination_account_info: &AccountInfo,
-    mint_info: &AccountInfo,
-    maybe_proof_context: Option<&TransferWithFeeProofContextInfo>,
-    is_self_transfer: bool,
-) -> ProgramResult {
-    check_program_account(destination_account_info.owner)?;
-    let destination_token_account_data = &mut destination_account_info.data.borrow_mut();
-    let mut destination_token_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(destination_token_account_data)?;
-
-    if destination_token_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    if destination_token_account.base.mint != *mint_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    if memo_required(&destination_token_account) {
-        check_previous_sibling_instruction_is_memo()?;
-    }
-
-    let destination_confidential_transfer_account =
-        destination_token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    destination_confidential_transfer_account.valid_as_destination()?;
-
-    if let Some(proof_context) = maybe_proof_context {
-        if proof_context.transfer_with_fee_pubkeys.destination
-            != destination_confidential_transfer_account.elgamal_pubkey
-        {
-            return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-        }
-
-        let destination_transfer_amount_lo =
-            transfer_amount_destination_ciphertext(&proof_context.ciphertext_lo);
-        let destination_transfer_amount_hi =
-            transfer_amount_destination_ciphertext(&proof_context.ciphertext_hi);
-
-        destination_confidential_transfer_account.pending_balance_lo = syscall::add(
-            &destination_confidential_transfer_account.pending_balance_lo,
-            &destination_transfer_amount_lo,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        destination_confidential_transfer_account.pending_balance_hi = syscall::add(
-            &destination_confidential_transfer_account.pending_balance_hi,
-            &destination_transfer_amount_hi,
-        )
-        .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-        destination_confidential_transfer_account.increment_pending_balance_credit_counter()?;
-
-        // process transfer fee
-        if !is_self_transfer {
-            // Decode lo and hi fee amounts encrypted under the destination encryption
-            // public key
-            let destination_fee_lo =
-                fee_amount_destination_ciphertext(&proof_context.fee_ciphertext_lo);
-            let destination_fee_hi =
-                fee_amount_destination_ciphertext(&proof_context.fee_ciphertext_hi);
-
-            // Subtract the fee amount from the destination pending balance
-            destination_confidential_transfer_account.pending_balance_lo = syscall::subtract(
-                &destination_confidential_transfer_account.pending_balance_lo,
-                &destination_fee_lo,
-            )
-            .ok_or(TokenError::CiphertextArithmeticFailed)?;
-            destination_confidential_transfer_account.pending_balance_hi = syscall::subtract(
-                &destination_confidential_transfer_account.pending_balance_hi,
-                &destination_fee_hi,
-            )
-            .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-            // Decode lo and hi fee amounts encrypted under the withdraw authority
-            // encryption public key
-            let withdraw_withheld_authority_fee_lo =
-                fee_amount_withdraw_withheld_authority_ciphertext(&proof_context.fee_ciphertext_lo);
-            let withdraw_withheld_authority_fee_hi =
-                fee_amount_withdraw_withheld_authority_ciphertext(&proof_context.fee_ciphertext_hi);
-
-            let destination_confidential_transfer_fee_amount =
-                destination_token_account.get_extension_mut::<ConfidentialTransferFeeAmount>()?;
-
-            // Add the fee amount to the destination withheld fee
-            destination_confidential_transfer_fee_amount.withheld_amount = syscall::add_with_lo_hi(
-                &destination_confidential_transfer_fee_amount.withheld_amount,
-                &withdraw_withheld_authority_fee_lo,
-                &withdraw_withheld_authority_fee_hi,
-            )
-            .ok_or(TokenError::CiphertextArithmeticFailed)?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Processes an [ApplyPendingBalance] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_apply_pending_balance(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    ApplyPendingBalanceData {
-        expected_pending_balance_credit_counter,
-        new_decryptable_available_balance,
-    }: &ApplyPendingBalanceData,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-
-    confidential_transfer_account.available_balance = syscall::add_with_lo_hi(
-        &confidential_transfer_account.available_balance,
-        &confidential_transfer_account.pending_balance_lo,
-        &confidential_transfer_account.pending_balance_hi,
-    )
-    .ok_or(TokenError::CiphertextArithmeticFailed)?;
-
-    confidential_transfer_account.actual_pending_balance_credit_counter =
-        confidential_transfer_account.pending_balance_credit_counter;
-    confidential_transfer_account.expected_pending_balance_credit_counter =
-        *expected_pending_balance_credit_counter;
-    confidential_transfer_account.decryptable_available_balance =
-        *new_decryptable_available_balance;
-    confidential_transfer_account.pending_balance_credit_counter = 0.into();
-    confidential_transfer_account.pending_balance_lo = EncryptedBalance::zeroed();
-    confidential_transfer_account.pending_balance_hi = EncryptedBalance::zeroed();
-
-    Ok(())
-}
-
-/// Processes a [DisableConfidentialCredits] or [EnableConfidentialCredits]
-/// instruction.
-fn process_allow_confidential_credits(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    allow_confidential_credits: bool,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.allow_confidential_credits = allow_confidential_credits.into();
-
-    Ok(())
-}
-
-/// Processes an [DisableNonConfidentialCredits] or
-/// [EnableNonConfidentialCredits] instruction.
-fn process_allow_non_confidential_credits(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    allow_non_confidential_credits: bool,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(token_account_info.owner)?;
-    let token_account_data = &mut token_account_info.data.borrow_mut();
-    let mut token_account = PodStateWithExtensionsMut::<PodAccount>::unpack(token_account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &token_account.base.owner,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let confidential_transfer_account =
-        token_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    confidential_transfer_account.allow_non_confidential_credits =
-        allow_non_confidential_credits.into();
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-
-    match decode_instruction_type(input)? {
-        ConfidentialTransferInstruction::InitializeMint => {
-            msg!("ConfidentialTransferInstruction::InitializeMint");
-            let data = decode_instruction_data::<InitializeMintData>(input)?;
-            process_initialize_mint(
-                accounts,
-                &data.authority,
-                data.auto_approve_new_accounts,
-                &data.auditor_elgamal_pubkey,
-            )
-        }
-        ConfidentialTransferInstruction::UpdateMint => {
-            msg!("ConfidentialTransferInstruction::UpdateMint");
-            let data = decode_instruction_data::<UpdateMintData>(input)?;
-            process_update_mint(
-                accounts,
-                data.auto_approve_new_accounts,
-                &data.auditor_elgamal_pubkey,
-            )
-        }
-        ConfidentialTransferInstruction::ConfigureAccount => {
-            msg!("ConfidentialTransferInstruction::ConfigureAccount");
-            let data = decode_instruction_data::<ConfigureAccountInstructionData>(input)?;
-            process_configure_account(
-                program_id,
-                accounts,
-                &data.decryptable_zero_balance,
-                &data.maximum_pending_balance_credit_counter,
-                data.proof_instruction_offset as i64,
-            )
-        }
-        ConfidentialTransferInstruction::ApproveAccount => {
-            msg!("ConfidentialTransferInstruction::ApproveAccount");
-            process_approve_account(accounts)
-        }
-        ConfidentialTransferInstruction::EmptyAccount => {
-            msg!("ConfidentialTransferInstruction::EmptyAccount");
-            let data = decode_instruction_data::<EmptyAccountInstructionData>(input)?;
-            process_empty_account(program_id, accounts, data.proof_instruction_offset as i64)
-        }
-        ConfidentialTransferInstruction::Deposit => {
-            msg!("ConfidentialTransferInstruction::Deposit");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data = decode_instruction_data::<DepositInstructionData>(input)?;
-                process_deposit(program_id, accounts, data.amount.into(), data.decimals)
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            Err(ProgramError::InvalidInstructionData)
-        }
-        ConfidentialTransferInstruction::Withdraw => {
-            msg!("ConfidentialTransferInstruction::Withdraw");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data = decode_instruction_data::<WithdrawInstructionData>(input)?;
-                process_withdraw(
-                    program_id,
-                    accounts,
-                    data.amount.into(),
-                    data.decimals,
-                    data.new_decryptable_available_balance,
-                    data.proof_instruction_offset as i64,
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            Err(ProgramError::InvalidInstructionData)
-        }
-        ConfidentialTransferInstruction::Transfer => {
-            msg!("ConfidentialTransferInstruction::Transfer");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data = decode_instruction_data::<TransferInstructionData>(input)?;
-                process_transfer(
-                    program_id,
-                    accounts,
-                    data.new_source_decryptable_available_balance,
-                    data.proof_instruction_offset as i64,
-                    false,
-                    false,
-                    false,
-                    &SourceDecryptHandles::zeroed(),
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            Err(ProgramError::InvalidInstructionData)
-        }
-        ConfidentialTransferInstruction::ApplyPendingBalance => {
-            msg!("ConfidentialTransferInstruction::ApplyPendingBalance");
-            #[cfg(feature = "zk-ops")]
-            {
-                process_apply_pending_balance(
-                    program_id,
-                    accounts,
-                    decode_instruction_data::<ApplyPendingBalanceData>(input)?,
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            {
-                Err(ProgramError::InvalidInstructionData)
-            }
-        }
-        ConfidentialTransferInstruction::DisableConfidentialCredits => {
-            msg!("ConfidentialTransferInstruction::DisableConfidentialCredits");
-            process_allow_confidential_credits(program_id, accounts, false)
-        }
-        ConfidentialTransferInstruction::EnableConfidentialCredits => {
-            msg!("ConfidentialTransferInstruction::EnableConfidentialCredits");
-            process_allow_confidential_credits(program_id, accounts, true)
-        }
-        ConfidentialTransferInstruction::DisableNonConfidentialCredits => {
-            msg!("ConfidentialTransferInstruction::DisableNonConfidentialCredits");
-            process_allow_non_confidential_credits(program_id, accounts, false)
-        }
-        ConfidentialTransferInstruction::EnableNonConfidentialCredits => {
-            msg!("ConfidentialTransferInstruction::EnableNonConfidentialCredits");
-            process_allow_non_confidential_credits(program_id, accounts, true)
-        }
-        ConfidentialTransferInstruction::TransferWithSplitProofs => {
-            msg!("ConfidentialTransferInstruction::TransferWithSplitProofs");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data =
-                    decode_instruction_data::<TransferWithSplitProofsInstructionData>(input)?;
-                process_transfer(
-                    program_id,
-                    accounts,
-                    data.new_source_decryptable_available_balance,
-                    0,
-                    true,
-                    data.no_op_on_uninitialized_split_context_state.into(),
-                    data.close_split_context_state_on_execution.into(),
-                    &data.source_decrypt_handles,
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            Err(ProgramError::InvalidInstructionData)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/split_proof_generation.rs b/token/program-2022/src/extension/confidential_transfer/split_proof_generation.rs
deleted file mode 100644
index 9d376bb0883..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/split_proof_generation.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-//! Helper functions to generate split zero-knowledge proofs for confidential
-//! transfers in the Confidential Transfer Extension.
-//!
-//! The logic in this submodule should belong to the `solana-zk-token-sdk` and
-//! will be removed with the next upgrade to the Solana program.
-
-use crate::{
-    extension::confidential_transfer::{
-        ciphertext_extraction::{transfer_amount_source_ciphertext, SourceDecryptHandles},
-        processor::verify_and_split_deposit_amount,
-        *,
-    },
-    solana_zk_token_sdk::{
-        encryption::{
-            auth_encryption::{AeCiphertext, AeKey},
-            elgamal::{DecryptHandle, ElGamalCiphertext, ElGamalKeypair, ElGamalPubkey},
-            grouped_elgamal::GroupedElGamal,
-            pedersen::Pedersen,
-        },
-        instruction::{
-            transfer::TransferAmountCiphertext, BatchedGroupedCiphertext2HandlesValidityProofData,
-            BatchedRangeProofU128Data, CiphertextCommitmentEqualityProofData,
-        },
-        zk_token_elgamal::ops::subtract_with_lo_hi,
-    },
-};
-
-/// The main logic to create the three split proof data for a transfer.
-pub fn transfer_split_proof_data(
-    current_available_balance: &ElGamalCiphertext,
-    current_decryptable_available_balance: &AeCiphertext,
-    transfer_amount: u64,
-    source_elgamal_keypair: &ElGamalKeypair,
-    aes_key: &AeKey,
-    destination_elgamal_pubkey: &ElGamalPubkey,
-    auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-) -> Result<
-    (
-        CiphertextCommitmentEqualityProofData,
-        BatchedGroupedCiphertext2HandlesValidityProofData,
-        BatchedRangeProofU128Data,
-        SourceDecryptHandles,
-    ),
-    TokenError,
-> {
-    let default_auditor_pubkey = ElGamalPubkey::default();
-    let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-    // Split the transfer amount into the low and high bit components.
-    let (transfer_amount_lo, transfer_amount_hi) =
-        verify_and_split_deposit_amount(transfer_amount)?;
-
-    // Encrypt the `lo` and `hi` transfer amounts.
-    let (transfer_amount_grouped_ciphertext_lo, transfer_amount_opening_lo) =
-        TransferAmountCiphertext::new(
-            transfer_amount_lo,
-            source_elgamal_keypair.pubkey(),
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-        );
-
-    let (transfer_amount_grouped_ciphertext_hi, transfer_amount_opening_hi) =
-        TransferAmountCiphertext::new(
-            transfer_amount_hi,
-            source_elgamal_keypair.pubkey(),
-            destination_elgamal_pubkey,
-            auditor_elgamal_pubkey,
-        );
-
-    // Decrypt the current available balance at the source
-    let current_decrypted_available_balance = current_decryptable_available_balance
-        .decrypt(aes_key)
-        .ok_or(TokenError::AccountDecryption)?;
-
-    // Compute the remaining balance at the source
-    let new_decrypted_available_balance = current_decrypted_available_balance
-        .checked_sub(transfer_amount)
-        .ok_or(TokenError::InsufficientFunds)?;
-
-    // Create a new Pedersen commitment for the remaining balance at the source
-    let (new_available_balance_commitment, new_source_opening) =
-        Pedersen::new(new_decrypted_available_balance);
-
-    // Compute the remaining balance at the source as ElGamal ciphertexts
-    let transfer_amount_source_ciphertext_lo =
-        transfer_amount_source_ciphertext(&transfer_amount_grouped_ciphertext_lo.into());
-    let transfer_amount_source_ciphertext_hi =
-        transfer_amount_source_ciphertext(&transfer_amount_grouped_ciphertext_hi.into());
-
-    let current_available_balance = (*current_available_balance).into();
-    let new_available_balance_ciphertext = subtract_with_lo_hi(
-        &current_available_balance,
-        &transfer_amount_source_ciphertext_lo,
-        &transfer_amount_source_ciphertext_hi,
-    )
-    .ok_or(TokenError::CiphertextArithmeticFailed)?;
-    let new_available_balance_ciphertext: ElGamalCiphertext = new_available_balance_ciphertext
-        .try_into()
-        .map_err(|_| TokenError::MalformedCiphertext)?;
-
-    // generate equality proof data
-    let equality_proof_data = CiphertextCommitmentEqualityProofData::new(
-        source_elgamal_keypair,
-        &new_available_balance_ciphertext,
-        &new_available_balance_commitment,
-        &new_source_opening,
-        new_decrypted_available_balance,
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    // create source decrypt handle
-    let source_decrypt_handle_lo =
-        DecryptHandle::new(source_elgamal_keypair.pubkey(), &transfer_amount_opening_lo);
-    let source_decrypt_handle_hi =
-        DecryptHandle::new(source_elgamal_keypair.pubkey(), &transfer_amount_opening_hi);
-
-    let source_decrypt_handles = SourceDecryptHandles {
-        lo: source_decrypt_handle_lo.into(),
-        hi: source_decrypt_handle_hi.into(),
-    };
-
-    // encrypt the transfer amount under the destination and auditor ElGamal public
-    // key
-    let transfer_amount_destination_auditor_ciphertext_lo = GroupedElGamal::encrypt_with(
-        [destination_elgamal_pubkey, auditor_elgamal_pubkey],
-        transfer_amount_lo,
-        &transfer_amount_opening_lo,
-    );
-    let transfer_amount_destination_auditor_ciphertext_hi = GroupedElGamal::encrypt_with(
-        [destination_elgamal_pubkey, auditor_elgamal_pubkey],
-        transfer_amount_hi,
-        &transfer_amount_opening_hi,
-    );
-
-    // generate ciphertext validity data
-    let ciphertext_validity_proof_data = BatchedGroupedCiphertext2HandlesValidityProofData::new(
-        destination_elgamal_pubkey,
-        auditor_elgamal_pubkey,
-        &transfer_amount_destination_auditor_ciphertext_lo,
-        &transfer_amount_destination_auditor_ciphertext_hi,
-        transfer_amount_lo,
-        transfer_amount_hi,
-        &transfer_amount_opening_lo,
-        &transfer_amount_opening_hi,
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    // generate range proof data
-    const REMAINING_BALANCE_BIT_LENGTH: usize = 64;
-    const TRANSFER_AMOUNT_LO_BIT_LENGTH: usize = 16;
-    const TRANSFER_AMOUNT_HI_BIT_LENGTH: usize = 32;
-    const PADDING_BIT_LENGTH: usize = 16;
-
-    let (padding_commitment, padding_opening) = Pedersen::new(0_u64);
-
-    let range_proof_data = BatchedRangeProofU128Data::new(
-        vec![
-            &new_available_balance_commitment,
-            transfer_amount_grouped_ciphertext_lo.get_commitment(),
-            transfer_amount_grouped_ciphertext_hi.get_commitment(),
-            &padding_commitment,
-        ],
-        vec![
-            new_decrypted_available_balance,
-            transfer_amount_lo,
-            transfer_amount_hi,
-            0,
-        ],
-        vec![
-            REMAINING_BALANCE_BIT_LENGTH,
-            TRANSFER_AMOUNT_LO_BIT_LENGTH,
-            TRANSFER_AMOUNT_HI_BIT_LENGTH,
-            PADDING_BIT_LENGTH,
-        ],
-        vec![
-            &new_source_opening,
-            &transfer_amount_opening_lo,
-            &transfer_amount_opening_hi,
-            &padding_opening,
-        ],
-    )
-    .map_err(|_| TokenError::ProofGeneration)?;
-
-    Ok((
-        equality_proof_data,
-        ciphertext_validity_proof_data,
-        range_proof_data,
-        source_decrypt_handles,
-    ))
-}
diff --git a/token/program-2022/src/extension/confidential_transfer/verify_proof.rs b/token/program-2022/src/extension/confidential_transfer/verify_proof.rs
deleted file mode 100644
index 13c6001ba7b..00000000000
--- a/token/program-2022/src/extension/confidential_transfer/verify_proof.rs
+++ /dev/null
@@ -1,600 +0,0 @@
-use {
-    crate::{
-        check_system_program_account, check_zk_token_proof_program_account,
-        extension::{
-            confidential_transfer::{ciphertext_extraction::*, instruction::*, *},
-            transfer_fee::TransferFee,
-        },
-        proof::decode_proof_instruction_context,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        msg,
-        program::invoke,
-        program_error::ProgramError,
-        sysvar::instructions::get_instruction_relative,
-    },
-    solana_zk_token_sdk::zk_token_proof_instruction::{self, ContextStateInfo},
-    std::slice::Iter,
-};
-
-/// Verify zero-knowledge proof needed for a [ConfigureAccount] instruction and
-/// return the corresponding proof context.
-pub fn verify_configure_account_proof(
-    account_info_iter: &mut Iter<'_, AccountInfo<'_>>,
-    proof_instruction_offset: i64,
-) -> Result<PubkeyValidityProofContext, ProgramError> {
-    if proof_instruction_offset == 0 {
-        // interpret `account_info` as a context state account
-        let context_state_account_info = next_account_info(account_info_iter)?;
-        check_zk_token_proof_program_account(context_state_account_info.owner)?;
-        let context_state_account_data = context_state_account_info.data.borrow();
-        let context_state = pod_from_bytes::<ProofContextState<PubkeyValidityProofContext>>(
-            &context_state_account_data,
-        )?;
-
-        if context_state.proof_type != ProofType::PubkeyValidity.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        Ok(context_state.proof_context)
-    } else {
-        // interpret `account_info` as a sysvar
-        let sysvar_account_info = next_account_info(account_info_iter)?;
-        let zkp_instruction =
-            get_instruction_relative(proof_instruction_offset, sysvar_account_info)?;
-        Ok(*decode_proof_instruction_context::<
-            PubkeyValidityData,
-            PubkeyValidityProofContext,
-        >(
-            ProofInstruction::VerifyPubkeyValidity, &zkp_instruction
-        )?)
-    }
-}
-
-/// Verify zero-knowledge proof needed for a [EmptyAccount] instruction and
-/// return the corresponding proof context.
-pub fn verify_empty_account_proof(
-    account_info_iter: &mut Iter<'_, AccountInfo<'_>>,
-    proof_instruction_offset: i64,
-) -> Result<ZeroBalanceProofContext, ProgramError> {
-    if proof_instruction_offset == 0 {
-        // interpret `account_info` as a context state account
-        let context_state_account_info = next_account_info(account_info_iter)?;
-        check_zk_token_proof_program_account(context_state_account_info.owner)?;
-        let context_state_account_data = context_state_account_info.data.borrow();
-        let context_state = pod_from_bytes::<ProofContextState<ZeroBalanceProofContext>>(
-            &context_state_account_data,
-        )?;
-
-        if context_state.proof_type != ProofType::ZeroBalance.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        Ok(context_state.proof_context)
-    } else {
-        // interpret `account_info` as a sysvar
-        let sysvar_account_info = next_account_info(account_info_iter)?;
-        let zkp_instruction =
-            get_instruction_relative(proof_instruction_offset, sysvar_account_info)?;
-        Ok(*decode_proof_instruction_context::<
-            ZeroBalanceProofData,
-            ZeroBalanceProofContext,
-        >(
-            ProofInstruction::VerifyZeroBalance, &zkp_instruction
-        )?)
-    }
-}
-
-/// Verify zero-knowledge proof needed for a [Withdraw] instruction and return
-/// the corresponding proof context.
-pub fn verify_withdraw_proof(
-    account_info_iter: &mut Iter<'_, AccountInfo<'_>>,
-    proof_instruction_offset: i64,
-) -> Result<WithdrawProofContext, ProgramError> {
-    if proof_instruction_offset == 0 {
-        // interpret `account_info` as a context state account
-        let context_state_account_info = next_account_info(account_info_iter)?;
-        check_zk_token_proof_program_account(context_state_account_info.owner)?;
-        let context_state_account_data = context_state_account_info.data.borrow();
-        let context_state =
-            pod_from_bytes::<ProofContextState<WithdrawProofContext>>(&context_state_account_data)?;
-
-        if context_state.proof_type != ProofType::Withdraw.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        Ok(context_state.proof_context)
-    } else {
-        // interpret `account_info` as a sysvar
-        let sysvar_account_info = next_account_info(account_info_iter)?;
-        let zkp_instruction =
-            get_instruction_relative(proof_instruction_offset, sysvar_account_info)?;
-        Ok(*decode_proof_instruction_context::<
-            WithdrawData,
-            WithdrawProofContext,
-        >(
-            ProofInstruction::VerifyWithdraw, &zkp_instruction
-        )?)
-    }
-}
-
-/// Verify zero-knowledge proof needed for a [Transfer] instruction without fee
-/// and return the corresponding proof context.
-///
-/// This returns a `Result` type for an `Option<TransferProofContextInfo>` type.
-/// If the proof verification fails, then the function returns a suitable error
-/// variant. If the proof succeeds to verify, then the function returns a
-/// `TransferProofContextInfo` that is wrapped inside
-/// `Ok(Some(TransferProofContextInfo))`. If
-/// `no_op_on_split_proof_context_state` is `true` and some a split context
-/// state account is not initialized, then it returns `Ok(None)`.
-#[cfg(feature = "zk-ops")]
-pub fn verify_transfer_proof(
-    account_info_iter: &mut Iter<'_, AccountInfo<'_>>,
-    proof_instruction_offset: i64,
-    split_proof_context_state_accounts: bool,
-    no_op_on_split_proof_context_state: bool,
-    close_split_context_state_on_execution: bool,
-    source_decrypt_handles: &SourceDecryptHandles,
-) -> Result<Option<TransferProofContextInfo>, ProgramError> {
-    if proof_instruction_offset == 0 && split_proof_context_state_accounts {
-        let equality_proof_context_state_account_info = next_account_info(account_info_iter)?;
-        let ciphertext_validity_proof_context_state_account_info =
-            next_account_info(account_info_iter)?;
-        let range_proof_context_state_account_info = next_account_info(account_info_iter)?;
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(equality_proof_context_state_account_info.owner).is_ok()
-        {
-            msg!("Equality proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(
-                ciphertext_validity_proof_context_state_account_info.owner,
-            )
-            .is_ok()
-        {
-            msg!("Ciphertext validity proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(range_proof_context_state_account_info.owner).is_ok()
-        {
-            msg!("Range proof context state account not initialized");
-            return Ok(None);
-        }
-
-        let equality_proof_context =
-            verify_equality_proof(equality_proof_context_state_account_info)?;
-        let ciphertext_validity_proof_context =
-            verify_ciphertext_validity_proof(ciphertext_validity_proof_context_state_account_info)?;
-        let range_proof_context =
-            verify_transfer_range_proof(range_proof_context_state_account_info)?;
-
-        // The `TransferProofContextInfo` constructor verifies the consistency of the
-        // individual proof context and generates a `TransferWithFeeProofInfo` struct
-        // that is used to process the rest of the token-2022 logic.
-        let transfer_proof_context = TransferProofContextInfo::verify_and_extract(
-            &equality_proof_context,
-            &ciphertext_validity_proof_context,
-            &range_proof_context,
-            source_decrypt_handles,
-        )?;
-
-        if close_split_context_state_on_execution {
-            let lamport_destination_account_info = next_account_info(account_info_iter)?;
-            let context_state_account_authority_info = next_account_info(account_info_iter)?;
-            let _zk_token_proof_program = next_account_info(account_info_iter)?;
-
-            msg!("Closing equality proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: equality_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    equality_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing ciphertext validity proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: ciphertext_validity_proof_context_state_account_info
-                            .key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    ciphertext_validity_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing range proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: range_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    range_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-        }
-
-        Ok(Some(transfer_proof_context))
-    } else if proof_instruction_offset == 0 && !split_proof_context_state_accounts {
-        // interpret `account_info` as a context state account
-        let context_state_account_info = next_account_info(account_info_iter)?;
-        check_zk_token_proof_program_account(context_state_account_info.owner)?;
-        let context_state_account_data = context_state_account_info.data.borrow();
-        let context_state =
-            pod_from_bytes::<ProofContextState<TransferProofContext>>(&context_state_account_data)?;
-
-        if context_state.proof_type != ProofType::Transfer.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        Ok(Some(context_state.proof_context.into()))
-    } else {
-        // interpret `account_info` as sysvar
-        let sysvar_account_info = next_account_info(account_info_iter)?;
-        let zkp_instruction =
-            get_instruction_relative(proof_instruction_offset, sysvar_account_info)?;
-        let proof_context = (*decode_proof_instruction_context::<
-            TransferData,
-            TransferProofContext,
-        >(ProofInstruction::VerifyTransfer, &zkp_instruction)?)
-        .into();
-
-        Ok(Some(proof_context))
-    }
-}
-
-/// Verify zero-knowledge proof needed for a [Transfer] instruction with fee and
-/// return the corresponding proof context.
-#[cfg(feature = "zk-ops")]
-pub fn verify_transfer_with_fee_proof(
-    account_info_iter: &mut Iter<'_, AccountInfo<'_>>,
-    proof_instruction_offset: i64,
-    split_proof_context_state_accounts: bool,
-    no_op_on_split_proof_context_state: bool,
-    close_split_context_state_on_execution: bool,
-    source_decrypt_handles: &SourceDecryptHandles,
-    fee_parameters: &TransferFee,
-) -> Result<Option<TransferWithFeeProofContextInfo>, ProgramError> {
-    if proof_instruction_offset == 0 && split_proof_context_state_accounts {
-        let equality_proof_context_state_account_info = next_account_info(account_info_iter)?;
-        let transfer_amount_ciphertext_validity_proof_context_state_account_info =
-            next_account_info(account_info_iter)?;
-        let fee_sigma_proof_context_state_account_info = next_account_info(account_info_iter)?;
-        let fee_ciphertext_validity_proof_context_state_account_info =
-            next_account_info(account_info_iter)?;
-        let range_proof_context_state_account_info = next_account_info(account_info_iter)?;
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(equality_proof_context_state_account_info.owner).is_ok()
-        {
-            msg!("Equality proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(
-                transfer_amount_ciphertext_validity_proof_context_state_account_info.owner,
-            )
-            .is_ok()
-        {
-            msg!("Transfer amount ciphertext validity proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(fee_sigma_proof_context_state_account_info.owner)
-                .is_ok()
-        {
-            msg!("Fee sigma proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(
-                fee_ciphertext_validity_proof_context_state_account_info.owner,
-            )
-            .is_ok()
-        {
-            msg!("Fee ciphertext validity proof context state account not initialized");
-            return Ok(None);
-        }
-
-        if no_op_on_split_proof_context_state
-            && check_system_program_account(range_proof_context_state_account_info.owner).is_ok()
-        {
-            msg!("Range proof context state account not initialized");
-            return Ok(None);
-        }
-
-        let equality_proof_context =
-            verify_equality_proof(equality_proof_context_state_account_info)?;
-        let transfer_amount_ciphertext_validity_proof_context = verify_ciphertext_validity_proof(
-            transfer_amount_ciphertext_validity_proof_context_state_account_info,
-        )?;
-        let fee_sigma_proof_context =
-            verify_fee_sigma_proof(fee_sigma_proof_context_state_account_info)?;
-        let fee_ciphertext_validity_proof_context = verify_ciphertext_validity_proof(
-            fee_ciphertext_validity_proof_context_state_account_info,
-        )?;
-        let range_proof_context =
-            verify_transfer_with_fee_range_proof(range_proof_context_state_account_info)?;
-
-        // The `TransferWithFeeProofContextInfo` constructor verifies the consistency of
-        // the individual proof context and generates a
-        // `TransferWithFeeProofInfo` struct that is used to process the rest of
-        // the token-2022 logic. The consistency check includes verifying
-        // whether the fee-related zkps were generated with respect to the correct fee
-        // parameter that is stored in the mint extension.
-        let transfer_with_fee_proof_context = TransferWithFeeProofContextInfo::verify_and_extract(
-            &equality_proof_context,
-            &transfer_amount_ciphertext_validity_proof_context,
-            &fee_sigma_proof_context,
-            &fee_ciphertext_validity_proof_context,
-            &range_proof_context,
-            source_decrypt_handles,
-            fee_parameters,
-        )?;
-
-        if close_split_context_state_on_execution {
-            let lamport_destination_account_info = next_account_info(account_info_iter)?;
-            let context_state_account_authority_info = next_account_info(account_info_iter)?;
-            let _zk_token_proof_program = next_account_info(account_info_iter)?;
-
-            msg!("Closing equality proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: equality_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    equality_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing transfer amount ciphertext validity proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account:
-                            transfer_amount_ciphertext_validity_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    transfer_amount_ciphertext_validity_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing fee sigma proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: fee_sigma_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    fee_sigma_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing fee ciphertext validity proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account:
-                            fee_ciphertext_validity_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    fee_ciphertext_validity_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-
-            msg!("Closing range proof context state account");
-            invoke(
-                &zk_token_proof_instruction::close_context_state(
-                    ContextStateInfo {
-                        context_state_account: range_proof_context_state_account_info.key,
-                        context_state_authority: context_state_account_authority_info.key,
-                    },
-                    lamport_destination_account_info.key,
-                ),
-                &[
-                    range_proof_context_state_account_info.clone(),
-                    lamport_destination_account_info.clone(),
-                    context_state_account_authority_info.clone(),
-                ],
-            )?;
-        }
-
-        Ok(Some(transfer_with_fee_proof_context))
-    } else if proof_instruction_offset == 0 && !split_proof_context_state_accounts {
-        // interpret `account_info` as a context state account
-        let context_state_account_info = next_account_info(account_info_iter)?;
-        check_zk_token_proof_program_account(context_state_account_info.owner)?;
-        let context_state_account_data = context_state_account_info.data.borrow();
-        let context_state = pod_from_bytes::<ProofContextState<TransferWithFeeProofContext>>(
-            &context_state_account_data,
-        )?;
-
-        if context_state.proof_type != ProofType::TransferWithFee.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        let proof_tranfer_fee_basis_points: u16 = context_state
-            .proof_context
-            .fee_parameters
-            .fee_rate_basis_points
-            .into();
-        let proof_maximum_fee: u64 = context_state
-            .proof_context
-            .fee_parameters
-            .maximum_fee
-            .into();
-
-        // check consistency of the transfer fee parameters in the mint extension with
-        // what were used to generate the zkp, which is not checked in the
-        // `From<TransferWithFeeProofContext>` implementation for
-        // `TransferWithFeeProofContextInfo`.
-        if u16::from(fee_parameters.transfer_fee_basis_points) != proof_tranfer_fee_basis_points
-            || u64::from(fee_parameters.maximum_fee) != proof_maximum_fee
-        {
-            return Err(TokenError::FeeParametersMismatch.into());
-        }
-
-        Ok(Some(context_state.proof_context.into()))
-    } else {
-        // interpret `account_info` as sysvar
-        let sysvar_account_info = next_account_info(account_info_iter)?;
-        let zkp_instruction =
-            get_instruction_relative(proof_instruction_offset, sysvar_account_info)?;
-        let proof_context = decode_proof_instruction_context::<
-            TransferWithFeeData,
-            TransferWithFeeProofContext,
-        >(ProofInstruction::VerifyTransferWithFee, &zkp_instruction)?;
-
-        let proof_tranfer_fee_basis_points: u16 =
-            proof_context.fee_parameters.fee_rate_basis_points.into();
-        let proof_maximum_fee: u64 = proof_context.fee_parameters.maximum_fee.into();
-
-        // check consistency of the transfer fee parameters in the mint extension with
-        // what were used to generate the zkp, which is not checked in the
-        // `From<TransferWithFeeProofContext>` implementation for
-        // `TransferWithFeeProofContextInfo`.
-        if u16::from(fee_parameters.transfer_fee_basis_points) != proof_tranfer_fee_basis_points
-            || u64::from(fee_parameters.maximum_fee) != proof_maximum_fee
-        {
-            return Err(TokenError::FeeParametersMismatch.into());
-        }
-
-        Ok(Some((*proof_context).into()))
-    }
-}
-
-/// Verify and process equality proof for [Transfer] and [TransferWithFee]
-/// instructions.
-fn verify_equality_proof(
-    account_info: &AccountInfo<'_>,
-) -> Result<CiphertextCommitmentEqualityProofContext, ProgramError> {
-    check_zk_token_proof_program_account(account_info.owner)?;
-    let context_state_account_data = account_info.data.borrow();
-    let equality_proof_context_state = pod_from_bytes::<
-        ProofContextState<CiphertextCommitmentEqualityProofContext>,
-    >(&context_state_account_data)?;
-
-    if equality_proof_context_state.proof_type != ProofType::CiphertextCommitmentEquality.into() {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    Ok(equality_proof_context_state.proof_context)
-}
-
-/// Verify and process ciphertext validity proof for [Transfer] and
-/// [TransferWithFee] instructions.
-fn verify_ciphertext_validity_proof(
-    account_info: &AccountInfo<'_>,
-) -> Result<BatchedGroupedCiphertext2HandlesValidityProofContext, ProgramError> {
-    check_zk_token_proof_program_account(account_info.owner)?;
-    let context_state_account_data = account_info.data.borrow();
-    let ciphertext_validity_proof_context_state = pod_from_bytes::<
-        ProofContextState<BatchedGroupedCiphertext2HandlesValidityProofContext>,
-    >(&context_state_account_data)?;
-
-    if ciphertext_validity_proof_context_state.proof_type
-        != ProofType::BatchedGroupedCiphertext2HandlesValidity.into()
-    {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    Ok(ciphertext_validity_proof_context_state.proof_context)
-}
-
-/// Verify and process range proof for [Transfer] instruction.
-fn verify_transfer_range_proof(
-    account_info: &AccountInfo<'_>,
-) -> Result<BatchedRangeProofContext, ProgramError> {
-    check_zk_token_proof_program_account(account_info.owner)?;
-    let context_state_account_data = account_info.data.borrow();
-    let range_proof_context_state =
-        pod_from_bytes::<ProofContextState<BatchedRangeProofContext>>(&context_state_account_data)?;
-
-    if range_proof_context_state.proof_type != ProofType::BatchedRangeProofU128.into() {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    Ok(range_proof_context_state.proof_context)
-}
-
-/// Verify and process range proof for [Transfer] instruction with fee.
-fn verify_transfer_with_fee_range_proof(
-    account_info: &AccountInfo<'_>,
-) -> Result<BatchedRangeProofContext, ProgramError> {
-    check_zk_token_proof_program_account(account_info.owner)?;
-    let context_state_account_data = account_info.data.borrow();
-    let range_proof_context_state =
-        pod_from_bytes::<ProofContextState<BatchedRangeProofContext>>(&context_state_account_data)?;
-
-    if range_proof_context_state.proof_type != ProofType::BatchedRangeProofU256.into() {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    Ok(range_proof_context_state.proof_context)
-}
-
-/// Verify and process fee sigma proof for [TransferWithFee] instruction.
-fn verify_fee_sigma_proof(
-    account_info: &AccountInfo<'_>,
-) -> Result<FeeSigmaProofContext, ProgramError> {
-    check_zk_token_proof_program_account(account_info.owner)?;
-    let context_state_account_data = account_info.data.borrow();
-    let fee_sigma_proof_context_state =
-        pod_from_bytes::<ProofContextState<FeeSigmaProofContext>>(&context_state_account_data)?;
-
-    if fee_sigma_proof_context_state.proof_type != ProofType::FeeSigma.into() {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    Ok(fee_sigma_proof_context_state.proof_context)
-}
diff --git a/token/program-2022/src/extension/confidential_transfer_fee/account_info.rs b/token/program-2022/src/extension/confidential_transfer_fee/account_info.rs
deleted file mode 100644
index 40a8919ae9c..00000000000
--- a/token/program-2022/src/extension/confidential_transfer_fee/account_info.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use {
-    crate::{error::TokenError, extension::confidential_transfer_fee::EncryptedWithheldAmount},
-    bytemuck::{Pod, Zeroable},
-    solana_zk_token_sdk::{
-        encryption::{
-            elgamal::{ElGamalCiphertext, ElGamalKeypair, ElGamalPubkey},
-            pedersen::PedersenOpening,
-        },
-        instruction::ciphertext_ciphertext_equality::CiphertextCiphertextEqualityProofData,
-    },
-};
-
-/// Confidential transfer fee extension information needed to construct a
-/// `WithdrawWithheldTokensFromMint` or `WithdrawWithheldTokensFromAccounts`
-/// instruction.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct WithheldTokensInfo {
-    /// The available balance
-    pub(crate) withheld_amount: EncryptedWithheldAmount,
-}
-impl WithheldTokensInfo {
-    /// Create a `WithheldTokensInfo` from an ElGamal ciphertext.
-    pub fn new(withheld_amount: &EncryptedWithheldAmount) -> Self {
-        Self {
-            withheld_amount: *withheld_amount,
-        }
-    }
-
-    /// Create withdraw withheld proof data.
-    pub fn generate_proof_data(
-        &self,
-        withdraw_withheld_authority_elgamal_keypair: &ElGamalKeypair,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-    ) -> Result<CiphertextCiphertextEqualityProofData, TokenError> {
-        let withheld_amount_in_mint: ElGamalCiphertext = self
-            .withheld_amount
-            .try_into()
-            .map_err(|_| TokenError::AccountDecryption)?;
-
-        let decrypted_withheld_amount_in_mint = withheld_amount_in_mint
-            .decrypt_u32(withdraw_withheld_authority_elgamal_keypair.secret())
-            .ok_or(TokenError::AccountDecryption)?;
-
-        let destination_opening = PedersenOpening::new_rand();
-
-        let destination_ciphertext = destination_elgamal_pubkey
-            .encrypt_with(decrypted_withheld_amount_in_mint, &destination_opening);
-
-        CiphertextCiphertextEqualityProofData::new(
-            withdraw_withheld_authority_elgamal_keypair,
-            destination_elgamal_pubkey,
-            &withheld_amount_in_mint,
-            &destination_ciphertext,
-            &destination_opening,
-            decrypted_withheld_amount_in_mint,
-        )
-        .map_err(|_| TokenError::ProofGeneration)
-    }
-}
diff --git a/token/program-2022/src/extension/confidential_transfer_fee/instruction.rs b/token/program-2022/src/extension/confidential_transfer_fee/instruction.rs
deleted file mode 100644
index 12a708624cb..00000000000
--- a/token/program-2022/src/extension/confidential_transfer_fee/instruction.rs
+++ /dev/null
@@ -1,547 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use {
-    crate::serialization::{aeciphertext_fromstr, elgamalpubkey_fromstr},
-    serde::{Deserialize, Serialize},
-};
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::confidential_transfer::{
-            instruction::{
-                verify_ciphertext_ciphertext_equality, CiphertextCiphertextEqualityProofData,
-            },
-            DecryptableBalance,
-        },
-        instruction::{encode_instruction, TokenInstruction},
-        proof::ProofLocation,
-        solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        sysvar,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryFrom,
-};
-
-/// Confidential Transfer extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, TryFromPrimitive, IntoPrimitive)]
-#[repr(u8)]
-pub enum ConfidentialTransferFeeInstruction {
-    /// Initializes confidential transfer fees for a mint.
-    ///
-    /// The `ConfidentialTransferFeeInstruction::InitializeConfidentialTransferFeeConfig`
-    /// instruction requires no signers and MUST be included within the same
-    /// Transaction as `TokenInstruction::InitializeMint`. Otherwise another
-    /// party can initialize the configuration.
-    ///
-    /// The instruction fails if the `TokenInstruction::InitializeMint`
-    /// instruction has already executed for the mint.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The SPL Token mint.
-    ///
-    /// Data expected by this instruction:
-    ///   `InitializeConfidentialTransferFeeConfigData`
-    InitializeConfidentialTransferFeeConfig,
-
-    /// Transfer all withheld confidential tokens in the mint to an account.
-    /// Signed by the mint's withdraw withheld tokens authority.
-    ///
-    /// The withheld confidential tokens are aggregated directly into the
-    /// destination available balance.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by the `VerifyCiphertextCiphertextEquality` instruction
-    /// of the `zk_token_proof` program in the same transaction or the
-    /// address of a context state account for the proof must be provided.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` and `ConfidentialTransferAccount` extensions.
-    ///   2. `[]` Instructions sysvar if `VerifyCiphertextCiphertextEquality` is
-    ///      included in the same transaction or context state account if
-    ///      `VerifyCiphertextCiphertextEquality` is pre-verified into a context
-    ///      state account.
-    ///   3. `[signer]` The mint's `withdraw_withheld_authority`.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` and `ConfidentialTransferAccount` extensions.
-    ///   2. `[]` Instructions sysvar if `VerifyCiphertextCiphertextEquality` is
-    ///      included in the same transaction or context state account if
-    ///      `VerifyCiphertextCiphertextEquality` is pre-verified into a context
-    ///      state account.
-    ///   3. `[]` The mint's multisig `withdraw_withheld_authority`.
-    ///   4. ..3+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   WithdrawWithheldTokensFromMintData
-    WithdrawWithheldTokensFromMint,
-
-    /// Transfer all withheld tokens to an account. Signed by the mint's
-    /// withdraw withheld tokens authority. This instruction is susceptible
-    /// to front-running. Use `HarvestWithheldTokensToMint` and
-    /// `WithdrawWithheldTokensFromMint` as an alternative.
-    ///
-    /// The withheld confidential tokens are aggregated directly into the
-    /// destination available balance.
-    ///
-    /// Note on front-running: This instruction requires a zero-knowledge proof
-    /// verification instruction that is checked with respect to the account
-    /// state (the currently withheld fees). Suppose that a withdraw
-    /// withheld authority generates the
-    /// `WithdrawWithheldTokensFromAccounts` instruction along with a
-    /// corresponding zero-knowledge proof for a specified set of accounts,
-    /// and submits it on chain. If the withheld fees at any
-    /// of the specified accounts change before the
-    /// `WithdrawWithheldTokensFromAccounts` is executed on chain, the
-    /// zero-knowledge proof will not verify with respect to the new state,
-    /// forcing the transaction to fail.
-    ///
-    /// If front-running occurs, then users can look up the updated states of
-    /// the accounts, generate a new zero-knowledge proof and try again.
-    /// Alternatively, withdraw withheld authority can first move the
-    /// withheld amount to the mint using `HarvestWithheldTokensToMint` and
-    /// then move the withheld fees from mint to a specified destination
-    /// account using `WithdrawWithheldTokensFromMint`.
-    ///
-    /// In order for this instruction to be successfully processed, it must be
-    /// accompanied by the `VerifyWithdrawWithheldTokens` instruction of the
-    /// `zk_token_proof` program in the same transaction or the address of a
-    /// context state account for the proof must be provided.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` and `ConfidentialTransferAccount` extensions.
-    ///   2. `[]` Instructions sysvar if `VerifyCiphertextCiphertextEquality` is
-    ///      included in the same transaction or context state account if
-    ///      `VerifyCiphertextCiphertextEquality` is pre-verified into a context
-    ///      state account.
-    ///   3. `[signer]` The mint's `withdraw_withheld_authority`.
-    ///   4. ..3+N `[writable]` The source accounts to withdraw from.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` and `ConfidentialTransferAccount` extensions.
-    ///   2. `[]` Instructions sysvar if `VerifyCiphertextCiphertextEquality` is
-    ///      included in the same transaction or context state account if
-    ///      `VerifyCiphertextCiphertextEquality` is pre-verified into a context
-    ///      state account.
-    ///   3. `[]` The mint's multisig `withdraw_withheld_authority`.
-    ///   4. ..4+M `[signer]` M signer accounts.
-    ///   4+M+1. ..4+M+N `[writable]` The source accounts to withdraw from.
-    ///
-    /// Data expected by this instruction:
-    ///   WithdrawWithheldTokensFromAccountsData
-    WithdrawWithheldTokensFromAccounts,
-
-    /// Permissionless instruction to transfer all withheld confidential tokens
-    /// to the mint.
-    ///
-    /// Succeeds for frozen accounts.
-    ///
-    /// Accounts provided should include both the `TransferFeeAmount` and
-    /// `ConfidentialTransferAccount` extension. If not, the account is skipped.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint.
-    ///   1. ..1+N `[writable]` The source accounts to harvest from.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    HarvestWithheldTokensToMint,
-
-    /// Configure a confidential transfer fee mint to accept harvested
-    /// confidential fees.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The token mint.
-    ///   1. `[signer]` The confidential transfer fee authority.
-    ///
-    ///   *Multisignature owner/delegate
-    ///   0. `[writable]` The token mint.
-    ///   1. `[]` The confidential transfer fee multisig authority,
-    ///   2. `[signer]` Required M signer accounts for the SPL Token Multisig
-    ///      account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    EnableHarvestToMint,
-
-    /// Configure a confidential transfer fee mint to reject any harvested
-    /// confidential fees.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The token mint.
-    ///   1. `[signer]` The confidential transfer fee authority.
-    ///
-    ///   *Multisignature owner/delegate
-    ///   0. `[writable]` The token mint.
-    ///   1. `[]` The confidential transfer fee multisig authority,
-    ///   2. `[signer]` Required M signer accounts for the SPL Token Multisig
-    ///      account.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    DisableHarvestToMint,
-}
-
-/// Data expected by `InitializeConfidentialTransferFeeConfig`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeConfidentialTransferFeeConfigData {
-    /// confidential transfer fee authority
-    pub authority: OptionalNonZeroPubkey,
-
-    /// ElGamal public key used to encrypt withheld fees.
-    #[cfg_attr(feature = "serde-traits", serde(with = "elgamalpubkey_fromstr"))]
-    pub withdraw_withheld_authority_elgamal_pubkey: ElGamalPubkey,
-}
-
-/// Data expected by
-/// `ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromMint`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct WithdrawWithheldTokensFromMintData {
-    /// Relative location of the `ProofInstruction::VerifyWithdrawWithheld`
-    /// instruction to the `WithdrawWithheldTokensFromMint` instruction in
-    /// the transaction. If the offset is `0`, then use a context state
-    /// account for the proof.
-    pub proof_instruction_offset: i8,
-    /// The new decryptable balance in the destination token account.
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_decryptable_available_balance: DecryptableBalance,
-}
-
-/// Data expected by
-/// `ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromAccounts`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-#[repr(C)]
-pub struct WithdrawWithheldTokensFromAccountsData {
-    /// Number of token accounts harvested
-    pub num_token_accounts: u8,
-    /// Relative location of the `ProofInstruction::VerifyWithdrawWithheld`
-    /// instruction to the `VerifyWithdrawWithheldTokensFromAccounts`
-    /// instruction in the transaction. If the offset is `0`, then use a
-    /// context state account for the proof.
-    pub proof_instruction_offset: i8,
-    /// The new decryptable balance in the destination token account.
-    #[cfg_attr(feature = "serde-traits", serde(with = "aeciphertext_fromstr"))]
-    pub new_decryptable_available_balance: DecryptableBalance,
-}
-
-/// Create a `InitializeConfidentialTransferFeeConfig` instruction
-pub fn initialize_confidential_transfer_fee_config(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    withdraw_withheld_authority_elgamal_pubkey: ElGamalPubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::InitializeConfidentialTransferFeeConfig,
-        &InitializeConfidentialTransferFeeConfigData {
-            authority: authority.try_into()?,
-            withdraw_withheld_authority_elgamal_pubkey,
-        },
-    ))
-}
-
-/// Create an inner `WithdrawWithheldTokensFromMint` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-pub fn inner_withdraw_withheld_tokens_from_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    new_decryptable_available_balance: &DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<CiphertextCiphertextEqualityProofData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new(*destination, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromMint,
-        &WithdrawWithheldTokensFromMintData {
-            proof_instruction_offset,
-            new_decryptable_available_balance: *new_decryptable_available_balance,
-        },
-    ))
-}
-
-/// Create an `WithdrawWithheldTokensFromMint` instruction
-pub fn withdraw_withheld_tokens_from_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    new_decryptable_available_balance: &DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    proof_data_location: ProofLocation<CiphertextCiphertextEqualityProofData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_withdraw_withheld_tokens_from_mint(
-        token_program_id,
-        mint,
-        destination,
-        new_decryptable_available_balance,
-        authority,
-        multisig_signers,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the
-        // `WithdrawWithheldTokensFromMint` instruction. This means that the proof
-        // instruction offset must be always be 1. To use an arbitrary proof
-        // instruction offset, use the
-        // `inner_withdraw_withheld_tokens_from_mint` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_ciphertext_ciphertext_equality(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Create an inner `WithdrawWithheldTokensFromMint` instruction
-///
-/// This instruction is suitable for use with a cross-program `invoke`
-#[allow(clippy::too_many_arguments)]
-pub fn inner_withdraw_withheld_tokens_from_accounts(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    new_decryptable_available_balance: &DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    sources: &[&Pubkey],
-    proof_data_location: ProofLocation<CiphertextCiphertextEqualityProofData>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let num_token_accounts =
-        u8::try_from(sources.len()).map_err(|_| ProgramError::InvalidInstructionData)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new(*destination, false),
-    ];
-
-    let proof_instruction_offset = match proof_data_location {
-        ProofLocation::InstructionOffset(proof_instruction_offset, _) => {
-            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
-            proof_instruction_offset.into()
-        }
-        ProofLocation::ContextStateAccount(context_state_account) => {
-            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
-            0
-        }
-    };
-
-    accounts.push(AccountMeta::new_readonly(
-        *authority,
-        multisig_signers.is_empty(),
-    ));
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    for source in sources.iter() {
-        accounts.push(AccountMeta::new(**source, false));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromAccounts,
-        &WithdrawWithheldTokensFromAccountsData {
-            proof_instruction_offset,
-            num_token_accounts,
-            new_decryptable_available_balance: *new_decryptable_available_balance,
-        },
-    ))
-}
-
-/// Create a `WithdrawWithheldTokensFromAccounts` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn withdraw_withheld_tokens_from_accounts(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    new_decryptable_available_balance: &DecryptableBalance,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-    sources: &[&Pubkey],
-    proof_data_location: ProofLocation<CiphertextCiphertextEqualityProofData>,
-) -> Result<Vec<Instruction>, ProgramError> {
-    let mut instructions = vec![inner_withdraw_withheld_tokens_from_accounts(
-        token_program_id,
-        mint,
-        destination,
-        new_decryptable_available_balance,
-        authority,
-        multisig_signers,
-        sources,
-        proof_data_location,
-    )?];
-
-    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
-        proof_data_location
-    {
-        // This constructor appends the proof instruction right after the
-        // `WithdrawWithheldTokensFromAccounts` instruction. This means that the proof
-        // instruction offset must always be 1. To use an arbitrary proof
-        // instruction offset, use the
-        // `inner_withdraw_withheld_tokens_from_accounts` constructor.
-        let proof_instruction_offset: i8 = proof_instruction_offset.into();
-        if proof_instruction_offset != 1 {
-            return Err(TokenError::InvalidProofInstructionOffset.into());
-        }
-        instructions.push(verify_ciphertext_ciphertext_equality(None, proof_data));
-    };
-
-    Ok(instructions)
-}
-
-/// Creates a `HarvestWithheldTokensToMint` instruction
-pub fn harvest_withheld_tokens_to_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    sources: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![AccountMeta::new(*mint, false)];
-
-    for source in sources.iter() {
-        accounts.push(AccountMeta::new(**source, false));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::HarvestWithheldTokensToMint,
-        &(),
-    ))
-}
-
-/// Create an `EnableHarvestToMint` instruction
-pub fn enable_harvest_to_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::EnableHarvestToMint,
-        &(),
-    ))
-}
-
-/// Create a `DisableHarvestToMint` instruction
-pub fn disable_harvest_to_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    multisig_signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, multisig_signers.is_empty()),
-    ];
-
-    for multisig_signer in multisig_signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**multisig_signer, true));
-    }
-
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::ConfidentialTransferFeeExtension,
-        ConfidentialTransferFeeInstruction::DisableHarvestToMint,
-        &(),
-    ))
-}
diff --git a/token/program-2022/src/extension/confidential_transfer_fee/mod.rs b/token/program-2022/src/extension/confidential_transfer_fee/mod.rs
deleted file mode 100644
index 64576b9a720..00000000000
--- a/token/program-2022/src/extension/confidential_transfer_fee/mod.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use {
-    crate::{
-        error::TokenError,
-        extension::{Extension, ExtensionType},
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::entrypoint::ProgramResult,
-    solana_zk_token_sdk::zk_token_elgamal::pod::{ElGamalCiphertext, ElGamalPubkey, FeeEncryption},
-    spl_pod::{optional_keys::OptionalNonZeroPubkey, primitives::PodBool},
-};
-
-/// Confidential transfer fee extension instructions
-pub mod instruction;
-
-/// Confidential transfer fee extension processor
-pub mod processor;
-
-/// Confidential Transfer Fee extension account information needed for
-/// instructions
-#[cfg(not(target_os = "solana"))]
-pub mod account_info;
-
-/// ElGamal ciphertext containing a transfer fee
-pub type EncryptedFee = FeeEncryption;
-/// ElGamal ciphertext containing a withheld fee in an account
-pub type EncryptedWithheldAmount = ElGamalCiphertext;
-
-/// Confidential transfer fee extension data for mints
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ConfidentialTransferFeeConfig {
-    /// Optional authority to set the withdraw withheld authority ElGamal key
-    pub authority: OptionalNonZeroPubkey,
-
-    /// Withheld fees from accounts must be encrypted with this ElGamal key.
-    ///
-    /// Note that whoever holds the ElGamal private key for this ElGamal public
-    /// key has the ability to decode any withheld fee amount that are
-    /// associated with accounts. When combined with the fee parameters, the
-    /// withheld fee amounts can reveal information about transfer amounts.
-    pub withdraw_withheld_authority_elgamal_pubkey: ElGamalPubkey,
-
-    /// If `false`, the harvest of withheld tokens to mint is rejected.
-    pub harvest_to_mint_enabled: PodBool,
-
-    /// Withheld confidential transfer fee tokens that have been moved to the
-    /// mint for withdrawal.
-    pub withheld_amount: EncryptedWithheldAmount,
-}
-
-impl Extension for ConfidentialTransferFeeConfig {
-    const TYPE: ExtensionType = ExtensionType::ConfidentialTransferFeeConfig;
-}
-
-/// Confidential transfer fee
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct ConfidentialTransferFeeAmount {
-    /// Amount withheld during confidential transfers, to be harvest to the mint
-    pub withheld_amount: EncryptedWithheldAmount,
-}
-
-impl Extension for ConfidentialTransferFeeAmount {
-    const TYPE: ExtensionType = ExtensionType::ConfidentialTransferFeeAmount;
-}
-
-impl ConfidentialTransferFeeAmount {
-    /// Check if a confidential transfer fee account is in a closable state.
-    pub fn closable(&self) -> ProgramResult {
-        if self.withheld_amount == EncryptedWithheldAmount::zeroed() {
-            Ok(())
-        } else {
-            Err(TokenError::ConfidentialTransferFeeAccountHasWithheldFee.into())
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/confidential_transfer_fee/processor.rs b/token/program-2022/src/extension/confidential_transfer_fee/processor.rs
deleted file mode 100644
index 4fa079ec0b4..00000000000
--- a/token/program-2022/src/extension/confidential_transfer_fee/processor.rs
+++ /dev/null
@@ -1,535 +0,0 @@
-// Remove feature once zk ops syscalls are enabled on all networks
-#[cfg(feature = "zk-ops")]
-use solana_zk_token_sdk::zk_token_elgamal::ops as syscall;
-use {
-    crate::{
-        check_program_account, check_zk_token_proof_program_account,
-        error::TokenError,
-        extension::{
-            confidential_transfer::{
-                instruction::{
-                    CiphertextCiphertextEqualityProofContext,
-                    CiphertextCiphertextEqualityProofData, ProofContextState, ProofInstruction,
-                    ProofType,
-                },
-                ConfidentialTransferAccount, DecryptableBalance,
-            },
-            confidential_transfer_fee::{
-                instruction::{
-                    ConfidentialTransferFeeInstruction,
-                    InitializeConfidentialTransferFeeConfigData,
-                    WithdrawWithheldTokensFromAccountsData, WithdrawWithheldTokensFromMintData,
-                },
-                ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig,
-                EncryptedWithheldAmount,
-            },
-            transfer_fee::TransferFeeConfig,
-            BaseStateWithExtensions, BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::{PodAccount, PodMint},
-        processor::Processor,
-        proof::decode_proof_instruction_context,
-        solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-    },
-    bytemuck::Zeroable,
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        sysvar::instructions::get_instruction_relative,
-    },
-    spl_pod::{bytemuck::pod_from_bytes, optional_keys::OptionalNonZeroPubkey},
-};
-
-/// Processes an [InitializeConfidentialTransferFeeConfig] instruction.
-fn process_initialize_confidential_transfer_fee_config(
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-    let extension = mint.init_extension::<ConfidentialTransferFeeConfig>(true)?;
-    extension.authority = *authority;
-    extension.withdraw_withheld_authority_elgamal_pubkey =
-        *withdraw_withheld_authority_elgamal_pubkey;
-    extension.harvest_to_mint_enabled = true.into();
-    extension.withheld_amount = EncryptedWithheldAmount::zeroed();
-
-    Ok(())
-}
-
-/// Processes a [WithdrawWithheldTokensFromMint] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_withdraw_withheld_tokens_from_mint(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_decryptable_available_balance: &DecryptableBalance,
-    proof_instruction_offset: i64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-
-    // zero-knowledge proof certifies that the exact withheld amount is credited to
-    // the destination account.
-    let proof_context = verify_ciphertext_ciphertext_equality_proof(
-        next_account_info(account_info_iter)?,
-        proof_instruction_offset,
-    )?;
-
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    // unnecessary check, but helps for clarity
-    check_program_account(mint_account_info.owner)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-
-    // mint must be extended for fees
-    {
-        let transfer_fee_config = mint.get_extension::<TransferFeeConfig>()?;
-        let withdraw_withheld_authority =
-            Option::<Pubkey>::from(transfer_fee_config.withdraw_withheld_authority)
-                .ok_or(TokenError::NoAuthorityExists)?;
-        Processor::validate_owner(
-            program_id,
-            &withdraw_withheld_authority,
-            authority_info,
-            authority_info_data_len,
-            account_info_iter.as_slice(),
-        )?;
-    } // free `transfer_fee_config` to borrow `confidential_transfer_fee_config` as
-      // mutable
-
-    // mint must also be extended for confidential transfers, but forgo an explicit
-    // check since it is not possible to initialize a confidential transfer mint
-    // without it
-
-    let confidential_transfer_fee_config =
-        mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-
-    // basic checks for the destination account - must be extended for confidential
-    // transfers
-    let mut destination_account_data = destination_account_info.data.borrow_mut();
-    let mut destination_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-
-    if destination_account.base.mint != *mint_account_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-    if destination_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-    let destination_confidential_transfer_account =
-        destination_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    destination_confidential_transfer_account.valid_as_destination()?;
-
-    // The funds are moved from the mint to a destination account. Here, the
-    // `source` equates to the withdraw withheld authority associated in the
-    // mint.
-
-    // Check that the withdraw authority ElGamal public key associated with the mint
-    // is consistent with what was actually used to generate the zkp.
-    if proof_context.source_pubkey
-        != confidential_transfer_fee_config.withdraw_withheld_authority_elgamal_pubkey
-    {
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-    // Check that the ElGamal public key associated with the destination account is
-    // consistent with what was actually used to generate the zkp.
-    if proof_context.destination_pubkey != destination_confidential_transfer_account.elgamal_pubkey
-    {
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-    // Check that the withheld amount ciphertext is consistent with the ciphertext
-    // data that was actually used to generate the zkp.
-    if proof_context.source_ciphertext != confidential_transfer_fee_config.withheld_amount {
-        return Err(TokenError::ConfidentialTransferBalanceMismatch.into());
-    }
-
-    // The proof data contains the mint withheld amount encrypted under the
-    // destination ElGamal pubkey. Add this amount to the available balance.
-    destination_confidential_transfer_account.available_balance = syscall::add(
-        &destination_confidential_transfer_account.available_balance,
-        &proof_context.destination_ciphertext,
-    )
-    .ok_or(ProgramError::InvalidInstructionData)?;
-
-    destination_confidential_transfer_account.decryptable_available_balance =
-        *new_decryptable_available_balance;
-
-    // Fee is now withdrawn, so zero out the mint withheld amount.
-    confidential_transfer_fee_config.withheld_amount = EncryptedWithheldAmount::zeroed();
-
-    Ok(())
-}
-
-/// Verify zero-knowledge proof needed for a [WithdrawWithheldTokensFromMint]
-/// instruction or a `[WithdrawWithheldTokensFromAccounts]` and return the
-/// corresponding proof context.
-fn verify_ciphertext_ciphertext_equality_proof(
-    account_info: &AccountInfo<'_>,
-    proof_instruction_offset: i64,
-) -> Result<CiphertextCiphertextEqualityProofContext, ProgramError> {
-    if proof_instruction_offset == 0 {
-        // interpret `account_info` as a context state account
-        check_zk_token_proof_program_account(account_info.owner)?;
-        let context_state_account_data = account_info.data.borrow();
-        let context_state = pod_from_bytes::<
-            ProofContextState<CiphertextCiphertextEqualityProofContext>,
-        >(&context_state_account_data)?;
-
-        if context_state.proof_type != ProofType::CiphertextCiphertextEquality.into() {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-
-        Ok(context_state.proof_context)
-    } else {
-        // interpret `account_info` as a sysvar
-        let zkp_instruction = get_instruction_relative(proof_instruction_offset, account_info)?;
-        Ok(*decode_proof_instruction_context::<
-            CiphertextCiphertextEqualityProofData,
-            CiphertextCiphertextEqualityProofContext,
-        >(
-            ProofInstruction::VerifyCiphertextCiphertextEquality,
-            &zkp_instruction,
-        )?)
-    }
-}
-
-/// Processes a [WithdrawWithheldTokensFromAccounts] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_withdraw_withheld_tokens_from_accounts(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    num_token_accounts: u8,
-    new_decryptable_available_balance: &DecryptableBalance,
-    proof_instruction_offset: i64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-
-    // zero-knowledge proof certifies that the exact aggregate withheld amount is
-    // credited to the destination account.
-    let proof_context = verify_ciphertext_ciphertext_equality_proof(
-        next_account_info(account_info_iter)?,
-        proof_instruction_offset,
-    )?;
-
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-    let account_infos = account_info_iter.as_slice();
-    let num_signers = account_infos
-        .len()
-        .saturating_sub(num_token_accounts as usize);
-
-    // unnecessary check, but helps for clarity
-    check_program_account(mint_account_info.owner)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-
-    // mint must be extended for fees
-    let transfer_fee_config = mint.get_extension::<TransferFeeConfig>()?;
-    let withdraw_withheld_authority =
-        Option::<Pubkey>::from(transfer_fee_config.withdraw_withheld_authority)
-            .ok_or(TokenError::NoAuthorityExists)?;
-    Processor::validate_owner(
-        program_id,
-        &withdraw_withheld_authority,
-        authority_info,
-        authority_info_data_len,
-        &account_infos[..num_signers],
-    )?;
-
-    let mut destination_account_data = destination_account_info.data.borrow_mut();
-    let mut destination_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-    if destination_account.base.mint != *mint_account_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-    if destination_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-
-    // Sum up the withheld amounts in all the accounts.
-    let mut aggregate_withheld_amount = EncryptedWithheldAmount::zeroed();
-    for account_info in &account_infos[num_signers..] {
-        // self-harvest, can't double-borrow the underlying data
-        if account_info.key == destination_account_info.key {
-            let destination_confidential_transfer_fee_amount = destination_account
-                .get_extension_mut::<ConfidentialTransferFeeAmount>()
-                .map_err(|_| TokenError::InvalidState)?;
-
-            aggregate_withheld_amount = syscall::add(
-                &aggregate_withheld_amount,
-                &destination_confidential_transfer_fee_amount.withheld_amount,
-            )
-            .ok_or(ProgramError::InvalidInstructionData)?;
-
-            destination_confidential_transfer_fee_amount.withheld_amount =
-                EncryptedWithheldAmount::zeroed();
-        } else {
-            match harvest_from_account(mint_account_info.key, account_info) {
-                Ok(encrypted_withheld_amount) => {
-                    aggregate_withheld_amount =
-                        syscall::add(&aggregate_withheld_amount, &encrypted_withheld_amount)
-                            .ok_or(ProgramError::InvalidInstructionData)?;
-                }
-                Err(e) => {
-                    msg!("Error harvesting from {}: {}", account_info.key, e);
-                }
-            }
-        }
-    }
-
-    let destination_confidential_transfer_account =
-        destination_account.get_extension_mut::<ConfidentialTransferAccount>()?;
-    destination_confidential_transfer_account.valid_as_destination()?;
-
-    // The funds are moved from the accounts to a destination account. Here, the
-    // `source` equates to the withdraw withheld authority associated in the
-    // mint.
-
-    // Checks that the withdraw authority ElGamal public key associated with the
-    // mint is consistent with what was actually used to generate the zkp.
-    let confidential_transfer_fee_config =
-        mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-    if proof_context.source_pubkey
-        != confidential_transfer_fee_config.withdraw_withheld_authority_elgamal_pubkey
-    {
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-    // Checks that the ElGamal public key associated with the destination account is
-    // consistent with what was actually used to generate the zkp.
-    if proof_context.destination_pubkey != destination_confidential_transfer_account.elgamal_pubkey
-    {
-        return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
-    }
-    // Checks that the withheld amount ciphertext is consistent with the ciphertext
-    // data that was actually used to generate the zkp.
-    if proof_context.source_ciphertext != aggregate_withheld_amount {
-        return Err(TokenError::ConfidentialTransferBalanceMismatch.into());
-    }
-
-    // The proof data contains the mint withheld amount encrypted under the
-    // destination ElGamal pubkey. This amount is added to the destination
-    // available balance.
-    destination_confidential_transfer_account.available_balance = syscall::add(
-        &destination_confidential_transfer_account.available_balance,
-        &proof_context.destination_ciphertext,
-    )
-    .ok_or(ProgramError::InvalidInstructionData)?;
-
-    destination_confidential_transfer_account.decryptable_available_balance =
-        *new_decryptable_available_balance;
-
-    Ok(())
-}
-
-#[cfg(feature = "zk-ops")]
-fn harvest_from_account<'b>(
-    mint_key: &'b Pubkey,
-    token_account_info: &'b AccountInfo<'_>,
-) -> Result<EncryptedWithheldAmount, TokenError> {
-    let mut token_account_data = token_account_info.data.borrow_mut();
-    let mut token_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut token_account_data)
-            .map_err(|_| TokenError::InvalidState)?;
-    if token_account.base.mint != *mint_key {
-        return Err(TokenError::MintMismatch);
-    }
-    check_program_account(token_account_info.owner).map_err(|_| TokenError::InvalidState)?;
-
-    let confidential_transfer_token_account = token_account
-        .get_extension_mut::<ConfidentialTransferFeeAmount>()
-        .map_err(|_| TokenError::InvalidState)?;
-
-    let withheld_amount = confidential_transfer_token_account.withheld_amount;
-    confidential_transfer_token_account.withheld_amount = EncryptedWithheldAmount::zeroed();
-
-    Ok(withheld_amount)
-}
-
-/// Process a [HarvestWithheldTokensToMint] instruction.
-#[cfg(feature = "zk-ops")]
-fn process_harvest_withheld_tokens_to_mint(accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let token_account_infos = account_info_iter.as_slice();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    mint.get_extension::<TransferFeeConfig>()?;
-    let confidential_transfer_fee_mint =
-        mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-
-    let harvest_to_mint_enabled: bool = confidential_transfer_fee_mint
-        .harvest_to_mint_enabled
-        .into();
-    if !harvest_to_mint_enabled {
-        return Err(TokenError::HarvestToMintDisabled.into());
-    }
-
-    for token_account_info in token_account_infos {
-        match harvest_from_account(mint_account_info.key, token_account_info) {
-            Ok(withheld_amount) => {
-                let new_mint_withheld_amount = syscall::add(
-                    &confidential_transfer_fee_mint.withheld_amount,
-                    &withheld_amount,
-                )
-                .ok_or(ProgramError::InvalidInstructionData)?;
-
-                confidential_transfer_fee_mint.withheld_amount = new_mint_withheld_amount;
-            }
-            Err(e) => {
-                msg!("Error harvesting from {}: {}", token_account_info.key, e);
-            }
-        }
-    }
-    Ok(())
-}
-
-/// Process a [EnableHarvestToMint] instruction.
-fn process_enable_harvest_to_mint(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mut mint_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
-    let confidential_transfer_fee_mint =
-        mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-
-    let maybe_confidential_transfer_fee_authority: Option<Pubkey> =
-        confidential_transfer_fee_mint.authority.into();
-    let confidential_transfer_fee_authority =
-        maybe_confidential_transfer_fee_authority.ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &confidential_transfer_fee_authority,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    confidential_transfer_fee_mint.harvest_to_mint_enabled = true.into();
-    Ok(())
-}
-
-/// Process a [DisableHarvestToMint] instruction.
-fn process_disable_harvest_to_mint(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    check_program_account(mint_info.owner)?;
-    let mint_data = &mut mint_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
-    let confidential_transfer_fee_mint =
-        mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-
-    let maybe_confidential_transfer_fee_authority: Option<Pubkey> =
-        confidential_transfer_fee_mint.authority.into();
-    let confidential_transfer_fee_authority =
-        maybe_confidential_transfer_fee_authority.ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &confidential_transfer_fee_authority,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    confidential_transfer_fee_mint.harvest_to_mint_enabled = false.into();
-    Ok(())
-}
-
-#[allow(dead_code)]
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-
-    match decode_instruction_type(input)? {
-        ConfidentialTransferFeeInstruction::InitializeConfidentialTransferFeeConfig => {
-            msg!("ConfidentialTransferFeeInstruction::InitializeConfidentialTransferFeeConfig");
-            let data =
-                decode_instruction_data::<InitializeConfidentialTransferFeeConfigData>(input)?;
-            process_initialize_confidential_transfer_fee_config(
-                accounts,
-                &data.authority,
-                &data.withdraw_withheld_authority_elgamal_pubkey,
-            )
-        }
-        ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromMint => {
-            msg!("ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromMint");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data = decode_instruction_data::<WithdrawWithheldTokensFromMintData>(input)?;
-                process_withdraw_withheld_tokens_from_mint(
-                    program_id,
-                    accounts,
-                    &data.new_decryptable_available_balance,
-                    data.proof_instruction_offset as i64,
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            {
-                Err(ProgramError::InvalidInstructionData)
-            }
-        }
-        ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromAccounts => {
-            msg!("ConfidentialTransferFeeInstruction::WithdrawWithheldTokensFromAccounts");
-            #[cfg(feature = "zk-ops")]
-            {
-                let data =
-                    decode_instruction_data::<WithdrawWithheldTokensFromAccountsData>(input)?;
-                process_withdraw_withheld_tokens_from_accounts(
-                    program_id,
-                    accounts,
-                    data.num_token_accounts,
-                    &data.new_decryptable_available_balance,
-                    data.proof_instruction_offset as i64,
-                )
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            {
-                Err(ProgramError::InvalidInstructionData)
-            }
-        }
-        ConfidentialTransferFeeInstruction::HarvestWithheldTokensToMint => {
-            msg!("ConfidentialTransferFeeInstruction::HarvestWithheldTokensToMint");
-            #[cfg(feature = "zk-ops")]
-            {
-                process_harvest_withheld_tokens_to_mint(accounts)
-            }
-            #[cfg(not(feature = "zk-ops"))]
-            {
-                Err(ProgramError::InvalidInstructionData)
-            }
-        }
-        ConfidentialTransferFeeInstruction::EnableHarvestToMint => {
-            msg!("ConfidentialTransferFeeInstruction::EnableHarvestToMint");
-            process_enable_harvest_to_mint(program_id, accounts)
-        }
-        ConfidentialTransferFeeInstruction::DisableHarvestToMint => {
-            msg!("ConfidentialTransferFeeInstruction::DisableHarvestToMint");
-            process_disable_harvest_to_mint(program_id, accounts)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/cpi_guard/instruction.rs b/token/program-2022/src/extension/cpi_guard/instruction.rs
deleted file mode 100644
index 4474ae91122..00000000000
--- a/token/program-2022/src/extension/cpi_guard/instruction.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-};
-
-/// CPI Guard extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum CpiGuardInstruction {
-    /// Lock certain token operations from taking place within CPI for this
-    /// Account, namely:
-    /// * Transfer and Burn must go through a delegate.
-    /// * CloseAccount can only return lamports to owner.
-    /// * SetAuthority can only be used to remove an existing close authority.
-    /// * Approve is disallowed entirely.
-    ///
-    /// In addition, CPI Guard cannot be enabled or disabled via CPI.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The account to update.
-    ///   1. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The account to update.
-    ///   1. `[]` The account's multisignature owner.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    Enable,
-    /// Allow all token operations to happen via CPI as normal.
-    ///
-    /// Implicitly initializes the extension in the case where it is not
-    /// present.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The account to update.
-    ///   1. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The account to update.
-    ///   1. `[]`  The account's multisignature owner.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    Disable,
-}
-
-/// Create an `Enable` instruction
-pub fn enable_cpi_guard(
-    token_program_id: &Pubkey,
-    account: &Pubkey,
-    owner: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*account, false),
-        AccountMeta::new_readonly(*owner, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::CpiGuardExtension,
-        CpiGuardInstruction::Enable,
-        &(),
-    ))
-}
-
-/// Create a `Disable` instruction
-pub fn disable_cpi_guard(
-    token_program_id: &Pubkey,
-    account: &Pubkey,
-    owner: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*account, false),
-        AccountMeta::new_readonly(*owner, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::CpiGuardExtension,
-        CpiGuardInstruction::Disable,
-        &(),
-    ))
-}
diff --git a/token/program-2022/src/extension/cpi_guard/mod.rs b/token/program-2022/src/extension/cpi_guard/mod.rs
deleted file mode 100644
index 7af9bd71153..00000000000
--- a/token/program-2022/src/extension/cpi_guard/mod.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        extension::{BaseStateWithExtensions, Extension, ExtensionType, StateWithExtensionsMut},
-        state::Account,
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::instruction::{get_stack_height, TRANSACTION_LEVEL_STACK_HEIGHT},
-    spl_pod::primitives::PodBool,
-};
-
-/// CPI Guard extension instructions
-pub mod instruction;
-
-/// CPI Guard extension processor
-pub mod processor;
-
-/// CPI Guard extension for Accounts
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct CpiGuard {
-    /// Lock privileged token operations from happening via CPI
-    pub lock_cpi: PodBool,
-}
-impl Extension for CpiGuard {
-    const TYPE: ExtensionType = ExtensionType::CpiGuard;
-}
-
-/// Determine if CPI Guard is enabled for this account
-pub fn cpi_guard_enabled(account_state: &StateWithExtensionsMut<Account>) -> bool {
-    if let Ok(extension) = account_state.get_extension::<CpiGuard>() {
-        return extension.lock_cpi.into();
-    }
-    false
-}
-
-/// Determine if we are in CPI
-pub fn in_cpi() -> bool {
-    get_stack_height() > TRANSACTION_LEVEL_STACK_HEIGHT
-}
diff --git a/token/program-2022/src/extension/cpi_guard/processor.rs b/token/program-2022/src/extension/cpi_guard/processor.rs
deleted file mode 100644
index 8c149d659c7..00000000000
--- a/token/program-2022/src/extension/cpi_guard/processor.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            cpi_guard::{in_cpi, instruction::CpiGuardInstruction, CpiGuard},
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::decode_instruction_type,
-        pod::PodAccount,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-};
-
-/// Toggle the CpiGuard extension, initializing the extension if not already
-/// present.
-fn process_toggle_cpi_guard(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    enable: bool,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut account_data = token_account_info.data.borrow_mut();
-    let mut account = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &account.base.owner,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    if in_cpi() {
-        return Err(TokenError::CpiGuardSettingsLocked.into());
-    }
-
-    let extension = if let Ok(extension) = account.get_extension_mut::<CpiGuard>() {
-        extension
-    } else {
-        account.init_extension::<CpiGuard>(true)?
-    };
-    extension.lock_cpi = enable.into();
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-
-    match decode_instruction_type(input)? {
-        CpiGuardInstruction::Enable => {
-            msg!("CpiGuardInstruction::Enable");
-            process_toggle_cpi_guard(program_id, accounts, true /* enable */)
-        }
-        CpiGuardInstruction::Disable => {
-            msg!("CpiGuardInstruction::Disable");
-            process_toggle_cpi_guard(program_id, accounts, false /* disable */)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/default_account_state/instruction.rs b/token/program-2022/src/extension/default_account_state/instruction.rs
deleted file mode 100644
index e7d72039a1a..00000000000
--- a/token/program-2022/src/extension/default_account_state/instruction.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account, error::TokenError, instruction::TokenInstruction,
-        state::AccountState,
-    },
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    std::convert::TryFrom,
-};
-
-/// Default Account State extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum DefaultAccountStateInstruction {
-    /// Initialize a new mint with the default state for new Accounts.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::state::AccountState`
-    Initialize,
-    /// Update the default state for new Accounts. Only supported for mints that
-    /// include the `DefaultAccountState` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The mint freeze authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's multisignature freeze authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::state::AccountState`
-    Update,
-}
-
-/// Utility function for decoding a DefaultAccountState instruction and its data
-pub fn decode_instruction(
-    input: &[u8],
-) -> Result<(DefaultAccountStateInstruction, AccountState), ProgramError> {
-    if input.len() != 2 {
-        return Err(TokenError::InvalidInstruction.into());
-    }
-    Ok((
-        DefaultAccountStateInstruction::try_from(input[0])
-            .or(Err(TokenError::InvalidInstruction))?,
-        AccountState::try_from(input[1]).or(Err(TokenError::InvalidInstruction))?,
-    ))
-}
-
-fn encode_instruction(
-    token_program_id: &Pubkey,
-    accounts: Vec<AccountMeta>,
-    instruction_type: DefaultAccountStateInstruction,
-    state: &AccountState,
-) -> Instruction {
-    let mut data = TokenInstruction::DefaultAccountStateExtension.pack();
-    data.push(instruction_type.into());
-    data.push((*state).into());
-    Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize_default_account_state(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    state: &AccountState,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        DefaultAccountStateInstruction::Initialize,
-        state,
-    ))
-}
-
-/// Create an `Initialize` instruction
-pub fn update_default_account_state(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    freeze_authority: &Pubkey,
-    signers: &[&Pubkey],
-    state: &AccountState,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*freeze_authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        DefaultAccountStateInstruction::Update,
-        state,
-    ))
-}
diff --git a/token/program-2022/src/extension/default_account_state/mod.rs b/token/program-2022/src/extension/default_account_state/mod.rs
deleted file mode 100644
index 939bd16b06f..00000000000
--- a/token/program-2022/src/extension/default_account_state/mod.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-};
-
-/// Default Account state extension instructions
-pub mod instruction;
-
-/// Default Account state extension processor
-pub mod processor;
-
-/// Default Account::state extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct DefaultAccountState {
-    /// Default Account::state in which new Accounts should be initialized
-    pub state: PodAccountState,
-}
-impl Extension for DefaultAccountState {
-    const TYPE: ExtensionType = ExtensionType::DefaultAccountState;
-}
-
-type PodAccountState = u8;
diff --git a/token/program-2022/src/extension/default_account_state/processor.rs b/token/program-2022/src/extension/default_account_state/processor.rs
deleted file mode 100644
index f220f386022..00000000000
--- a/token/program-2022/src/extension/default_account_state/processor.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            default_account_state::{
-                instruction::{decode_instruction, DefaultAccountStateInstruction},
-                DefaultAccountState,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        pod::{PodCOption, PodMint},
-        processor::Processor,
-        state::AccountState,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-};
-
-fn check_valid_default_state(state: AccountState) -> ProgramResult {
-    match state {
-        AccountState::Uninitialized => Err(TokenError::InvalidState.into()),
-        _ => Ok(()),
-    }
-}
-
-fn process_initialize_default_account_state(
-    accounts: &[AccountInfo],
-    state: AccountState,
-) -> ProgramResult {
-    check_valid_default_state(state)?;
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-    let extension = mint.init_extension::<DefaultAccountState>(true)?;
-    extension.state = state.into();
-    Ok(())
-}
-
-fn process_update_default_account_state(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    state: AccountState,
-) -> ProgramResult {
-    check_valid_default_state(state)?;
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let freeze_authority_info = next_account_info(account_info_iter)?;
-    let freeze_authority_info_data_len = freeze_authority_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-
-    match &mint.base.freeze_authority {
-        PodCOption {
-            option: PodCOption::<Pubkey>::SOME,
-            value: freeze_authority,
-        } => Processor::validate_owner(
-            program_id,
-            freeze_authority,
-            freeze_authority_info,
-            freeze_authority_info_data_len,
-            account_info_iter.as_slice(),
-        ),
-        _ => Err(TokenError::NoAuthorityExists.into()),
-    }?;
-
-    let extension = mint.get_extension_mut::<DefaultAccountState>()?;
-    extension.state = state.into();
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-
-    let (instruction, state) = decode_instruction(input)?;
-    match instruction {
-        DefaultAccountStateInstruction::Initialize => {
-            msg!("DefaultAccountStateInstruction::Initialize");
-            process_initialize_default_account_state(accounts, state)
-        }
-        DefaultAccountStateInstruction::Update => {
-            msg!("DefaultAccountStateInstruction::Update");
-            process_update_default_account_state(program_id, accounts, state)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/group_member_pointer/instruction.rs b/token/program-2022/src/extension/group_member_pointer/instruction.rs
deleted file mode 100644
index c8fc28019b3..00000000000
--- a/token/program-2022/src/extension/group_member_pointer/instruction.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryInto,
-};
-
-/// Group member pointer extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum GroupMemberPointerInstruction {
-    /// Initialize a new mint with a group member pointer
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::group_member_pointer::instruction::InitializeInstructionData`
-    Initialize,
-    /// Update the group member pointer address. Only supported for mints that
-    /// include the `GroupMemberPointer` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]`   The group member pointer authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]`         The group member pointer authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::group_member_pointer::instruction::UpdateInstructionData`
-    Update,
-}
-
-/// Data expected by `Initialize`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeInstructionData {
-    /// The public key for the account that can update the group address
-    pub authority: OptionalNonZeroPubkey,
-    /// The account address that holds the member
-    pub member_address: OptionalNonZeroPubkey,
-}
-
-/// Data expected by `Update`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct UpdateInstructionData {
-    /// The new account address that holds the group
-    pub member_address: OptionalNonZeroPubkey,
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    member_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::GroupMemberPointerExtension,
-        GroupMemberPointerInstruction::Initialize,
-        &InitializeInstructionData {
-            authority: authority.try_into()?,
-            member_address: member_address.try_into()?,
-        },
-    ))
-}
-
-/// Create an `Update` instruction
-pub fn update(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    member_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::GroupMemberPointerExtension,
-        GroupMemberPointerInstruction::Update,
-        &UpdateInstructionData {
-            member_address: member_address.try_into()?,
-        },
-    ))
-}
diff --git a/token/program-2022/src/extension/group_member_pointer/mod.rs b/token/program-2022/src/extension/group_member_pointer/mod.rs
deleted file mode 100644
index ba7246965cf..00000000000
--- a/token/program-2022/src/extension/group_member_pointer/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Instructions for the GroupMemberPointer extension
-pub mod instruction;
-/// Instruction processor for the GroupMemberPointer extension
-pub mod processor;
-
-/// Group member pointer extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct GroupMemberPointer {
-    /// Authority that can set the member address
-    pub authority: OptionalNonZeroPubkey,
-    /// Account address that holds the member
-    pub member_address: OptionalNonZeroPubkey,
-}
-
-impl Extension for GroupMemberPointer {
-    const TYPE: ExtensionType = ExtensionType::GroupMemberPointer;
-}
diff --git a/token/program-2022/src/extension/group_member_pointer/processor.rs b/token/program-2022/src/extension/group_member_pointer/processor.rs
deleted file mode 100644
index 30cbab21f3e..00000000000
--- a/token/program-2022/src/extension/group_member_pointer/processor.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            group_member_pointer::{
-                instruction::{
-                    GroupMemberPointerInstruction, InitializeInstructionData, UpdateInstructionData,
-                },
-                GroupMemberPointer,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::PodMint,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    member_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-
-    if Option::<Pubkey>::from(*authority).is_none()
-        && Option::<Pubkey>::from(*member_address).is_none()
-    {
-        msg!(
-            "The group member pointer extension requires at least an authority or an address for \
-            initialization, neither was provided"
-        );
-        Err(TokenError::InvalidInstruction)?;
-    }
-
-    let extension = mint.init_extension::<GroupMemberPointer>(true)?;
-    extension.authority = *authority;
-    extension.member_address = *member_address;
-    Ok(())
-}
-
-fn process_update(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_member_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<GroupMemberPointer>()?;
-    let authority =
-        Option::<Pubkey>::from(extension.authority).ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &authority,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    extension.member_address = *new_member_address;
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-    match decode_instruction_type(input)? {
-        GroupMemberPointerInstruction::Initialize => {
-            msg!("GroupMemberPointerInstruction::Initialize");
-            let InitializeInstructionData {
-                authority,
-                member_address,
-            } = decode_instruction_data(input)?;
-            process_initialize(program_id, accounts, authority, member_address)
-        }
-        GroupMemberPointerInstruction::Update => {
-            msg!("GroupMemberPointerInstruction::Update");
-            let UpdateInstructionData { member_address } = decode_instruction_data(input)?;
-            process_update(program_id, accounts, member_address)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/group_pointer/instruction.rs b/token/program-2022/src/extension/group_pointer/instruction.rs
deleted file mode 100644
index 5fccbd9ad89..00000000000
--- a/token/program-2022/src/extension/group_pointer/instruction.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryInto,
-};
-
-/// Group pointer extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum GroupPointerInstruction {
-    /// Initialize a new mint with a group pointer
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::group_pointer::instruction::InitializeInstructionData`
-    Initialize,
-    /// Update the group pointer address. Only supported for mints that
-    /// include the `GroupPointer` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The group pointer authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's group pointer authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::group_pointer::instruction::UpdateInstructionData`
-    Update,
-}
-
-/// Data expected by `Initialize`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeInstructionData {
-    /// The public key for the account that can update the group address
-    pub authority: OptionalNonZeroPubkey,
-    /// The account address that holds the group
-    pub group_address: OptionalNonZeroPubkey,
-}
-
-/// Data expected by `Update`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct UpdateInstructionData {
-    /// The new account address that holds the group configurations
-    pub group_address: OptionalNonZeroPubkey,
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    group_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::GroupPointerExtension,
-        GroupPointerInstruction::Initialize,
-        &InitializeInstructionData {
-            authority: authority.try_into()?,
-            group_address: group_address.try_into()?,
-        },
-    ))
-}
-
-/// Create an `Update` instruction
-pub fn update(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    group_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::GroupPointerExtension,
-        GroupPointerInstruction::Update,
-        &UpdateInstructionData {
-            group_address: group_address.try_into()?,
-        },
-    ))
-}
diff --git a/token/program-2022/src/extension/group_pointer/mod.rs b/token/program-2022/src/extension/group_pointer/mod.rs
deleted file mode 100644
index 9fe2679a19e..00000000000
--- a/token/program-2022/src/extension/group_pointer/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Instructions for the GroupPointer extension
-pub mod instruction;
-/// Instruction processor for the GroupPointer extension
-pub mod processor;
-
-/// Group pointer extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct GroupPointer {
-    /// Authority that can set the group address
-    pub authority: OptionalNonZeroPubkey,
-    /// Account address that holds the group
-    pub group_address: OptionalNonZeroPubkey,
-}
-
-impl Extension for GroupPointer {
-    const TYPE: ExtensionType = ExtensionType::GroupPointer;
-}
diff --git a/token/program-2022/src/extension/group_pointer/processor.rs b/token/program-2022/src/extension/group_pointer/processor.rs
deleted file mode 100644
index 48cc42f6638..00000000000
--- a/token/program-2022/src/extension/group_pointer/processor.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            group_pointer::{
-                instruction::{
-                    GroupPointerInstruction, InitializeInstructionData, UpdateInstructionData,
-                },
-                GroupPointer,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::PodMint,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    group_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-
-    if Option::<Pubkey>::from(*authority).is_none()
-        && Option::<Pubkey>::from(*group_address).is_none()
-    {
-        msg!(
-            "The group pointer extension requires at least an authority or an address for \
-             initialization, neither was provided"
-        );
-        Err(TokenError::InvalidInstruction)?;
-    }
-
-    let extension = mint.init_extension::<GroupPointer>(true)?;
-    extension.authority = *authority;
-    extension.group_address = *group_address;
-    Ok(())
-}
-
-fn process_update(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_group_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<GroupPointer>()?;
-    let authority =
-        Option::<Pubkey>::from(extension.authority).ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &authority,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    extension.group_address = *new_group_address;
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-    match decode_instruction_type(input)? {
-        GroupPointerInstruction::Initialize => {
-            msg!("GroupPointerInstruction::Initialize");
-            let InitializeInstructionData {
-                authority,
-                group_address,
-            } = decode_instruction_data(input)?;
-            process_initialize(program_id, accounts, authority, group_address)
-        }
-        GroupPointerInstruction::Update => {
-            msg!("GroupPointerInstruction::Update");
-            let UpdateInstructionData { group_address } = decode_instruction_data(input)?;
-            process_update(program_id, accounts, group_address)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/immutable_owner.rs b/token/program-2022/src/extension/immutable_owner.rs
deleted file mode 100644
index cc323599490..00000000000
--- a/token/program-2022/src/extension/immutable_owner.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-};
-
-/// Indicates that the Account owner authority cannot be changed
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct ImmutableOwner;
-
-impl Extension for ImmutableOwner {
-    const TYPE: ExtensionType = ExtensionType::ImmutableOwner;
-}
diff --git a/token/program-2022/src/extension/interest_bearing_mint/instruction.rs b/token/program-2022/src/extension/interest_bearing_mint/instruction.rs
deleted file mode 100644
index f98ec592c27..00000000000
--- a/token/program-2022/src/extension/interest_bearing_mint/instruction.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        extension::interest_bearing_mint::BasisPoints,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryInto,
-};
-
-/// Interesting-bearing mint extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum InterestBearingMintInstruction {
-    /// Initialize a new mint with interest accrual.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::interest_bearing::instruction::InitializeInstructionData`
-    Initialize,
-    /// Update the interest rate. Only supported for mints that include the
-    /// `InterestBearingConfig` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The mint rate authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's multisignature rate authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::interest_bearing::BasisPoints`
-    UpdateRate,
-}
-
-/// Data expected by `InterestBearing::Initialize`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeInstructionData {
-    /// The public key for the account that can update the rate
-    pub rate_authority: OptionalNonZeroPubkey,
-    /// The initial interest rate
-    pub rate: BasisPoints,
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    rate_authority: Option<Pubkey>,
-    rate: i16,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::InterestBearingMintExtension,
-        InterestBearingMintInstruction::Initialize,
-        &InitializeInstructionData {
-            rate_authority: rate_authority.try_into()?,
-            rate: rate.into(),
-        },
-    ))
-}
-
-/// Create an `UpdateRate` instruction
-pub fn update_rate(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    rate_authority: &Pubkey,
-    signers: &[&Pubkey],
-    rate: i16,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*rate_authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::InterestBearingMintExtension,
-        InterestBearingMintInstruction::UpdateRate,
-        &BasisPoints::from(rate),
-    ))
-}
diff --git a/token/program-2022/src/extension/interest_bearing_mint/mod.rs b/token/program-2022/src/extension/interest_bearing_mint/mod.rs
deleted file mode 100644
index 1afb664f577..00000000000
--- a/token/program-2022/src/extension/interest_bearing_mint/mod.rs
+++ /dev/null
@@ -1,457 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    solana_program::program_error::ProgramError,
-    spl_pod::{
-        optional_keys::OptionalNonZeroPubkey,
-        primitives::{PodI16, PodI64},
-    },
-    std::convert::TryInto,
-};
-
-/// Interest-bearing mint extension instructions
-pub mod instruction;
-
-/// Interest-bearing mint extension processor
-pub mod processor;
-
-/// Annual interest rate, expressed as basis points
-pub type BasisPoints = PodI16;
-const ONE_IN_BASIS_POINTS: f64 = 10_000.;
-const SECONDS_PER_YEAR: f64 = 60. * 60. * 24. * 365.24;
-
-/// UnixTimestamp expressed with an alignment-independent type
-pub type UnixTimestamp = PodI64;
-
-/// Interest-bearing extension data for mints
-///
-/// Tokens accrue interest at an annual rate expressed by `current_rate`,
-/// compounded continuously, so APY will be higher than the published interest
-/// rate.
-///
-/// To support changing the rate, the config also maintains state for the
-/// previous rate.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct InterestBearingConfig {
-    /// Authority that can set the interest rate and authority
-    pub rate_authority: OptionalNonZeroPubkey,
-    /// Timestamp of initialization, from which to base interest calculations
-    pub initialization_timestamp: UnixTimestamp,
-    /// Average rate from initialization until the last time it was updated
-    pub pre_update_average_rate: BasisPoints,
-    /// Timestamp of the last update, used to calculate the total amount accrued
-    pub last_update_timestamp: UnixTimestamp,
-    /// Current rate, since the last update
-    pub current_rate: BasisPoints,
-}
-impl InterestBearingConfig {
-    fn pre_update_timespan(&self) -> Option<i64> {
-        i64::from(self.last_update_timestamp).checked_sub(self.initialization_timestamp.into())
-    }
-
-    fn pre_update_exp(&self) -> Option<f64> {
-        let numerator = (i16::from(self.pre_update_average_rate) as i128)
-            .checked_mul(self.pre_update_timespan()? as i128)? as f64;
-        let exponent = numerator / SECONDS_PER_YEAR / ONE_IN_BASIS_POINTS;
-        Some(exponent.exp())
-    }
-
-    fn post_update_timespan(&self, unix_timestamp: i64) -> Option<i64> {
-        unix_timestamp.checked_sub(self.last_update_timestamp.into())
-    }
-
-    fn post_update_exp(&self, unix_timestamp: i64) -> Option<f64> {
-        let numerator = (i16::from(self.current_rate) as i128)
-            .checked_mul(self.post_update_timespan(unix_timestamp)? as i128)?
-            as f64;
-        let exponent = numerator / SECONDS_PER_YEAR / ONE_IN_BASIS_POINTS;
-        Some(exponent.exp())
-    }
-
-    fn total_scale(&self, decimals: u8, unix_timestamp: i64) -> Option<f64> {
-        Some(
-            self.pre_update_exp()? * self.post_update_exp(unix_timestamp)?
-                / 10_f64.powi(decimals as i32),
-        )
-    }
-
-    /// Convert a raw amount to its UI representation using the given decimals
-    /// field Excess zeroes or unneeded decimal point are trimmed.
-    pub fn amount_to_ui_amount(
-        &self,
-        amount: u64,
-        decimals: u8,
-        unix_timestamp: i64,
-    ) -> Option<String> {
-        let scaled_amount_with_interest =
-            (amount as f64) * self.total_scale(decimals, unix_timestamp)?;
-        Some(scaled_amount_with_interest.to_string())
-    }
-
-    /// Try to convert a UI representation of a token amount to its raw amount
-    /// using the given decimals field
-    pub fn try_ui_amount_into_amount(
-        &self,
-        ui_amount: &str,
-        decimals: u8,
-        unix_timestamp: i64,
-    ) -> Result<u64, ProgramError> {
-        let scaled_amount = ui_amount
-            .parse::<f64>()
-            .map_err(|_| ProgramError::InvalidArgument)?;
-        let amount = scaled_amount
-            / self
-                .total_scale(decimals, unix_timestamp)
-                .ok_or(ProgramError::InvalidArgument)?;
-        if amount > (u64::MAX as f64) || amount < (u64::MIN as f64) || amount.is_nan() {
-            Err(ProgramError::InvalidArgument)
-        } else {
-            // this is important, if you round earlier, you'll get wrong "inf"
-            // answers
-            Ok(amount.round() as u64)
-        }
-    }
-
-    /// The new average rate is the time-weighted average of the current rate
-    /// and average rate, solving for r such that:
-    ///
-    /// exp(r_1 * t_1) * exp(r_2 * t_2) = exp(r * (t_1 + t_2))
-    ///
-    /// r_1 * t_1 + r_2 * t_2 = r * (t_1 + t_2)
-    ///
-    /// r = (r_1 * t_1 + r_2 * t_2) / (t_1 + t_2)
-    pub fn time_weighted_average_rate(&self, current_timestamp: i64) -> Option<i16> {
-        let initialization_timestamp = i64::from(self.initialization_timestamp) as i128;
-        let last_update_timestamp = i64::from(self.last_update_timestamp) as i128;
-
-        let r_1 = i16::from(self.pre_update_average_rate) as i128;
-        let t_1 = last_update_timestamp.checked_sub(initialization_timestamp)?;
-        let r_2 = i16::from(self.current_rate) as i128;
-        let t_2 = (current_timestamp as i128).checked_sub(last_update_timestamp)?;
-        let total_timespan = t_1.checked_add(t_2)?;
-        let average_rate = if total_timespan == 0 {
-            // happens in testing situations, just use the new rate since the earlier
-            // one was never practically used
-            r_2
-        } else {
-            r_1.checked_mul(t_1)?
-                .checked_add(r_2.checked_mul(t_2)?)?
-                .checked_div(total_timespan)?
-        };
-        average_rate.try_into().ok()
-    }
-}
-impl Extension for InterestBearingConfig {
-    const TYPE: ExtensionType = ExtensionType::InterestBearingConfig;
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, proptest::prelude::*};
-
-    const INT_SECONDS_PER_YEAR: i64 = 6 * 6 * 24 * 36524;
-    const TEST_DECIMALS: u8 = 2;
-
-    #[test]
-    fn seconds_per_year() {
-        assert_eq!(SECONDS_PER_YEAR, 31_556_736.);
-        assert_eq!(INT_SECONDS_PER_YEAR, 31_556_736);
-    }
-
-    #[test]
-    fn specific_amount_to_ui_amount() {
-        // constant 5%
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: 500.into(),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: 500.into(),
-        };
-        // 1 year at 5% gives a total of exp(0.05) = 1.0512710963760241
-        let ui_amount = config
-            .amount_to_ui_amount(1, 0, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(ui_amount, "1.0512710963760241");
-        // with 1 decimal place
-        let ui_amount = config
-            .amount_to_ui_amount(1, 1, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(ui_amount, "0.10512710963760241");
-        // with 10 decimal places
-        let ui_amount = config
-            .amount_to_ui_amount(1, 10, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(ui_amount, "0.00000000010512710963760242"); // different digit at the end!
-
-        // huge amount with 10 decimal places
-        let ui_amount = config
-            .amount_to_ui_amount(10_000_000_000, 10, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(ui_amount, "1.0512710963760241");
-
-        // negative
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(-500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(-500),
-        };
-        // 1 year at -5% gives a total of exp(-0.05) = 0.951229424500714
-        let ui_amount = config
-            .amount_to_ui_amount(1, 0, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(ui_amount, "0.951229424500714");
-
-        // net out
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(-500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(500),
-        };
-        // 1 year at -5% and 1 year at 5% gives a total of 1
-        let ui_amount = config
-            .amount_to_ui_amount(1, 0, INT_SECONDS_PER_YEAR * 2)
-            .unwrap();
-        assert_eq!(ui_amount, "1");
-
-        // huge values
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(500),
-        };
-        let ui_amount = config
-            .amount_to_ui_amount(u64::MAX, 0, INT_SECONDS_PER_YEAR * 2)
-            .unwrap();
-        assert_eq!(ui_amount, "20386805083448100000");
-        let ui_amount = config
-            .amount_to_ui_amount(u64::MAX, 0, INT_SECONDS_PER_YEAR * 10_000)
-            .unwrap();
-        // there's an underflow risk, but it works!
-        assert_eq!(ui_amount, "258917064265813830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
-    }
-
-    #[test]
-    fn specific_ui_amount_to_amount() {
-        // constant 5%
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: 500.into(),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: 500.into(),
-        };
-        // 1 year at 5% gives a total of exp(0.05) = 1.0512710963760241
-        let amount = config
-            .try_ui_amount_into_amount("1.0512710963760241", 0, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(1, amount);
-        // with 1 decimal place
-        let amount = config
-            .try_ui_amount_into_amount("0.10512710963760241", 1, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(amount, 1);
-        // with 10 decimal places
-        let amount = config
-            .try_ui_amount_into_amount("0.00000000010512710963760242", 10, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(amount, 1);
-
-        // huge amount with 10 decimal places
-        let amount = config
-            .try_ui_amount_into_amount("1.0512710963760241", 10, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(amount, 10_000_000_000);
-
-        // negative
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(-500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(-500),
-        };
-        // 1 year at -5% gives a total of exp(-0.05) = 0.951229424500714
-        let amount = config
-            .try_ui_amount_into_amount("0.951229424500714", 0, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(amount, 1);
-
-        // net out
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(-500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(500),
-        };
-        // 1 year at -5% and 1 year at 5% gives a total of 1
-        let amount = config
-            .try_ui_amount_into_amount("1", 0, INT_SECONDS_PER_YEAR * 2)
-            .unwrap();
-        assert_eq!(amount, 1);
-
-        // huge values
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: PodI16::from(500),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: PodI16::from(500),
-        };
-        let amount = config
-            .try_ui_amount_into_amount("20386805083448100000", 0, INT_SECONDS_PER_YEAR * 2)
-            .unwrap();
-        assert_eq!(amount, u64::MAX);
-        let amount = config
-            .try_ui_amount_into_amount("258917064265813830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0, INT_SECONDS_PER_YEAR * 10_000)
-            .unwrap();
-        assert_eq!(amount, u64::MAX);
-        // scientific notation "e"
-        let amount = config
-            .try_ui_amount_into_amount("2.5891706426581383e236", 0, INT_SECONDS_PER_YEAR * 10_000)
-            .unwrap();
-        assert_eq!(amount, u64::MAX);
-        // scientific notation "E"
-        let amount = config
-            .try_ui_amount_into_amount("2.5891706426581383E236", 0, INT_SECONDS_PER_YEAR * 10_000)
-            .unwrap();
-        assert_eq!(amount, u64::MAX);
-
-        // overflow u64 fail
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            config.try_ui_amount_into_amount("20386805083448200001", 0, INT_SECONDS_PER_YEAR)
-        );
-
-        for fail_ui_amount in ["-0.0000000000000000000001", "inf", "-inf", "NaN"] {
-            assert_eq!(
-                Err(ProgramError::InvalidArgument),
-                config.try_ui_amount_into_amount(fail_ui_amount, 0, INT_SECONDS_PER_YEAR)
-            );
-        }
-    }
-
-    #[test]
-    fn specific_amount_to_ui_amount_no_interest() {
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: 0.into(),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: 0.into(),
-        };
-        for (amount, expected) in [(23, "0.23"), (110, "1.1"), (4200, "42"), (0, "0")] {
-            let ui_amount = config
-                .amount_to_ui_amount(amount, TEST_DECIMALS, INT_SECONDS_PER_YEAR)
-                .unwrap();
-            assert_eq!(ui_amount, expected);
-        }
-    }
-
-    #[test]
-    fn specific_ui_amount_to_amount_no_interest() {
-        let config = InterestBearingConfig {
-            rate_authority: OptionalNonZeroPubkey::default(),
-            initialization_timestamp: 0.into(),
-            pre_update_average_rate: 0.into(),
-            last_update_timestamp: INT_SECONDS_PER_YEAR.into(),
-            current_rate: 0.into(),
-        };
-        for (ui_amount, expected) in [
-            ("0.23", 23),
-            ("0.20", 20),
-            ("0.2000", 20),
-            (".2", 20),
-            ("1.1", 110),
-            ("1.10", 110),
-            ("42", 4200),
-            ("42.", 4200),
-            ("0", 0),
-        ] {
-            let amount = config
-                .try_ui_amount_into_amount(ui_amount, TEST_DECIMALS, INT_SECONDS_PER_YEAR)
-                .unwrap();
-            assert_eq!(expected, amount);
-        }
-
-        // this is invalid with normal mints, but rounding for this mint makes it ok
-        let amount = config
-            .try_ui_amount_into_amount("0.111", TEST_DECIMALS, INT_SECONDS_PER_YEAR)
-            .unwrap();
-        assert_eq!(11, amount);
-
-        // fail if invalid ui_amount passed in
-        for ui_amount in ["", ".", "0.t"] {
-            assert_eq!(
-                Err(ProgramError::InvalidArgument),
-                config.try_ui_amount_into_amount(ui_amount, TEST_DECIMALS, INT_SECONDS_PER_YEAR),
-            );
-        }
-    }
-
-    prop_compose! {
-        /// Three values in ascending order
-        fn low_middle_high()
-            (middle in 1..i64::MAX - 1)
-            (low in 0..=middle, middle in Just(middle), high in middle..=i64::MAX)
-                        -> (i64, i64, i64) {
-           (low, middle, high)
-       }
-    }
-
-    proptest! {
-        #[test]
-        fn time_weighted_average_calc(
-            current_rate in i16::MIN..i16::MAX,
-            pre_update_average_rate in i16::MIN..i16::MAX,
-            (initialization_timestamp, last_update_timestamp, current_timestamp) in low_middle_high(),
-        ) {
-            let config = InterestBearingConfig {
-                rate_authority: OptionalNonZeroPubkey::default(),
-                initialization_timestamp: initialization_timestamp.into(),
-                pre_update_average_rate: pre_update_average_rate.into(),
-                last_update_timestamp: last_update_timestamp.into(),
-                current_rate: current_rate.into(),
-            };
-            let new_rate = config.time_weighted_average_rate(current_timestamp).unwrap();
-            if pre_update_average_rate <= current_rate {
-                assert!(pre_update_average_rate <= new_rate);
-                assert!(new_rate <= current_rate);
-            } else {
-                assert!(current_rate <= new_rate);
-                assert!(new_rate <= pre_update_average_rate);
-            }
-        }
-
-        #[test]
-        fn amount_to_ui_amount(
-            current_rate in i16::MIN..i16::MAX,
-            pre_update_average_rate in i16::MIN..i16::MAX,
-            (initialization_timestamp, last_update_timestamp, current_timestamp) in low_middle_high(),
-            amount in 0..=u64::MAX,
-            decimals in 0u8..20u8,
-        ) {
-            let config = InterestBearingConfig {
-                rate_authority: OptionalNonZeroPubkey::default(),
-                initialization_timestamp: initialization_timestamp.into(),
-                pre_update_average_rate: pre_update_average_rate.into(),
-                last_update_timestamp: last_update_timestamp.into(),
-                current_rate: current_rate.into(),
-            };
-            let ui_amount = config.amount_to_ui_amount(amount, decimals, current_timestamp);
-            assert!(ui_amount.is_some());
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/interest_bearing_mint/processor.rs b/token/program-2022/src/extension/interest_bearing_mint/processor.rs
deleted file mode 100644
index cf5c6c6a9b1..00000000000
--- a/token/program-2022/src/extension/interest_bearing_mint/processor.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            interest_bearing_mint::{
-                instruction::{InitializeInstructionData, InterestBearingMintInstruction},
-                BasisPoints, InterestBearingConfig,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::PodMint,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        clock::Clock,
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-        sysvar::Sysvar,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    rate_authority: &OptionalNonZeroPubkey,
-    rate: &BasisPoints,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-
-    let clock = Clock::get()?;
-    let extension = mint.init_extension::<InterestBearingConfig>(true)?;
-    extension.rate_authority = *rate_authority;
-    extension.initialization_timestamp = clock.unix_timestamp.into();
-    extension.last_update_timestamp = clock.unix_timestamp.into();
-    // There is no validation on the rate, since ridiculous values are *technically*
-    // possible!
-    extension.pre_update_average_rate = *rate;
-    extension.current_rate = *rate;
-    Ok(())
-}
-
-fn process_update_rate(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_rate: &BasisPoints,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<InterestBearingConfig>()?;
-    let rate_authority =
-        Option::<Pubkey>::from(extension.rate_authority).ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &rate_authority,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let clock = Clock::get()?;
-    let new_average_rate = extension
-        .time_weighted_average_rate(clock.unix_timestamp)
-        .ok_or(TokenError::Overflow)?;
-    extension.pre_update_average_rate = new_average_rate.into();
-    extension.last_update_timestamp = clock.unix_timestamp.into();
-    // There is no validation on the rate, since ridiculous values are *technically*
-    // possible!
-    extension.current_rate = *new_rate;
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-    match decode_instruction_type(input)? {
-        InterestBearingMintInstruction::Initialize => {
-            msg!("InterestBearingMintInstruction::Initialize");
-            let InitializeInstructionData {
-                rate_authority,
-                rate,
-            } = decode_instruction_data(input)?;
-            process_initialize(program_id, accounts, rate_authority, rate)
-        }
-        InterestBearingMintInstruction::UpdateRate => {
-            msg!("InterestBearingMintInstruction::UpdateRate");
-            let new_rate = decode_instruction_data(input)?;
-            process_update_rate(program_id, accounts, new_rate)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/memo_transfer/instruction.rs b/token/program-2022/src/extension/memo_transfer/instruction.rs
deleted file mode 100644
index 0a619a1400b..00000000000
--- a/token/program-2022/src/extension/memo_transfer/instruction.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-};
-
-/// Required Memo Transfers extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum RequiredMemoTransfersInstruction {
-    /// Require memos for transfers into this Account. Adds the MemoTransfer
-    /// extension to the Account, if it doesn't already exist.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The account to update.
-    ///   1. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The account to update.
-    ///   1. `[]` The account's multisignature owner.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    Enable,
-    /// Stop requiring memos for transfers into this Account.
-    ///
-    /// Implicitly initializes the extension in the case where it is not
-    /// present.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The account to update.
-    ///   1. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The account to update.
-    ///   1. `[]`  The account's multisignature owner.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    Disable,
-}
-
-/// Create an `Enable` instruction
-pub fn enable_required_transfer_memos(
-    token_program_id: &Pubkey,
-    account: &Pubkey,
-    owner: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*account, false),
-        AccountMeta::new_readonly(*owner, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::MemoTransferExtension,
-        RequiredMemoTransfersInstruction::Enable,
-        &(),
-    ))
-}
-
-/// Create a `Disable` instruction
-pub fn disable_required_transfer_memos(
-    token_program_id: &Pubkey,
-    account: &Pubkey,
-    owner: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*account, false),
-        AccountMeta::new_readonly(*owner, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::MemoTransferExtension,
-        RequiredMemoTransfersInstruction::Disable,
-        &(),
-    ))
-}
diff --git a/token/program-2022/src/extension/memo_transfer/mod.rs b/token/program-2022/src/extension/memo_transfer/mod.rs
deleted file mode 100644
index ab1565db568..00000000000
--- a/token/program-2022/src/extension/memo_transfer/mod.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        error::TokenError,
-        extension::{BaseState, BaseStateWithExtensions, Extension, ExtensionType},
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::{
-        instruction::get_processed_sibling_instruction, program_error::ProgramError, pubkey::Pubkey,
-    },
-    spl_pod::primitives::PodBool,
-};
-
-/// Memo Transfer extension instructions
-pub mod instruction;
-
-/// Memo Transfer extension processor
-pub mod processor;
-
-/// Memo Transfer extension for Accounts
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct MemoTransfer {
-    /// Require transfers into this account to be accompanied by a memo
-    pub require_incoming_transfer_memos: PodBool,
-}
-impl Extension for MemoTransfer {
-    const TYPE: ExtensionType = ExtensionType::MemoTransfer;
-}
-
-/// Determine if a memo is required for transfers into this account
-pub fn memo_required<BSE: BaseStateWithExtensions<S>, S: BaseState>(account_state: &BSE) -> bool {
-    if let Ok(extension) = account_state.get_extension::<MemoTransfer>() {
-        return extension.require_incoming_transfer_memos.into();
-    }
-    false
-}
-
-/// Check if the previous sibling instruction is a memo
-pub fn check_previous_sibling_instruction_is_memo() -> Result<(), ProgramError> {
-    let is_memo_program = |program_id: &Pubkey| -> bool {
-        program_id == &spl_memo::id() || program_id == &spl_memo::v1::id()
-    };
-    let previous_instruction = get_processed_sibling_instruction(0);
-    match previous_instruction {
-        Some(instruction) if is_memo_program(&instruction.program_id) => {}
-        _ => {
-            return Err(TokenError::NoMemo.into());
-        }
-    }
-    Ok(())
-}
diff --git a/token/program-2022/src/extension/memo_transfer/processor.rs b/token/program-2022/src/extension/memo_transfer/processor.rs
deleted file mode 100644
index 3e5f0c7be4a..00000000000
--- a/token/program-2022/src/extension/memo_transfer/processor.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        extension::{
-            memo_transfer::{instruction::RequiredMemoTransfersInstruction, MemoTransfer},
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::decode_instruction_type,
-        pod::PodAccount,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-};
-
-/// Toggle the RequiredMemoTransfers extension, initializing the extension if
-/// not already present.
-fn process_toggle_required_memo_transfers(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    enable: bool,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut account_data = token_account_info.data.borrow_mut();
-    let mut account = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut account_data)?;
-
-    Processor::validate_owner(
-        program_id,
-        &account.base.owner,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let extension = if let Ok(extension) = account.get_extension_mut::<MemoTransfer>() {
-        extension
-    } else {
-        account.init_extension::<MemoTransfer>(true)?
-    };
-    extension.require_incoming_transfer_memos = enable.into();
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-
-    match decode_instruction_type(input)? {
-        RequiredMemoTransfersInstruction::Enable => {
-            msg!("RequiredMemoTransfersInstruction::Enable");
-            process_toggle_required_memo_transfers(program_id, accounts, true /* enable */)
-        }
-        RequiredMemoTransfersInstruction::Disable => {
-            msg!("RequiredMemoTransfersInstruction::Disable");
-            process_toggle_required_memo_transfers(program_id, accounts, false /* disable */)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/metadata_pointer/instruction.rs b/token/program-2022/src/extension/metadata_pointer/instruction.rs
deleted file mode 100644
index 778c7dddb38..00000000000
--- a/token/program-2022/src/extension/metadata_pointer/instruction.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryInto,
-};
-
-/// Metadata pointer extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum MetadataPointerInstruction {
-    /// Initialize a new mint with a metadata pointer
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::metadata_pointer::instruction::InitializeInstructionData`
-    Initialize,
-    /// Update the metadata pointer address. Only supported for mints that
-    /// include the `MetadataPointer` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The metadata pointer authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's metadata pointer authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::metadata_pointer::instruction::UpdateInstructionData`
-    Update,
-}
-
-/// Data expected by `Initialize`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeInstructionData {
-    /// The public key for the account that can update the metadata address
-    pub authority: OptionalNonZeroPubkey,
-    /// The account address that holds the metadata
-    pub metadata_address: OptionalNonZeroPubkey,
-}
-
-/// Data expected by `Update`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct UpdateInstructionData {
-    /// The new account address that holds the metadata
-    pub metadata_address: OptionalNonZeroPubkey,
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    metadata_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::MetadataPointerExtension,
-        MetadataPointerInstruction::Initialize,
-        &InitializeInstructionData {
-            authority: authority.try_into()?,
-            metadata_address: metadata_address.try_into()?,
-        },
-    ))
-}
-
-/// Create an `Update` instruction
-pub fn update(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    metadata_address: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::MetadataPointerExtension,
-        MetadataPointerInstruction::Update,
-        &UpdateInstructionData {
-            metadata_address: metadata_address.try_into()?,
-        },
-    ))
-}
diff --git a/token/program-2022/src/extension/metadata_pointer/mod.rs b/token/program-2022/src/extension/metadata_pointer/mod.rs
deleted file mode 100644
index c14932d5000..00000000000
--- a/token/program-2022/src/extension/metadata_pointer/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Instructions for the MetadataPointer extension
-pub mod instruction;
-/// Instruction processor for the MetadataPointer extension
-pub mod processor;
-
-/// Metadata pointer extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct MetadataPointer {
-    /// Authority that can set the metadata address
-    pub authority: OptionalNonZeroPubkey,
-    /// Account address that holds the metadata
-    pub metadata_address: OptionalNonZeroPubkey,
-}
-
-impl Extension for MetadataPointer {
-    const TYPE: ExtensionType = ExtensionType::MetadataPointer;
-}
diff --git a/token/program-2022/src/extension/metadata_pointer/processor.rs b/token/program-2022/src/extension/metadata_pointer/processor.rs
deleted file mode 100644
index 23350372fdf..00000000000
--- a/token/program-2022/src/extension/metadata_pointer/processor.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            metadata_pointer::{
-                instruction::{
-                    InitializeInstructionData, MetadataPointerInstruction, UpdateInstructionData,
-                },
-                MetadataPointer,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::PodMint,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    metadata_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-
-    let extension = mint.init_extension::<MetadataPointer>(true)?;
-    extension.authority = *authority;
-
-    if Option::<Pubkey>::from(*authority).is_none()
-        && Option::<Pubkey>::from(*metadata_address).is_none()
-    {
-        msg!("The metadata pointer extension requires at least an authority or an address for initialization, neither was provided");
-        Err(TokenError::InvalidInstruction)?;
-    }
-    extension.metadata_address = *metadata_address;
-    Ok(())
-}
-
-fn process_update(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_metadata_address: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<MetadataPointer>()?;
-    let authority =
-        Option::<Pubkey>::from(extension.authority).ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &authority,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    extension.metadata_address = *new_metadata_address;
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-    match decode_instruction_type(input)? {
-        MetadataPointerInstruction::Initialize => {
-            msg!("MetadataPointerInstruction::Initialize");
-            let InitializeInstructionData {
-                authority,
-                metadata_address,
-            } = decode_instruction_data(input)?;
-            process_initialize(program_id, accounts, authority, metadata_address)
-        }
-        MetadataPointerInstruction::Update => {
-            msg!("MetadataPointerInstruction::Update");
-            let UpdateInstructionData { metadata_address } = decode_instruction_data(input)?;
-            process_update(program_id, accounts, metadata_address)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/mint_close_authority.rs b/token/program-2022/src/extension/mint_close_authority.rs
deleted file mode 100644
index 7321b7f6004..00000000000
--- a/token/program-2022/src/extension/mint_close_authority.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Close authority extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct MintCloseAuthority {
-    /// Optional authority to close the mint
-    pub close_authority: OptionalNonZeroPubkey,
-}
-impl Extension for MintCloseAuthority {
-    const TYPE: ExtensionType = ExtensionType::MintCloseAuthority;
-}
diff --git a/token/program-2022/src/extension/mod.rs b/token/program-2022/src/extension/mod.rs
deleted file mode 100644
index 3fefd993ca0..00000000000
--- a/token/program-2022/src/extension/mod.rs
+++ /dev/null
@@ -1,2955 +0,0 @@
-//! Extensions available to token mints and accounts
-
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        error::TokenError,
-        extension::{
-            confidential_transfer::{ConfidentialTransferAccount, ConfidentialTransferMint},
-            confidential_transfer_fee::{
-                ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig,
-            },
-            cpi_guard::CpiGuard,
-            default_account_state::DefaultAccountState,
-            group_member_pointer::GroupMemberPointer,
-            group_pointer::GroupPointer,
-            immutable_owner::ImmutableOwner,
-            interest_bearing_mint::InterestBearingConfig,
-            memo_transfer::MemoTransfer,
-            metadata_pointer::MetadataPointer,
-            mint_close_authority::MintCloseAuthority,
-            non_transferable::{NonTransferable, NonTransferableAccount},
-            permanent_delegate::PermanentDelegate,
-            transfer_fee::{TransferFeeAmount, TransferFeeConfig},
-            transfer_hook::{TransferHook, TransferHookAccount},
-        },
-        pod::{PodAccount, PodMint},
-        state::{Account, Mint, Multisig, PackedSizeOf},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        account_info::AccountInfo,
-        program_error::ProgramError,
-        program_pack::{IsInitialized, Pack},
-    },
-    spl_pod::{
-        bytemuck::{pod_from_bytes, pod_from_bytes_mut, pod_get_packed_len},
-        primitives::PodU16,
-    },
-    spl_token_group_interface::state::{TokenGroup, TokenGroupMember},
-    spl_type_length_value::variable_len_pack::VariableLenPack,
-    std::{
-        cmp::Ordering,
-        convert::{TryFrom, TryInto},
-        mem::size_of,
-    },
-};
-
-/// Confidential Transfer extension
-pub mod confidential_transfer;
-/// Confidential Transfer Fee extension
-pub mod confidential_transfer_fee;
-/// CPI Guard extension
-pub mod cpi_guard;
-/// Default Account State extension
-pub mod default_account_state;
-/// Group Member Pointer extension
-pub mod group_member_pointer;
-/// Group Pointer extension
-pub mod group_pointer;
-/// Immutable Owner extension
-pub mod immutable_owner;
-/// Interest-Bearing Mint extension
-pub mod interest_bearing_mint;
-/// Memo Transfer extension
-pub mod memo_transfer;
-/// Metadata Pointer extension
-pub mod metadata_pointer;
-/// Mint Close Authority extension
-pub mod mint_close_authority;
-/// Non Transferable extension
-pub mod non_transferable;
-/// Permanent Delegate extension
-pub mod permanent_delegate;
-/// Utility to reallocate token accounts
-pub mod reallocate;
-/// Token-group extension
-pub mod token_group;
-/// Token-metadata extension
-pub mod token_metadata;
-/// Transfer Fee extension
-pub mod transfer_fee;
-/// Transfer Hook extension
-pub mod transfer_hook;
-
-/// Length in TLV structure
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct Length(PodU16);
-impl From<Length> for usize {
-    fn from(n: Length) -> Self {
-        Self::from(u16::from(n.0))
-    }
-}
-impl TryFrom<usize> for Length {
-    type Error = ProgramError;
-    fn try_from(n: usize) -> Result<Self, Self::Error> {
-        u16::try_from(n)
-            .map(|v| Self(PodU16::from(v)))
-            .map_err(|_| ProgramError::AccountDataTooSmall)
-    }
-}
-
-/// Helper function to get the current TlvIndices from the current spot
-fn get_tlv_indices(type_start: usize) -> TlvIndices {
-    let length_start = type_start.saturating_add(size_of::<ExtensionType>());
-    let value_start = length_start.saturating_add(pod_get_packed_len::<Length>());
-    TlvIndices {
-        type_start,
-        length_start,
-        value_start,
-    }
-}
-
-/// Helper function to tack on the size of an extension bytes if an account with
-/// extensions is exactly the size of a multisig
-const fn adjust_len_for_multisig(account_len: usize) -> usize {
-    if account_len == Multisig::LEN {
-        account_len.saturating_add(size_of::<ExtensionType>())
-    } else {
-        account_len
-    }
-}
-
-/// Helper function to calculate exactly how many bytes a value will take up,
-/// given the value's length
-const fn add_type_and_length_to_len(value_len: usize) -> usize {
-    value_len
-        .saturating_add(size_of::<ExtensionType>())
-        .saturating_add(pod_get_packed_len::<Length>())
-}
-
-/// Helper struct for returning the indices of the type, length, and value in
-/// a TLV entry
-#[derive(Debug)]
-struct TlvIndices {
-    pub type_start: usize,
-    pub length_start: usize,
-    pub value_start: usize,
-}
-fn get_extension_indices<V: Extension>(
-    tlv_data: &[u8],
-    init: bool,
-) -> Result<TlvIndices, ProgramError> {
-    let mut start_index = 0;
-    let v_account_type = V::TYPE.get_account_type();
-    while start_index < tlv_data.len() {
-        let tlv_indices = get_tlv_indices(start_index);
-        if tlv_data.len() < tlv_indices.value_start {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        let extension_type =
-            ExtensionType::try_from(&tlv_data[tlv_indices.type_start..tlv_indices.length_start])?;
-        let account_type = extension_type.get_account_type();
-        if extension_type == V::TYPE {
-            // found an instance of the extension that we're initializing, return!
-            return Ok(tlv_indices);
-        // got to an empty spot, init here, or error if we're searching, since
-        // nothing is written after an Uninitialized spot
-        } else if extension_type == ExtensionType::Uninitialized {
-            if init {
-                return Ok(tlv_indices);
-            } else {
-                return Err(TokenError::ExtensionNotFound.into());
-            }
-        } else if v_account_type != account_type {
-            return Err(TokenError::ExtensionTypeMismatch.into());
-        } else {
-            let length = pod_from_bytes::<Length>(
-                &tlv_data[tlv_indices.length_start..tlv_indices.value_start],
-            )?;
-            let value_end_index = tlv_indices.value_start.saturating_add(usize::from(*length));
-            start_index = value_end_index;
-        }
-    }
-    Err(ProgramError::InvalidAccountData)
-}
-
-/// Basic information about the TLV buffer, collected from iterating through all
-/// entries
-#[derive(Debug, PartialEq)]
-struct TlvDataInfo {
-    /// The extension types written in the TLV buffer
-    extension_types: Vec<ExtensionType>,
-    /// The total number bytes allocated for all TLV entries.
-    ///
-    /// Each TLV entry's allocated bytes comprises two bytes for the `type`, two
-    /// bytes for the `length`, and `length` number of bytes for the `value`.
-    used_len: usize,
-}
-
-/// Fetches basic information about the TLV buffer by iterating through all
-/// TLV entries.
-fn get_tlv_data_info(tlv_data: &[u8]) -> Result<TlvDataInfo, ProgramError> {
-    let mut extension_types = vec![];
-    let mut start_index = 0;
-    while start_index < tlv_data.len() {
-        let tlv_indices = get_tlv_indices(start_index);
-        if tlv_data.len() < tlv_indices.length_start {
-            // There aren't enough bytes to store the next type, which means we
-            // got to the end. The last byte could be used during a realloc!
-            return Ok(TlvDataInfo {
-                extension_types,
-                used_len: tlv_indices.type_start,
-            });
-        }
-        let extension_type =
-            ExtensionType::try_from(&tlv_data[tlv_indices.type_start..tlv_indices.length_start])?;
-        if extension_type == ExtensionType::Uninitialized {
-            return Ok(TlvDataInfo {
-                extension_types,
-                used_len: tlv_indices.type_start,
-            });
-        } else {
-            if tlv_data.len() < tlv_indices.value_start {
-                // not enough bytes to store the length, malformed
-                return Err(ProgramError::InvalidAccountData);
-            }
-            extension_types.push(extension_type);
-            let length = pod_from_bytes::<Length>(
-                &tlv_data[tlv_indices.length_start..tlv_indices.value_start],
-            )?;
-
-            let value_end_index = tlv_indices.value_start.saturating_add(usize::from(*length));
-            if value_end_index > tlv_data.len() {
-                // value blows past the size of the slice, malformed
-                return Err(ProgramError::InvalidAccountData);
-            }
-            start_index = value_end_index;
-        }
-    }
-    Ok(TlvDataInfo {
-        extension_types,
-        used_len: start_index,
-    })
-}
-
-fn get_first_extension_type(tlv_data: &[u8]) -> Result<Option<ExtensionType>, ProgramError> {
-    if tlv_data.is_empty() {
-        Ok(None)
-    } else {
-        let tlv_indices = get_tlv_indices(0);
-        if tlv_data.len() <= tlv_indices.length_start {
-            return Ok(None);
-        }
-        let extension_type =
-            ExtensionType::try_from(&tlv_data[tlv_indices.type_start..tlv_indices.length_start])?;
-        if extension_type == ExtensionType::Uninitialized {
-            Ok(None)
-        } else {
-            Ok(Some(extension_type))
-        }
-    }
-}
-
-fn check_min_len_and_not_multisig(input: &[u8], minimum_len: usize) -> Result<(), ProgramError> {
-    if input.len() == Multisig::LEN || input.len() < minimum_len {
-        Err(ProgramError::InvalidAccountData)
-    } else {
-        Ok(())
-    }
-}
-
-fn check_account_type<S: BaseState>(account_type: AccountType) -> Result<(), ProgramError> {
-    if account_type != S::ACCOUNT_TYPE {
-        Err(ProgramError::InvalidAccountData)
-    } else {
-        Ok(())
-    }
-}
-
-/// Any account with extensions must be at least `Account::LEN`.  Both mints and
-/// accounts can have extensions
-/// A mint with extensions that takes it past 165 could be indiscernible from an
-/// Account with an extension, even if we add the account type. For example,
-/// let's say we have:
-///
-/// Account: 165 bytes... + [2, 0, 3, 0, 100, ....]
-///                          ^     ^       ^     ^
-///                     acct type  extension length data...
-///
-/// Mint: 82 bytes... + 83 bytes of other extension data
-///     + [2, 0, 3, 0, 100, ....]
-///      (data in extension just happens to look like this)
-///
-/// With this approach, we only start writing the TLV data after Account::LEN,
-/// which means we always know that the account type is going to be right after
-/// that. We do a special case checking for a Multisig length, because those
-/// aren't extensible under any circumstances.
-const BASE_ACCOUNT_LENGTH: usize = Account::LEN;
-/// Helper that tacks on the AccountType length, which gives the minimum for any
-/// account with extensions
-const BASE_ACCOUNT_AND_TYPE_LENGTH: usize = BASE_ACCOUNT_LENGTH + size_of::<AccountType>();
-
-fn type_and_tlv_indices<S: BaseState>(
-    rest_input: &[u8],
-) -> Result<Option<(usize, usize)>, ProgramError> {
-    if rest_input.is_empty() {
-        Ok(None)
-    } else {
-        let account_type_index = BASE_ACCOUNT_LENGTH.saturating_sub(S::SIZE_OF);
-        // check padding is all zeroes
-        let tlv_start_index = account_type_index.saturating_add(size_of::<AccountType>());
-        if rest_input.len() <= tlv_start_index {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        if rest_input[..account_type_index] != vec![0; account_type_index] {
-            Err(ProgramError::InvalidAccountData)
-        } else {
-            Ok(Some((account_type_index, tlv_start_index)))
-        }
-    }
-}
-
-/// Checks a base buffer to verify if it is an Account without having to
-/// completely deserialize it
-fn is_initialized_account(input: &[u8]) -> Result<bool, ProgramError> {
-    const ACCOUNT_INITIALIZED_INDEX: usize = 108; // See state.rs#L99
-
-    if input.len() != BASE_ACCOUNT_LENGTH {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    Ok(input[ACCOUNT_INITIALIZED_INDEX] != 0)
-}
-
-fn get_extension_bytes<S: BaseState, V: Extension>(tlv_data: &[u8]) -> Result<&[u8], ProgramError> {
-    if V::TYPE.get_account_type() != S::ACCOUNT_TYPE {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    let TlvIndices {
-        type_start: _,
-        length_start,
-        value_start,
-    } = get_extension_indices::<V>(tlv_data, false)?;
-    // get_extension_indices has checked that tlv_data is long enough to include
-    // these indices
-    let length = pod_from_bytes::<Length>(&tlv_data[length_start..value_start])?;
-    let value_end = value_start.saturating_add(usize::from(*length));
-    if tlv_data.len() < value_end {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    Ok(&tlv_data[value_start..value_end])
-}
-
-fn get_extension_bytes_mut<S: BaseState, V: Extension>(
-    tlv_data: &mut [u8],
-) -> Result<&mut [u8], ProgramError> {
-    if V::TYPE.get_account_type() != S::ACCOUNT_TYPE {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    let TlvIndices {
-        type_start: _,
-        length_start,
-        value_start,
-    } = get_extension_indices::<V>(tlv_data, false)?;
-    // get_extension_indices has checked that tlv_data is long enough to include
-    // these indices
-    let length = pod_from_bytes::<Length>(&tlv_data[length_start..value_start])?;
-    let value_end = value_start.saturating_add(usize::from(*length));
-    if tlv_data.len() < value_end {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    Ok(&mut tlv_data[value_start..value_end])
-}
-
-/// Calculate the new expected size if the state allocates the given number
-/// of bytes for the given extension type.
-///
-/// Provides the correct answer regardless if the extension is already present
-/// in the TLV data.
-fn try_get_new_account_len_for_extension_len<S: BaseState, V: Extension>(
-    tlv_data: &[u8],
-    new_extension_len: usize,
-) -> Result<usize, ProgramError> {
-    // get the new length used by the extension
-    let new_extension_tlv_len = add_type_and_length_to_len(new_extension_len);
-    let tlv_info = get_tlv_data_info(tlv_data)?;
-    // If we're adding an extension, then we must have at least BASE_ACCOUNT_LENGTH
-    // and account type
-    let current_len = tlv_info
-        .used_len
-        .saturating_add(BASE_ACCOUNT_AND_TYPE_LENGTH);
-    // get the current length used by the extension
-    let current_extension_len = get_extension_bytes::<S, V>(tlv_data)
-        .map(|x| add_type_and_length_to_len(x.len()))
-        .unwrap_or(0);
-    let new_len = current_len
-        .saturating_sub(current_extension_len)
-        .saturating_add(new_extension_tlv_len);
-    Ok(adjust_len_for_multisig(new_len))
-}
-
-/// Trait for base state with extension
-pub trait BaseStateWithExtensions<S: BaseState> {
-    /// Get the buffer containing all extension data
-    fn get_tlv_data(&self) -> &[u8];
-
-    /// Fetch the bytes for a TLV entry
-    fn get_extension_bytes<V: Extension>(&self) -> Result<&[u8], ProgramError> {
-        get_extension_bytes::<S, V>(self.get_tlv_data())
-    }
-
-    /// Unpack a portion of the TLV data as the desired type
-    fn get_extension<V: Extension + Pod>(&self) -> Result<&V, ProgramError> {
-        pod_from_bytes::<V>(self.get_extension_bytes::<V>()?)
-    }
-
-    /// Unpacks a portion of the TLV data as the desired variable-length type
-    fn get_variable_len_extension<V: Extension + VariableLenPack>(
-        &self,
-    ) -> Result<V, ProgramError> {
-        let data = get_extension_bytes::<S, V>(self.get_tlv_data())?;
-        V::unpack_from_slice(data)
-    }
-
-    /// Iterates through the TLV entries, returning only the types
-    fn get_extension_types(&self) -> Result<Vec<ExtensionType>, ProgramError> {
-        get_tlv_data_info(self.get_tlv_data()).map(|x| x.extension_types)
-    }
-
-    /// Get just the first extension type, useful to track mixed initializations
-    fn get_first_extension_type(&self) -> Result<Option<ExtensionType>, ProgramError> {
-        get_first_extension_type(self.get_tlv_data())
-    }
-
-    /// Get the total number of bytes used by TLV entries and the base type
-    fn try_get_account_len(&self) -> Result<usize, ProgramError> {
-        let tlv_info = get_tlv_data_info(self.get_tlv_data())?;
-        if tlv_info.extension_types.is_empty() {
-            Ok(S::SIZE_OF)
-        } else {
-            let total_len = tlv_info
-                .used_len
-                .saturating_add(BASE_ACCOUNT_AND_TYPE_LENGTH);
-            Ok(adjust_len_for_multisig(total_len))
-        }
-    }
-    /// Calculate the new expected size if the state allocates the given
-    /// fixed-length extension instance.
-    /// If the state already has the extension, the resulting account length
-    /// will be unchanged.
-    fn try_get_new_account_len<V: Extension + Pod>(&self) -> Result<usize, ProgramError> {
-        try_get_new_account_len_for_extension_len::<S, V>(
-            self.get_tlv_data(),
-            pod_get_packed_len::<V>(),
-        )
-    }
-
-    /// Calculate the new expected size if the state allocates the given
-    /// variable-length extension instance.
-    fn try_get_new_account_len_for_variable_len_extension<V: Extension + VariableLenPack>(
-        &self,
-        new_extension: &V,
-    ) -> Result<usize, ProgramError> {
-        try_get_new_account_len_for_extension_len::<S, V>(
-            self.get_tlv_data(),
-            new_extension.get_packed_len()?,
-        )
-    }
-}
-
-/// Encapsulates owned immutable base state data (mint or account) with possible
-/// extensions
-#[derive(Clone, Debug, PartialEq)]
-pub struct StateWithExtensionsOwned<S: BaseState> {
-    /// Unpacked base data
-    pub base: S,
-    /// Raw TLV data, deserialized on demand
-    tlv_data: Vec<u8>,
-}
-impl<S: BaseState + Pack> StateWithExtensionsOwned<S> {
-    /// Unpack base state, leaving the extension data as a slice
-    ///
-    /// Fails if the base state is not initialized.
-    pub fn unpack(mut input: Vec<u8>) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(&input, S::SIZE_OF)?;
-        let mut rest = input.split_off(S::SIZE_OF);
-        let base = S::unpack(&input)?;
-        if let Some((account_type_index, tlv_start_index)) = type_and_tlv_indices::<S>(&rest)? {
-            // type_and_tlv_indices() checks that returned indexes are within range
-            let account_type = AccountType::try_from(rest[account_type_index])
-                .map_err(|_| ProgramError::InvalidAccountData)?;
-            check_account_type::<S>(account_type)?;
-            let tlv_data = rest.split_off(tlv_start_index);
-            Ok(Self { base, tlv_data })
-        } else {
-            Ok(Self {
-                base,
-                tlv_data: vec![],
-            })
-        }
-    }
-}
-
-impl<S: BaseState> BaseStateWithExtensions<S> for StateWithExtensionsOwned<S> {
-    fn get_tlv_data(&self) -> &[u8] {
-        &self.tlv_data
-    }
-}
-
-/// Encapsulates immutable base state data (mint or account) with possible
-/// extensions
-#[derive(Debug, PartialEq)]
-pub struct StateWithExtensions<'data, S: BaseState + Pack> {
-    /// Unpacked base data
-    pub base: S,
-    /// Slice of data containing all TLV data, deserialized on demand
-    tlv_data: &'data [u8],
-}
-impl<'data, S: BaseState + Pack> StateWithExtensions<'data, S> {
-    /// Unpack base state, leaving the extension data as a slice
-    ///
-    /// Fails if the base state is not initialized.
-    pub fn unpack(input: &'data [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at(S::SIZE_OF);
-        let base = S::unpack(base_data)?;
-        let tlv_data = unpack_tlv_data::<S>(rest)?;
-        Ok(Self { base, tlv_data })
-    }
-}
-impl<'a, S: BaseState + Pack> BaseStateWithExtensions<S> for StateWithExtensions<'a, S> {
-    fn get_tlv_data(&self) -> &[u8] {
-        self.tlv_data
-    }
-}
-
-/// Encapsulates immutable base state data (mint or account) with possible
-/// extensions, where the base state is Pod for zero-copy serde.
-#[derive(Debug, PartialEq)]
-pub struct PodStateWithExtensions<'data, S: BaseState + Pod> {
-    /// Unpacked base data
-    pub base: &'data S,
-    /// Slice of data containing all TLV data, deserialized on demand
-    tlv_data: &'data [u8],
-}
-impl<'data, S: BaseState + Pod> PodStateWithExtensions<'data, S> {
-    /// Unpack base state, leaving the extension data as a slice
-    ///
-    /// Fails if the base state is not initialized.
-    pub fn unpack(input: &'data [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at(S::SIZE_OF);
-        let base = pod_from_bytes::<S>(base_data)?;
-        if !base.is_initialized() {
-            Err(ProgramError::UninitializedAccount)
-        } else {
-            let tlv_data = unpack_tlv_data::<S>(rest)?;
-            Ok(Self { base, tlv_data })
-        }
-    }
-}
-impl<'a, S: BaseState + Pod> BaseStateWithExtensions<S> for PodStateWithExtensions<'a, S> {
-    fn get_tlv_data(&self) -> &[u8] {
-        self.tlv_data
-    }
-}
-
-/// Trait for mutable base state with extension
-pub trait BaseStateWithExtensionsMut<S: BaseState>: BaseStateWithExtensions<S> {
-    /// Get the underlying TLV data as mutable
-    fn get_tlv_data_mut(&mut self) -> &mut [u8];
-
-    /// Get the underlying account type as mutable
-    fn get_account_type_mut(&mut self) -> &mut [u8];
-
-    /// Unpack a portion of the TLV data as the base mutable bytes
-    fn get_extension_bytes_mut<V: Extension>(&mut self) -> Result<&mut [u8], ProgramError> {
-        get_extension_bytes_mut::<S, V>(self.get_tlv_data_mut())
-    }
-
-    /// Unpack a portion of the TLV data as the desired type that allows
-    /// modifying the type
-    fn get_extension_mut<V: Extension + Pod>(&mut self) -> Result<&mut V, ProgramError> {
-        pod_from_bytes_mut::<V>(self.get_extension_bytes_mut::<V>()?)
-    }
-
-    /// Packs a variable-length extension into its appropriate data segment.
-    /// Fails if space hasn't already been allocated for the given extension
-    fn pack_variable_len_extension<V: Extension + VariableLenPack>(
-        &mut self,
-        extension: &V,
-    ) -> Result<(), ProgramError> {
-        let data = self.get_extension_bytes_mut::<V>()?;
-        // NOTE: Do *not* use `pack`, since the length check will cause
-        // reallocations to smaller sizes to fail
-        extension.pack_into_slice(data)
-    }
-
-    /// Packs the default extension data into an open slot if not already found
-    /// in the data buffer. If extension is already found in the buffer, it
-    /// overwrites the existing extension with the default state if
-    /// `overwrite` is set. If extension found, but `overwrite` is not set,
-    /// it returns error.
-    fn init_extension<V: Extension + Pod + Default>(
-        &mut self,
-        overwrite: bool,
-    ) -> Result<&mut V, ProgramError> {
-        let length = pod_get_packed_len::<V>();
-        let buffer = self.alloc::<V>(length, overwrite)?;
-        let extension_ref = pod_from_bytes_mut::<V>(buffer)?;
-        *extension_ref = V::default();
-        Ok(extension_ref)
-    }
-
-    /// Reallocate and overwite the TLV entry for the given variable-length
-    /// extension.
-    ///
-    /// Returns an error if the extension is not present, or if there is not
-    /// enough space in the buffer.
-    fn realloc_variable_len_extension<V: Extension + VariableLenPack>(
-        &mut self,
-        new_extension: &V,
-    ) -> Result<(), ProgramError> {
-        let data = self.realloc::<V>(new_extension.get_packed_len()?)?;
-        new_extension.pack_into_slice(data)
-    }
-
-    /// Reallocate the TLV entry for the given extension to the given number of
-    /// bytes.
-    ///
-    /// If the new length is smaller, it will compact the rest of the buffer and
-    /// zero out the difference at the end. If it's larger, it will move the
-    /// rest of the buffer data and zero out the new data.
-    ///
-    /// Returns an error if the extension is not present, or if this is not
-    /// enough space in the buffer.
-    fn realloc<V: Extension + VariableLenPack>(
-        &mut self,
-        length: usize,
-    ) -> Result<&mut [u8], ProgramError> {
-        let tlv_data = self.get_tlv_data_mut();
-        let TlvIndices {
-            type_start: _,
-            length_start,
-            value_start,
-        } = get_extension_indices::<V>(tlv_data, false)?;
-        let tlv_len = get_tlv_data_info(tlv_data).map(|x| x.used_len)?;
-        let data_len = tlv_data.len();
-
-        let length_ref = pod_from_bytes_mut::<Length>(&mut tlv_data[length_start..value_start])?;
-        let old_length = usize::from(*length_ref);
-
-        // Length check to avoid a panic later in `copy_within`
-        if old_length < length {
-            let new_tlv_len = tlv_len.saturating_add(length.saturating_sub(old_length));
-            if new_tlv_len > data_len {
-                return Err(ProgramError::InvalidAccountData);
-            }
-        }
-
-        // write new length after the check, to avoid getting into a bad situation
-        // if trying to recover from an error
-        *length_ref = Length::try_from(length)?;
-
-        let old_value_end = value_start.saturating_add(old_length);
-        let new_value_end = value_start.saturating_add(length);
-        tlv_data.copy_within(old_value_end..tlv_len, new_value_end);
-        match old_length.cmp(&length) {
-            Ordering::Greater => {
-                // realloc to smaller, zero out the end
-                let new_tlv_len = tlv_len.saturating_sub(old_length.saturating_sub(length));
-                tlv_data[new_tlv_len..tlv_len].fill(0);
-            }
-            Ordering::Less => {
-                // realloc to bigger, zero out the new bytes
-                tlv_data[old_value_end..new_value_end].fill(0);
-            }
-            Ordering::Equal => {} // nothing needed!
-        }
-
-        Ok(&mut tlv_data[value_start..new_value_end])
-    }
-
-    /// Allocate the given number of bytes for the given variable-length
-    /// extension and write its contents into the TLV buffer.
-    ///
-    /// This can only be used for variable-sized types, such as `String` or
-    /// `Vec`. `Pod` types must use `init_extension`
-    fn init_variable_len_extension<V: Extension + VariableLenPack>(
-        &mut self,
-        extension: &V,
-        overwrite: bool,
-    ) -> Result<(), ProgramError> {
-        let data = self.alloc::<V>(extension.get_packed_len()?, overwrite)?;
-        extension.pack_into_slice(data)
-    }
-
-    /// Allocate some space for the extension in the TLV data
-    fn alloc<V: Extension>(
-        &mut self,
-        length: usize,
-        overwrite: bool,
-    ) -> Result<&mut [u8], ProgramError> {
-        if V::TYPE.get_account_type() != S::ACCOUNT_TYPE {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        let tlv_data = self.get_tlv_data_mut();
-        let TlvIndices {
-            type_start,
-            length_start,
-            value_start,
-        } = get_extension_indices::<V>(tlv_data, true)?;
-
-        if tlv_data[type_start..].len() < add_type_and_length_to_len(length) {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        let extension_type = ExtensionType::try_from(&tlv_data[type_start..length_start])?;
-
-        if extension_type == ExtensionType::Uninitialized || overwrite {
-            // write extension type
-            let extension_type_array: [u8; 2] = V::TYPE.into();
-            let extension_type_ref = &mut tlv_data[type_start..length_start];
-            extension_type_ref.copy_from_slice(&extension_type_array);
-            // write length
-            let length_ref =
-                pod_from_bytes_mut::<Length>(&mut tlv_data[length_start..value_start])?;
-
-            // check that the length is the same if we're doing an alloc
-            // with overwrite, otherwise a realloc should be done
-            if overwrite && extension_type == V::TYPE && usize::from(*length_ref) != length {
-                return Err(TokenError::InvalidLengthForAlloc.into());
-            }
-
-            *length_ref = Length::try_from(length)?;
-
-            let value_end = value_start.saturating_add(length);
-            Ok(&mut tlv_data[value_start..value_end])
-        } else {
-            // extension is already initialized, but no overwrite permission
-            Err(TokenError::ExtensionAlreadyInitialized.into())
-        }
-    }
-
-    /// If `extension_type` is an Account-associated ExtensionType that requires
-    /// initialization on InitializeAccount, this method packs the default
-    /// relevant Extension of an ExtensionType into an open slot if not
-    /// already found in the data buffer, otherwise overwrites the
-    /// existing extension with the default state. For all other ExtensionTypes,
-    /// this is a no-op.
-    fn init_account_extension_from_type(
-        &mut self,
-        extension_type: ExtensionType,
-    ) -> Result<(), ProgramError> {
-        if extension_type.get_account_type() != AccountType::Account {
-            return Ok(());
-        }
-        match extension_type {
-            ExtensionType::TransferFeeAmount => {
-                self.init_extension::<TransferFeeAmount>(true).map(|_| ())
-            }
-            ExtensionType::ImmutableOwner => {
-                self.init_extension::<ImmutableOwner>(true).map(|_| ())
-            }
-            ExtensionType::NonTransferableAccount => self
-                .init_extension::<NonTransferableAccount>(true)
-                .map(|_| ()),
-            ExtensionType::TransferHookAccount => {
-                self.init_extension::<TransferHookAccount>(true).map(|_| ())
-            }
-            // ConfidentialTransfers are currently opt-in only, so this is a no-op for extra safety
-            // on InitializeAccount
-            ExtensionType::ConfidentialTransferAccount => Ok(()),
-            #[cfg(test)]
-            ExtensionType::AccountPaddingTest => {
-                self.init_extension::<AccountPaddingTest>(true).map(|_| ())
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// Write the account type into the buffer, done during the base
-    /// state initialization
-    /// Noops if there is no room for an extension in the account, needed for
-    /// pure base mints / accounts.
-    fn init_account_type(&mut self) -> Result<(), ProgramError> {
-        let first_extension_type = self.get_first_extension_type()?;
-        let account_type = self.get_account_type_mut();
-        if !account_type.is_empty() {
-            if let Some(extension_type) = first_extension_type {
-                let account_type = extension_type.get_account_type();
-                if account_type != S::ACCOUNT_TYPE {
-                    return Err(TokenError::ExtensionBaseMismatch.into());
-                }
-            }
-            account_type[0] = S::ACCOUNT_TYPE.into();
-        }
-        Ok(())
-    }
-
-    /// Check that the account type on the account (if initialized) matches the
-    /// account type for any extensions initialized on the TLV data
-    fn check_account_type_matches_extension_type(&self) -> Result<(), ProgramError> {
-        if let Some(extension_type) = self.get_first_extension_type()? {
-            let account_type = extension_type.get_account_type();
-            if account_type != S::ACCOUNT_TYPE {
-                return Err(TokenError::ExtensionBaseMismatch.into());
-            }
-        }
-        Ok(())
-    }
-}
-
-/// Encapsulates mutable base state data (mint or account) with possible
-/// extensions
-#[derive(Debug, PartialEq)]
-pub struct StateWithExtensionsMut<'data, S: BaseState> {
-    /// Unpacked base data
-    pub base: S,
-    /// Raw base data
-    base_data: &'data mut [u8],
-    /// Writable account type
-    account_type: &'data mut [u8],
-    /// Slice of data containing all TLV data, deserialized on demand
-    tlv_data: &'data mut [u8],
-}
-impl<'data, S: BaseState + Pack> StateWithExtensionsMut<'data, S> {
-    /// Unpack base state, leaving the extension data as a mutable slice
-    ///
-    /// Fails if the base state is not initialized.
-    pub fn unpack(input: &'data mut [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at_mut(S::SIZE_OF);
-        let base = S::unpack(base_data)?;
-        let (account_type, tlv_data) = unpack_type_and_tlv_data_mut::<S>(rest)?;
-        Ok(Self {
-            base,
-            base_data,
-            account_type,
-            tlv_data,
-        })
-    }
-
-    /// Unpack an uninitialized base state, leaving the extension data as a
-    /// mutable slice
-    ///
-    /// Fails if the base state has already been initialized.
-    pub fn unpack_uninitialized(input: &'data mut [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at_mut(S::SIZE_OF);
-        let base = S::unpack_unchecked(base_data)?;
-        if base.is_initialized() {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-        let (account_type, tlv_data) = unpack_uninitialized_type_and_tlv_data_mut::<S>(rest)?;
-        let state = Self {
-            base,
-            base_data,
-            account_type,
-            tlv_data,
-        };
-        state.check_account_type_matches_extension_type()?;
-        Ok(state)
-    }
-
-    /// Packs base state data into the base data portion
-    pub fn pack_base(&mut self) {
-        S::pack_into_slice(&self.base, self.base_data);
-    }
-}
-impl<'a, S: BaseState> BaseStateWithExtensions<S> for StateWithExtensionsMut<'a, S> {
-    fn get_tlv_data(&self) -> &[u8] {
-        self.tlv_data
-    }
-}
-impl<'a, S: BaseState> BaseStateWithExtensionsMut<S> for StateWithExtensionsMut<'a, S> {
-    fn get_tlv_data_mut(&mut self) -> &mut [u8] {
-        self.tlv_data
-    }
-    fn get_account_type_mut(&mut self) -> &mut [u8] {
-        self.account_type
-    }
-}
-
-/// Encapsulates mutable base state data (mint or account) with possible
-/// extensions, where the base state is Pod for zero-copy serde.
-#[derive(Debug, PartialEq)]
-pub struct PodStateWithExtensionsMut<'data, S: BaseState> {
-    /// Unpacked base data
-    pub base: &'data mut S,
-    /// Writable account type
-    account_type: &'data mut [u8],
-    /// Slice of data containing all TLV data, deserialized on demand
-    tlv_data: &'data mut [u8],
-}
-impl<'data, S: BaseState + Pod> PodStateWithExtensionsMut<'data, S> {
-    /// Unpack base state, leaving the extension data as a mutable slice
-    ///
-    /// Fails if the base state is not initialized.
-    pub fn unpack(input: &'data mut [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at_mut(S::SIZE_OF);
-        let base = pod_from_bytes_mut::<S>(base_data)?;
-        if !base.is_initialized() {
-            Err(ProgramError::UninitializedAccount)
-        } else {
-            let (account_type, tlv_data) = unpack_type_and_tlv_data_mut::<S>(rest)?;
-            Ok(Self {
-                base,
-                account_type,
-                tlv_data,
-            })
-        }
-    }
-
-    /// Unpack an uninitialized base state, leaving the extension data as a
-    /// mutable slice
-    ///
-    /// Fails if the base state has already been initialized.
-    pub fn unpack_uninitialized(input: &'data mut [u8]) -> Result<Self, ProgramError> {
-        check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-        let (base_data, rest) = input.split_at_mut(S::SIZE_OF);
-        let base = pod_from_bytes_mut::<S>(base_data)?;
-        if base.is_initialized() {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-        let (account_type, tlv_data) = unpack_uninitialized_type_and_tlv_data_mut::<S>(rest)?;
-        let state = Self {
-            base,
-            account_type,
-            tlv_data,
-        };
-        state.check_account_type_matches_extension_type()?;
-        Ok(state)
-    }
-}
-
-impl<'a, S: BaseState> BaseStateWithExtensions<S> for PodStateWithExtensionsMut<'a, S> {
-    fn get_tlv_data(&self) -> &[u8] {
-        self.tlv_data
-    }
-}
-impl<'a, S: BaseState> BaseStateWithExtensionsMut<S> for PodStateWithExtensionsMut<'a, S> {
-    fn get_tlv_data_mut(&mut self) -> &mut [u8] {
-        self.tlv_data
-    }
-    fn get_account_type_mut(&mut self) -> &mut [u8] {
-        self.account_type
-    }
-}
-
-fn unpack_tlv_data<S: BaseState>(rest: &[u8]) -> Result<&[u8], ProgramError> {
-    if let Some((account_type_index, tlv_start_index)) = type_and_tlv_indices::<S>(rest)? {
-        // type_and_tlv_indices() checks that returned indexes are within range
-        let account_type = AccountType::try_from(rest[account_type_index])
-            .map_err(|_| ProgramError::InvalidAccountData)?;
-        check_account_type::<S>(account_type)?;
-        Ok(&rest[tlv_start_index..])
-    } else {
-        Ok(&[])
-    }
-}
-
-fn unpack_type_and_tlv_data_with_check_mut<
-    S: BaseState,
-    F: Fn(AccountType) -> Result<(), ProgramError>,
->(
-    rest: &mut [u8],
-    check_fn: F,
-) -> Result<(&mut [u8], &mut [u8]), ProgramError> {
-    if let Some((account_type_index, tlv_start_index)) = type_and_tlv_indices::<S>(rest)? {
-        // type_and_tlv_indices() checks that returned indexes are within range
-        let account_type = AccountType::try_from(rest[account_type_index])
-            .map_err(|_| ProgramError::InvalidAccountData)?;
-        check_fn(account_type)?;
-        let (account_type, tlv_data) = rest.split_at_mut(tlv_start_index);
-        Ok((
-            &mut account_type[account_type_index..tlv_start_index],
-            tlv_data,
-        ))
-    } else {
-        Ok((&mut [], &mut []))
-    }
-}
-
-fn unpack_type_and_tlv_data_mut<S: BaseState>(
-    rest: &mut [u8],
-) -> Result<(&mut [u8], &mut [u8]), ProgramError> {
-    unpack_type_and_tlv_data_with_check_mut::<S, _>(rest, check_account_type::<S>)
-}
-
-fn unpack_uninitialized_type_and_tlv_data_mut<S: BaseState>(
-    rest: &mut [u8],
-) -> Result<(&mut [u8], &mut [u8]), ProgramError> {
-    unpack_type_and_tlv_data_with_check_mut::<S, _>(rest, |account_type| {
-        if account_type != AccountType::Uninitialized {
-            Err(ProgramError::InvalidAccountData)
-        } else {
-            Ok(())
-        }
-    })
-}
-
-/// If AccountType is uninitialized, set it to the BaseState's ACCOUNT_TYPE;
-/// if AccountType is already set, check is set correctly for BaseState
-/// This method assumes that the `base_data` has already been packed with data
-/// of the desired type.
-pub fn set_account_type<S: BaseState>(input: &mut [u8]) -> Result<(), ProgramError> {
-    check_min_len_and_not_multisig(input, S::SIZE_OF)?;
-    let (base_data, rest) = input.split_at_mut(S::SIZE_OF);
-    if S::ACCOUNT_TYPE == AccountType::Account && !is_initialized_account(base_data)? {
-        return Err(ProgramError::InvalidAccountData);
-    }
-    if let Some((account_type_index, _tlv_start_index)) = type_and_tlv_indices::<S>(rest)? {
-        let mut account_type = AccountType::try_from(rest[account_type_index])
-            .map_err(|_| ProgramError::InvalidAccountData)?;
-        if account_type == AccountType::Uninitialized {
-            rest[account_type_index] = S::ACCOUNT_TYPE.into();
-            account_type = S::ACCOUNT_TYPE;
-        }
-        check_account_type::<S>(account_type)?;
-        Ok(())
-    } else {
-        Err(ProgramError::InvalidAccountData)
-    }
-}
-
-/// Different kinds of accounts. Note that `Mint`, `Account`, and `Multisig`
-/// types are determined exclusively by the size of the account, and are not
-/// included in the account data. `AccountType` is only included if extensions
-/// have been initialized.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, PartialEq, TryFromPrimitive, IntoPrimitive)]
-pub enum AccountType {
-    /// Marker for 0 data
-    Uninitialized,
-    /// Mint account with additional extensions
-    Mint,
-    /// Token holding account with additional extensions
-    Account,
-}
-impl Default for AccountType {
-    fn default() -> Self {
-        Self::Uninitialized
-    }
-}
-
-/// Extensions that can be applied to mints or accounts.  Mint extensions must
-/// only be applied to mint accounts, and account extensions must only be
-/// applied to token holding accounts.
-#[repr(u16)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, TryFromPrimitive, IntoPrimitive)]
-pub enum ExtensionType {
-    /// Used as padding if the account size would otherwise be 355, same as a
-    /// multisig
-    Uninitialized,
-    /// Includes transfer fee rate info and accompanying authorities to withdraw
-    /// and set the fee
-    TransferFeeConfig,
-    /// Includes withheld transfer fees
-    TransferFeeAmount,
-    /// Includes an optional mint close authority
-    MintCloseAuthority,
-    /// Auditor configuration for confidential transfers
-    ConfidentialTransferMint,
-    /// State for confidential transfers
-    ConfidentialTransferAccount,
-    /// Specifies the default Account::state for new Accounts
-    DefaultAccountState,
-    /// Indicates that the Account owner authority cannot be changed
-    ImmutableOwner,
-    /// Require inbound transfers to have memo
-    MemoTransfer,
-    /// Indicates that the tokens from this mint can't be transferred
-    NonTransferable,
-    /// Tokens accrue interest over time,
-    InterestBearingConfig,
-    /// Locks privileged token operations from happening via CPI
-    CpiGuard,
-    /// Includes an optional permanent delegate
-    PermanentDelegate,
-    /// Indicates that the tokens in this account belong to a non-transferable
-    /// mint
-    NonTransferableAccount,
-    /// Mint requires a CPI to a program implementing the "transfer hook"
-    /// interface
-    TransferHook,
-    /// Indicates that the tokens in this account belong to a mint with a
-    /// transfer hook
-    TransferHookAccount,
-    /// Includes encrypted withheld fees and the encryption public that they are
-    /// encrypted under
-    ConfidentialTransferFeeConfig,
-    /// Includes confidential withheld transfer fees
-    ConfidentialTransferFeeAmount,
-    /// Mint contains a pointer to another account (or the same account) that
-    /// holds metadata
-    MetadataPointer,
-    /// Mint contains token-metadata
-    TokenMetadata,
-    /// Mint contains a pointer to another account (or the same account) that
-    /// holds group configurations
-    GroupPointer,
-    /// Mint contains token group configurations
-    TokenGroup,
-    /// Mint contains a pointer to another account (or the same account) that
-    /// holds group member configurations
-    GroupMemberPointer,
-    /// Mint contains token group member configurations
-    TokenGroupMember,
-    /// Test variable-length mint extension
-    #[cfg(test)]
-    VariableLenMintTest = u16::MAX - 2,
-    /// Padding extension used to make an account exactly Multisig::LEN, used
-    /// for testing
-    #[cfg(test)]
-    AccountPaddingTest,
-    /// Padding extension used to make a mint exactly Multisig::LEN, used for
-    /// testing
-    #[cfg(test)]
-    MintPaddingTest,
-}
-impl TryFrom<&[u8]> for ExtensionType {
-    type Error = ProgramError;
-    fn try_from(a: &[u8]) -> Result<Self, Self::Error> {
-        Self::try_from(u16::from_le_bytes(
-            a.try_into().map_err(|_| ProgramError::InvalidAccountData)?,
-        ))
-        .map_err(|_| ProgramError::InvalidAccountData)
-    }
-}
-impl From<ExtensionType> for [u8; 2] {
-    fn from(a: ExtensionType) -> Self {
-        u16::from(a).to_le_bytes()
-    }
-}
-impl ExtensionType {
-    /// Returns true if the given extension type is sized
-    ///
-    /// Most extension types should be sized, so any variable-length extension
-    /// types should be added here by hand
-    const fn sized(&self) -> bool {
-        match self {
-            ExtensionType::TokenMetadata => false,
-            #[cfg(test)]
-            ExtensionType::VariableLenMintTest => false,
-            _ => true,
-        }
-    }
-
-    /// Get the data length of the type associated with the enum
-    ///
-    /// Fails if the extension type has a variable length
-    fn try_get_type_len(&self) -> Result<usize, ProgramError> {
-        if !self.sized() {
-            return Err(ProgramError::InvalidArgument);
-        }
-        Ok(match self {
-            ExtensionType::Uninitialized => 0,
-            ExtensionType::TransferFeeConfig => pod_get_packed_len::<TransferFeeConfig>(),
-            ExtensionType::TransferFeeAmount => pod_get_packed_len::<TransferFeeAmount>(),
-            ExtensionType::MintCloseAuthority => pod_get_packed_len::<MintCloseAuthority>(),
-            ExtensionType::ImmutableOwner => pod_get_packed_len::<ImmutableOwner>(),
-            ExtensionType::ConfidentialTransferMint => {
-                pod_get_packed_len::<ConfidentialTransferMint>()
-            }
-            ExtensionType::ConfidentialTransferAccount => {
-                pod_get_packed_len::<ConfidentialTransferAccount>()
-            }
-            ExtensionType::DefaultAccountState => pod_get_packed_len::<DefaultAccountState>(),
-            ExtensionType::MemoTransfer => pod_get_packed_len::<MemoTransfer>(),
-            ExtensionType::NonTransferable => pod_get_packed_len::<NonTransferable>(),
-            ExtensionType::InterestBearingConfig => pod_get_packed_len::<InterestBearingConfig>(),
-            ExtensionType::CpiGuard => pod_get_packed_len::<CpiGuard>(),
-            ExtensionType::PermanentDelegate => pod_get_packed_len::<PermanentDelegate>(),
-            ExtensionType::NonTransferableAccount => pod_get_packed_len::<NonTransferableAccount>(),
-            ExtensionType::TransferHook => pod_get_packed_len::<TransferHook>(),
-            ExtensionType::TransferHookAccount => pod_get_packed_len::<TransferHookAccount>(),
-            ExtensionType::ConfidentialTransferFeeConfig => {
-                pod_get_packed_len::<ConfidentialTransferFeeConfig>()
-            }
-            ExtensionType::ConfidentialTransferFeeAmount => {
-                pod_get_packed_len::<ConfidentialTransferFeeAmount>()
-            }
-            ExtensionType::MetadataPointer => pod_get_packed_len::<MetadataPointer>(),
-            ExtensionType::TokenMetadata => unreachable!(),
-            ExtensionType::GroupPointer => pod_get_packed_len::<GroupPointer>(),
-            ExtensionType::TokenGroup => pod_get_packed_len::<TokenGroup>(),
-            ExtensionType::GroupMemberPointer => pod_get_packed_len::<GroupMemberPointer>(),
-            ExtensionType::TokenGroupMember => pod_get_packed_len::<TokenGroupMember>(),
-            #[cfg(test)]
-            ExtensionType::AccountPaddingTest => pod_get_packed_len::<AccountPaddingTest>(),
-            #[cfg(test)]
-            ExtensionType::MintPaddingTest => pod_get_packed_len::<MintPaddingTest>(),
-            #[cfg(test)]
-            ExtensionType::VariableLenMintTest => unreachable!(),
-        })
-    }
-
-    /// Get the TLV length for an ExtensionType
-    ///
-    /// Fails if the extension type has a variable length
-    fn try_get_tlv_len(&self) -> Result<usize, ProgramError> {
-        Ok(add_type_and_length_to_len(self.try_get_type_len()?))
-    }
-
-    /// Get the TLV length for a set of ExtensionTypes
-    ///
-    /// Fails if any of the extension types has a variable length
-    fn try_get_total_tlv_len(extension_types: &[Self]) -> Result<usize, ProgramError> {
-        // dedupe extensions
-        let mut extensions = vec![];
-        for extension_type in extension_types {
-            if !extensions.contains(&extension_type) {
-                extensions.push(extension_type);
-            }
-        }
-        extensions.iter().map(|e| e.try_get_tlv_len()).sum()
-    }
-
-    /// Get the required account data length for the given ExtensionTypes
-    ///
-    /// Fails if any of the extension types has a variable length
-    pub fn try_calculate_account_len<S: BaseState>(
-        extension_types: &[Self],
-    ) -> Result<usize, ProgramError> {
-        if extension_types.is_empty() {
-            Ok(S::SIZE_OF)
-        } else {
-            let extension_size = Self::try_get_total_tlv_len(extension_types)?;
-            let total_len = extension_size.saturating_add(BASE_ACCOUNT_AND_TYPE_LENGTH);
-            Ok(adjust_len_for_multisig(total_len))
-        }
-    }
-
-    /// Get the associated account type
-    pub fn get_account_type(&self) -> AccountType {
-        match self {
-            ExtensionType::Uninitialized => AccountType::Uninitialized,
-            ExtensionType::TransferFeeConfig
-            | ExtensionType::MintCloseAuthority
-            | ExtensionType::ConfidentialTransferMint
-            | ExtensionType::DefaultAccountState
-            | ExtensionType::NonTransferable
-            | ExtensionType::InterestBearingConfig
-            | ExtensionType::PermanentDelegate
-            | ExtensionType::TransferHook
-            | ExtensionType::ConfidentialTransferFeeConfig
-            | ExtensionType::MetadataPointer
-            | ExtensionType::TokenMetadata
-            | ExtensionType::GroupPointer
-            | ExtensionType::TokenGroup
-            | ExtensionType::GroupMemberPointer
-            | ExtensionType::TokenGroupMember => AccountType::Mint,
-            ExtensionType::ImmutableOwner
-            | ExtensionType::TransferFeeAmount
-            | ExtensionType::ConfidentialTransferAccount
-            | ExtensionType::MemoTransfer
-            | ExtensionType::NonTransferableAccount
-            | ExtensionType::TransferHookAccount
-            | ExtensionType::CpiGuard
-            | ExtensionType::ConfidentialTransferFeeAmount => AccountType::Account,
-            #[cfg(test)]
-            ExtensionType::VariableLenMintTest => AccountType::Mint,
-            #[cfg(test)]
-            ExtensionType::AccountPaddingTest => AccountType::Account,
-            #[cfg(test)]
-            ExtensionType::MintPaddingTest => AccountType::Mint,
-        }
-    }
-
-    /// Based on a set of AccountType::Mint ExtensionTypes, get the list of
-    /// AccountType::Account ExtensionTypes required on InitializeAccount
-    pub fn get_required_init_account_extensions(mint_extension_types: &[Self]) -> Vec<Self> {
-        let mut account_extension_types = vec![];
-        for extension_type in mint_extension_types {
-            match extension_type {
-                ExtensionType::TransferFeeConfig => {
-                    account_extension_types.push(ExtensionType::TransferFeeAmount);
-                }
-                ExtensionType::NonTransferable => {
-                    account_extension_types.push(ExtensionType::NonTransferableAccount);
-                    account_extension_types.push(ExtensionType::ImmutableOwner);
-                }
-                ExtensionType::TransferHook => {
-                    account_extension_types.push(ExtensionType::TransferHookAccount);
-                }
-                #[cfg(test)]
-                ExtensionType::MintPaddingTest => {
-                    account_extension_types.push(ExtensionType::AccountPaddingTest);
-                }
-                _ => {}
-            }
-        }
-        account_extension_types
-    }
-
-    /// Check for invalid combination of mint extensions
-    pub fn check_for_invalid_mint_extension_combinations(
-        mint_extension_types: &[Self],
-    ) -> Result<(), TokenError> {
-        let mut transfer_fee_config = false;
-        let mut confidential_transfer_mint = false;
-        let mut confidential_transfer_fee_config = false;
-
-        for extension_type in mint_extension_types {
-            match extension_type {
-                ExtensionType::TransferFeeConfig => transfer_fee_config = true,
-                ExtensionType::ConfidentialTransferMint => confidential_transfer_mint = true,
-                ExtensionType::ConfidentialTransferFeeConfig => {
-                    confidential_transfer_fee_config = true
-                }
-                _ => (),
-            }
-        }
-
-        if confidential_transfer_fee_config && !(transfer_fee_config && confidential_transfer_mint)
-        {
-            return Err(TokenError::InvalidExtensionCombination);
-        }
-
-        if transfer_fee_config && confidential_transfer_mint && !confidential_transfer_fee_config {
-            return Err(TokenError::InvalidExtensionCombination);
-        }
-
-        Ok(())
-    }
-}
-
-/// Trait for base states, specifying the associated enum
-pub trait BaseState: PackedSizeOf + IsInitialized {
-    /// Associated extension type enum, checked at the start of TLV entries
-    const ACCOUNT_TYPE: AccountType;
-}
-impl BaseState for Account {
-    const ACCOUNT_TYPE: AccountType = AccountType::Account;
-}
-impl BaseState for Mint {
-    const ACCOUNT_TYPE: AccountType = AccountType::Mint;
-}
-impl BaseState for PodAccount {
-    const ACCOUNT_TYPE: AccountType = AccountType::Account;
-}
-impl BaseState for PodMint {
-    const ACCOUNT_TYPE: AccountType = AccountType::Mint;
-}
-
-/// Trait to be implemented by all extension states, specifying which extension
-/// and account type they are associated with
-pub trait Extension {
-    /// Associated extension type enum, checked at the start of TLV entries
-    const TYPE: ExtensionType;
-}
-
-/// Padding a mint account to be exactly Multisig::LEN.
-/// We need to pad 185 bytes, since Multisig::LEN = 355, Account::LEN = 165,
-/// size_of AccountType = 1, size_of ExtensionType = 2, size_of Length = 2.
-/// 355 - 165 - 1 - 2 - 2 = 185
-#[cfg(test)]
-#[repr(C)]
-#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-pub struct MintPaddingTest {
-    /// Largest value under 185 that implements Pod
-    pub padding1: [u8; 128],
-    /// Largest value under 57 that implements Pod
-    pub padding2: [u8; 48],
-    /// Exact value needed to finish the padding
-    pub padding3: [u8; 9],
-}
-#[cfg(test)]
-impl Extension for MintPaddingTest {
-    const TYPE: ExtensionType = ExtensionType::MintPaddingTest;
-}
-#[cfg(test)]
-impl Default for MintPaddingTest {
-    fn default() -> Self {
-        Self {
-            padding1: [1; 128],
-            padding2: [2; 48],
-            padding3: [3; 9],
-        }
-    }
-}
-/// Account version of the MintPadding
-#[cfg(test)]
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct AccountPaddingTest(MintPaddingTest);
-#[cfg(test)]
-impl Extension for AccountPaddingTest {
-    const TYPE: ExtensionType = ExtensionType::AccountPaddingTest;
-}
-
-/// Packs a fixed-length extension into a TLV space
-///
-/// This function reallocates the account as needed to accommodate for the
-/// change in space.
-///
-/// If the extension already exists, it will overwrite the existing extension
-/// if `overwrite` is `true`, otherwise it will return an error.
-///
-/// If the extension does not exist, it will reallocate the account and write
-/// the extension into the TLV buffer.
-///
-/// NOTE: Since this function deals with fixed-size extensions, it does not
-/// handle _decreasing_ the size of an account's data buffer, like the function
-/// `alloc_and_serialize_variable_len_extension` does.
-pub(crate) fn alloc_and_serialize<S: BaseState + Pod, V: Default + Extension + Pod>(
-    account_info: &AccountInfo,
-    new_extension: &V,
-    overwrite: bool,
-) -> Result<(), ProgramError> {
-    let previous_account_len = account_info.try_data_len()?;
-    let new_account_len = {
-        let data = account_info.try_borrow_data()?;
-        let state = PodStateWithExtensions::<S>::unpack(&data)?;
-        state.try_get_new_account_len::<V>()?
-    };
-
-    // Realloc the account first, if needed
-    if new_account_len > previous_account_len {
-        account_info.realloc(new_account_len, false)?;
-    }
-    let mut buffer = account_info.try_borrow_mut_data()?;
-    if previous_account_len <= BASE_ACCOUNT_LENGTH {
-        set_account_type::<S>(*buffer)?;
-    }
-    let mut state = PodStateWithExtensionsMut::<S>::unpack(&mut buffer)?;
-
-    // Write the extension
-    let extension = state.init_extension::<V>(overwrite)?;
-    *extension = *new_extension;
-
-    Ok(())
-}
-
-/// Packs a variable-length extension into a TLV space
-///
-/// This function reallocates the account as needed to accommodate for the
-/// change in space, then reallocates in the TLV buffer, and finally writes the
-/// bytes.
-///
-/// NOTE: Unlike the `reallocate` instruction, this function will reduce the
-/// size of an account if it has too many bytes allocated for the given value.
-pub(crate) fn alloc_and_serialize_variable_len_extension<
-    S: BaseState + Pod,
-    V: Extension + VariableLenPack,
->(
-    account_info: &AccountInfo,
-    new_extension: &V,
-    overwrite: bool,
-) -> Result<(), ProgramError> {
-    let previous_account_len = account_info.try_data_len()?;
-    let (new_account_len, extension_already_exists) = {
-        let data = account_info.try_borrow_data()?;
-        let state = PodStateWithExtensions::<S>::unpack(&data)?;
-        let new_account_len =
-            state.try_get_new_account_len_for_variable_len_extension(new_extension)?;
-        let extension_already_exists = state.get_extension_bytes::<V>().is_ok();
-        (new_account_len, extension_already_exists)
-    };
-
-    if extension_already_exists && !overwrite {
-        return Err(TokenError::ExtensionAlreadyInitialized.into());
-    }
-
-    if previous_account_len < new_account_len {
-        // account size increased, so realloc the account, then the TLV entry, then
-        // write data
-        account_info.realloc(new_account_len, false)?;
-        let mut buffer = account_info.try_borrow_mut_data()?;
-        if extension_already_exists {
-            let mut state = PodStateWithExtensionsMut::<S>::unpack(&mut buffer)?;
-            state.realloc_variable_len_extension(new_extension)?;
-        } else {
-            if previous_account_len <= BASE_ACCOUNT_LENGTH {
-                set_account_type::<S>(*buffer)?;
-            }
-            // now alloc in the TLV buffer and write the data
-            let mut state = PodStateWithExtensionsMut::<S>::unpack(&mut buffer)?;
-            state.init_variable_len_extension(new_extension, false)?;
-        }
-    } else {
-        // do it backwards otherwise, write the state, realloc TLV, then the account
-        let mut buffer = account_info.try_borrow_mut_data()?;
-        let mut state = PodStateWithExtensionsMut::<S>::unpack(&mut buffer)?;
-        if extension_already_exists {
-            state.realloc_variable_len_extension(new_extension)?;
-        } else {
-            // this situation can happen if we have an overallocated buffer
-            state.init_variable_len_extension(new_extension, false)?;
-        }
-
-        let removed_bytes = previous_account_len
-            .checked_sub(new_account_len)
-            .ok_or(ProgramError::AccountDataTooSmall)?;
-        if removed_bytes > 0 {
-            // this is probably fine, but be safe and avoid invalidating references
-            drop(buffer);
-            account_info.realloc(new_account_len, false)?;
-        }
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-mod test {
-    use {
-        super::*,
-        crate::{
-            pod::test::{TEST_POD_ACCOUNT, TEST_POD_MINT},
-            state::test::{TEST_ACCOUNT_SLICE, TEST_MINT_SLICE},
-        },
-        bytemuck::Pod,
-        solana_program::{
-            account_info::{Account as GetAccount, IntoAccountInfo},
-            clock::Epoch,
-            entrypoint::MAX_PERMITTED_DATA_INCREASE,
-            pubkey::Pubkey,
-        },
-        spl_pod::{
-            bytemuck::pod_bytes_of, optional_keys::OptionalNonZeroPubkey, primitives::PodU64,
-        },
-        transfer_fee::test::test_transfer_fee_config,
-    };
-
-    /// Test fixed-length struct
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-    struct FixedLenMintTest {
-        data: [u8; 8],
-    }
-    impl Extension for FixedLenMintTest {
-        const TYPE: ExtensionType = ExtensionType::MintPaddingTest;
-    }
-
-    /// Test variable-length struct
-    #[derive(Clone, Debug, PartialEq)]
-    struct VariableLenMintTest {
-        data: Vec<u8>,
-    }
-    impl Extension for VariableLenMintTest {
-        const TYPE: ExtensionType = ExtensionType::VariableLenMintTest;
-    }
-    impl VariableLenPack for VariableLenMintTest {
-        fn pack_into_slice(&self, dst: &mut [u8]) -> Result<(), ProgramError> {
-            let data_start = size_of::<u64>();
-            let end = data_start + self.data.len();
-            if dst.len() < end {
-                Err(ProgramError::InvalidAccountData)
-            } else {
-                dst[..data_start].copy_from_slice(&self.data.len().to_le_bytes());
-                dst[data_start..end].copy_from_slice(&self.data);
-                Ok(())
-            }
-        }
-        fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-            let data_start = size_of::<u64>();
-            let length = u64::from_le_bytes(src[..data_start].try_into().unwrap()) as usize;
-            if src[data_start..data_start + length].len() != length {
-                return Err(ProgramError::InvalidAccountData);
-            }
-            let data = Vec::from(&src[data_start..data_start + length]);
-            Ok(Self { data })
-        }
-        fn get_packed_len(&self) -> Result<usize, ProgramError> {
-            Ok(size_of::<u64>().saturating_add(self.data.len()))
-        }
-    }
-
-    const MINT_WITH_EXTENSION: &[u8] = &[
-        1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // base mint
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // padding
-        1, // account type
-        3, 0, // extension type
-        32, 0, // length
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, // data
-    ];
-
-    #[test]
-    fn unpack_opaque_buffer() {
-        let state = PodStateWithExtensions::<PodMint>::unpack(MINT_WITH_EXTENSION).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-        let extension = state.get_extension::<MintCloseAuthority>().unwrap();
-        let close_authority =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([1; 32]))).unwrap();
-        assert_eq!(extension.close_authority, close_authority);
-        assert_eq!(
-            state.get_extension::<TransferFeeConfig>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-        assert_eq!(
-            PodStateWithExtensions::<PodAccount>::unpack(MINT_WITH_EXTENSION),
-            Err(ProgramError::UninitializedAccount)
-        );
-
-        let state = PodStateWithExtensions::<PodMint>::unpack(TEST_MINT_SLICE).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-
-        let mut test_mint = TEST_MINT_SLICE.to_vec();
-        let state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut test_mint).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-    }
-
-    #[test]
-    fn fail_unpack_opaque_buffer() {
-        // input buffer too small
-        let mut buffer = vec![0, 3];
-        assert_eq!(
-            PodStateWithExtensions::<PodMint>::unpack(&buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the account type
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[BASE_ACCOUNT_LENGTH] = 3;
-        assert_eq!(
-            PodStateWithExtensions::<PodMint>::unpack(&buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // clear the mint initialized byte
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[45] = 0;
-        assert_eq!(
-            PodStateWithExtensions::<PodMint>::unpack(&buffer),
-            Err(ProgramError::UninitializedAccount)
-        );
-
-        // tweak the padding
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[PodMint::SIZE_OF] = 100;
-        assert_eq!(
-            PodStateWithExtensions::<PodMint>::unpack(&buffer),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the extension type
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[BASE_ACCOUNT_LENGTH + 1] = 2;
-        let state = PodStateWithExtensions::<PodMint>::unpack(&buffer).unwrap();
-        assert_eq!(
-            state.get_extension::<TransferFeeConfig>(),
-            Err(ProgramError::Custom(
-                TokenError::ExtensionTypeMismatch as u32
-            ))
-        );
-
-        // tweak the length, too big
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[BASE_ACCOUNT_LENGTH + 3] = 100;
-        let state = PodStateWithExtensions::<PodMint>::unpack(&buffer).unwrap();
-        assert_eq!(
-            state.get_extension::<TransferFeeConfig>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // tweak the length, too small
-        let mut buffer = MINT_WITH_EXTENSION.to_vec();
-        buffer[BASE_ACCOUNT_LENGTH + 3] = 10;
-        let state = PodStateWithExtensions::<PodMint>::unpack(&buffer).unwrap();
-        assert_eq!(
-            state.get_extension::<TransferFeeConfig>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-
-        // data buffer is too small
-        let buffer = &MINT_WITH_EXTENSION[..MINT_WITH_EXTENSION.len() - 1];
-        let state = PodStateWithExtensions::<PodMint>::unpack(buffer).unwrap();
-        assert_eq!(
-            state.get_extension::<MintCloseAuthority>(),
-            Err(ProgramError::InvalidAccountData)
-        );
-    }
-
-    #[test]
-    fn get_extension_types_with_opaque_buffer() {
-        // incorrect due to the length
-        assert_eq!(
-            get_tlv_data_info(&[1, 0, 1, 1]).unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-        // incorrect due to the huge enum number
-        assert_eq!(
-            get_tlv_data_info(&[0, 1, 0, 0]).unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-        // correct due to the good enum number and zero length
-        assert_eq!(
-            get_tlv_data_info(&[1, 0, 0, 0]).unwrap(),
-            TlvDataInfo {
-                extension_types: vec![ExtensionType::try_from(1).unwrap()],
-                used_len: add_type_and_length_to_len(0),
-            }
-        );
-        // correct since it's just uninitialized data at the end
-        assert_eq!(
-            get_tlv_data_info(&[0, 0]).unwrap(),
-            TlvDataInfo {
-                extension_types: vec![],
-                used_len: 0
-            }
-        );
-    }
-
-    #[test]
-    fn mint_with_extension_pack_unpack() {
-        let mint_size = ExtensionType::try_calculate_account_len::<PodMint>(&[
-            ExtensionType::MintCloseAuthority,
-            ExtensionType::TransferFeeConfig,
-        ])
-        .unwrap();
-        let mut buffer = vec![0; mint_size];
-
-        // fail unpack
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer),
-            Err(ProgramError::UninitializedAccount),
-        );
-
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        // fail init account extension
-        assert_eq!(
-            state.init_extension::<TransferFeeAmount>(true),
-            Err(ProgramError::InvalidAccountData),
-        );
-
-        // success write extension
-        let close_authority =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([1; 32]))).unwrap();
-        let extension = state.init_extension::<MintCloseAuthority>(true).unwrap();
-        extension.close_authority = close_authority;
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[ExtensionType::MintCloseAuthority]
-        );
-
-        // fail init extension when already initialized
-        assert_eq!(
-            state.init_extension::<MintCloseAuthority>(false),
-            Err(ProgramError::Custom(
-                TokenError::ExtensionAlreadyInitialized as u32
-            ))
-        );
-
-        // fail unpack as account, a mint extension was written
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer),
-            Err(ProgramError::Custom(
-                TokenError::ExtensionBaseMismatch as u32
-            ))
-        );
-
-        // fail unpack again, still no base data
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer.clone()),
-            Err(ProgramError::UninitializedAccount),
-        );
-
-        // write base mint
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        // check raw buffer
-        let mut expect = TEST_MINT_SLICE.to_vec();
-        expect.extend_from_slice(&[0; BASE_ACCOUNT_LENGTH - PodMint::SIZE_OF]); // padding
-        expect.push(AccountType::Mint.into());
-        expect.extend_from_slice(&(ExtensionType::MintCloseAuthority as u16).to_le_bytes());
-        expect
-            .extend_from_slice(&(pod_get_packed_len::<MintCloseAuthority>() as u16).to_le_bytes());
-        expect.extend_from_slice(&[1; 32]); // data
-        expect.extend_from_slice(&[0; size_of::<ExtensionType>()]);
-        expect.extend_from_slice(&[0; size_of::<Length>()]);
-        expect.extend_from_slice(&[0; size_of::<TransferFeeConfig>()]);
-        assert_eq!(expect, buffer);
-
-        // unpack uninitialized will now fail because the PodMint is now initialized
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer.clone()),
-            Err(TokenError::AlreadyInUse.into()),
-        );
-
-        // check unpacking
-        let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-
-        // update base
-        *state.base = TEST_POD_MINT;
-        state.base.supply = (u64::from(state.base.supply) + 100).into();
-
-        // check unpacking
-        let unpacked_extension = state.get_extension_mut::<MintCloseAuthority>().unwrap();
-        assert_eq!(*unpacked_extension, MintCloseAuthority { close_authority });
-
-        // update extension
-        let close_authority = OptionalNonZeroPubkey::try_from(None).unwrap();
-        unpacked_extension.close_authority = close_authority;
-
-        // check updates are propagated
-        let base = *state.base;
-        let state = PodStateWithExtensions::<PodMint>::unpack(&buffer).unwrap();
-        assert_eq!(state.base, &base);
-        let unpacked_extension = state.get_extension::<MintCloseAuthority>().unwrap();
-        assert_eq!(*unpacked_extension, MintCloseAuthority { close_authority });
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(bytemuck::bytes_of(&base));
-        expect.extend_from_slice(&[0; BASE_ACCOUNT_LENGTH - PodMint::SIZE_OF]); // padding
-        expect.push(AccountType::Mint.into());
-        expect.extend_from_slice(&(ExtensionType::MintCloseAuthority as u16).to_le_bytes());
-        expect
-            .extend_from_slice(&(pod_get_packed_len::<MintCloseAuthority>() as u16).to_le_bytes());
-        expect.extend_from_slice(&[0; 32]);
-        expect.extend_from_slice(&[0; size_of::<ExtensionType>()]);
-        expect.extend_from_slice(&[0; size_of::<Length>()]);
-        expect.extend_from_slice(&[0; size_of::<TransferFeeConfig>()]);
-        assert_eq!(expect, buffer);
-
-        // fail unpack as an account
-        assert_eq!(
-            PodStateWithExtensions::<PodAccount>::unpack(&buffer),
-            Err(ProgramError::UninitializedAccount),
-        );
-
-        let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-        // init one more extension
-        let mint_transfer_fee = test_transfer_fee_config();
-        let new_extension = state.init_extension::<TransferFeeConfig>(true).unwrap();
-        new_extension.transfer_fee_config_authority =
-            mint_transfer_fee.transfer_fee_config_authority;
-        new_extension.withdraw_withheld_authority = mint_transfer_fee.withdraw_withheld_authority;
-        new_extension.withheld_amount = mint_transfer_fee.withheld_amount;
-        new_extension.older_transfer_fee = mint_transfer_fee.older_transfer_fee;
-        new_extension.newer_transfer_fee = mint_transfer_fee.newer_transfer_fee;
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[
-                ExtensionType::MintCloseAuthority,
-                ExtensionType::TransferFeeConfig
-            ]
-        );
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(pod_bytes_of(&base));
-        expect.extend_from_slice(&[0; BASE_ACCOUNT_LENGTH - PodMint::SIZE_OF]); // padding
-        expect.push(AccountType::Mint.into());
-        expect.extend_from_slice(&(ExtensionType::MintCloseAuthority as u16).to_le_bytes());
-        expect
-            .extend_from_slice(&(pod_get_packed_len::<MintCloseAuthority>() as u16).to_le_bytes());
-        expect.extend_from_slice(&[0; 32]); // data
-        expect.extend_from_slice(&(ExtensionType::TransferFeeConfig as u16).to_le_bytes());
-        expect.extend_from_slice(&(pod_get_packed_len::<TransferFeeConfig>() as u16).to_le_bytes());
-        expect.extend_from_slice(pod_bytes_of(&mint_transfer_fee));
-        assert_eq!(expect, buffer);
-
-        // fail to init one more extension that does not fit
-        let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-        assert_eq!(
-            state.init_extension::<MintPaddingTest>(true),
-            Err(ProgramError::InvalidAccountData),
-        );
-    }
-
-    #[test]
-    fn mint_extension_any_order() {
-        let mint_size = ExtensionType::try_calculate_account_len::<PodMint>(&[
-            ExtensionType::MintCloseAuthority,
-            ExtensionType::TransferFeeConfig,
-        ])
-        .unwrap();
-        let mut buffer = vec![0; mint_size];
-
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        // write extensions
-        let close_authority =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([1; 32]))).unwrap();
-        let extension = state.init_extension::<MintCloseAuthority>(true).unwrap();
-        extension.close_authority = close_authority;
-
-        let mint_transfer_fee = test_transfer_fee_config();
-        let extension = state.init_extension::<TransferFeeConfig>(true).unwrap();
-        extension.transfer_fee_config_authority = mint_transfer_fee.transfer_fee_config_authority;
-        extension.withdraw_withheld_authority = mint_transfer_fee.withdraw_withheld_authority;
-        extension.withheld_amount = mint_transfer_fee.withheld_amount;
-        extension.older_transfer_fee = mint_transfer_fee.older_transfer_fee;
-        extension.newer_transfer_fee = mint_transfer_fee.newer_transfer_fee;
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[
-                ExtensionType::MintCloseAuthority,
-                ExtensionType::TransferFeeConfig
-            ]
-        );
-
-        // write base mint
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        let mut other_buffer = vec![0; mint_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut other_buffer).unwrap();
-
-        // write base mint
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        // write extensions in a different order
-        let mint_transfer_fee = test_transfer_fee_config();
-        let extension = state.init_extension::<TransferFeeConfig>(true).unwrap();
-        extension.transfer_fee_config_authority = mint_transfer_fee.transfer_fee_config_authority;
-        extension.withdraw_withheld_authority = mint_transfer_fee.withdraw_withheld_authority;
-        extension.withheld_amount = mint_transfer_fee.withheld_amount;
-        extension.older_transfer_fee = mint_transfer_fee.older_transfer_fee;
-        extension.newer_transfer_fee = mint_transfer_fee.newer_transfer_fee;
-
-        let close_authority =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([1; 32]))).unwrap();
-        let extension = state.init_extension::<MintCloseAuthority>(true).unwrap();
-        extension.close_authority = close_authority;
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[
-                ExtensionType::TransferFeeConfig,
-                ExtensionType::MintCloseAuthority
-            ]
-        );
-
-        // buffers are NOT the same because written in a different order
-        assert_ne!(buffer, other_buffer);
-        let state = PodStateWithExtensions::<PodMint>::unpack(&buffer).unwrap();
-        let other_state = PodStateWithExtensions::<PodMint>::unpack(&other_buffer).unwrap();
-
-        // BUT mint and extensions are the same
-        assert_eq!(
-            state.get_extension::<TransferFeeConfig>().unwrap(),
-            other_state.get_extension::<TransferFeeConfig>().unwrap()
-        );
-        assert_eq!(
-            state.get_extension::<MintCloseAuthority>().unwrap(),
-            other_state.get_extension::<MintCloseAuthority>().unwrap()
-        );
-        assert_eq!(state.base, other_state.base);
-    }
-
-    #[test]
-    fn mint_with_multisig_len() {
-        let mut buffer = vec![0; Multisig::LEN];
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer),
-            Err(ProgramError::InvalidAccountData),
-        );
-        let mint_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::MintPaddingTest])
-                .unwrap();
-        assert_eq!(mint_size, Multisig::LEN + size_of::<ExtensionType>());
-        let mut buffer = vec![0; mint_size];
-
-        // write base mint
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        // write padding
-        let extension = state.init_extension::<MintPaddingTest>(true).unwrap();
-        extension.padding1 = [1; 128];
-        extension.padding2 = [1; 48];
-        extension.padding3 = [1; 9];
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[ExtensionType::MintPaddingTest]
-        );
-
-        // check raw buffer
-        let mut expect = TEST_MINT_SLICE.to_vec();
-        expect.extend_from_slice(&[0; BASE_ACCOUNT_LENGTH - PodMint::SIZE_OF]); // padding
-        expect.push(AccountType::Mint.into());
-        expect.extend_from_slice(&(ExtensionType::MintPaddingTest as u16).to_le_bytes());
-        expect.extend_from_slice(&(pod_get_packed_len::<MintPaddingTest>() as u16).to_le_bytes());
-        expect.extend_from_slice(&vec![1; pod_get_packed_len::<MintPaddingTest>()]);
-        expect.extend_from_slice(&(ExtensionType::Uninitialized as u16).to_le_bytes());
-        assert_eq!(expect, buffer);
-    }
-
-    #[test]
-    fn account_with_extension_pack_unpack() {
-        let account_size = ExtensionType::try_calculate_account_len::<PodAccount>(&[
-            ExtensionType::TransferFeeAmount,
-        ])
-        .unwrap();
-        let mut buffer = vec![0; account_size];
-
-        // fail unpack
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer),
-            Err(ProgramError::UninitializedAccount),
-        );
-
-        let mut state =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer).unwrap();
-        // fail init mint extension
-        assert_eq!(
-            state.init_extension::<TransferFeeConfig>(true),
-            Err(ProgramError::InvalidAccountData),
-        );
-        // success write extension
-        let withheld_amount = PodU64::from(u64::MAX);
-        let extension = state.init_extension::<TransferFeeAmount>(true).unwrap();
-        extension.withheld_amount = withheld_amount;
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[ExtensionType::TransferFeeAmount]
-        );
-
-        // fail unpack again, still no base data
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer.clone()),
-            Err(ProgramError::UninitializedAccount),
-        );
-
-        // write base account
-        let mut state =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_ACCOUNT;
-        state.init_account_type().unwrap();
-        let base = *state.base;
-
-        // check raw buffer
-        let mut expect = TEST_ACCOUNT_SLICE.to_vec();
-        expect.push(AccountType::Account.into());
-        expect.extend_from_slice(&(ExtensionType::TransferFeeAmount as u16).to_le_bytes());
-        expect.extend_from_slice(&(pod_get_packed_len::<TransferFeeAmount>() as u16).to_le_bytes());
-        expect.extend_from_slice(&u64::from(withheld_amount).to_le_bytes());
-        assert_eq!(expect, buffer);
-
-        // check unpacking
-        let mut state = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &base);
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[ExtensionType::TransferFeeAmount]
-        );
-
-        // update base
-        *state.base = TEST_POD_ACCOUNT;
-        state.base.amount = (u64::from(state.base.amount) + 100).into();
-
-        // check unpacking
-        let unpacked_extension = state.get_extension_mut::<TransferFeeAmount>().unwrap();
-        assert_eq!(*unpacked_extension, TransferFeeAmount { withheld_amount });
-
-        // update extension
-        let withheld_amount = PodU64::from(u32::MAX as u64);
-        unpacked_extension.withheld_amount = withheld_amount;
-
-        // check updates are propagated
-        let base = *state.base;
-        let state = PodStateWithExtensions::<PodAccount>::unpack(&buffer).unwrap();
-        assert_eq!(state.base, &base);
-        let unpacked_extension = state.get_extension::<TransferFeeAmount>().unwrap();
-        assert_eq!(*unpacked_extension, TransferFeeAmount { withheld_amount });
-
-        // check raw buffer
-        let mut expect = vec![];
-        expect.extend_from_slice(pod_bytes_of(&base));
-        expect.push(AccountType::Account.into());
-        expect.extend_from_slice(&(ExtensionType::TransferFeeAmount as u16).to_le_bytes());
-        expect.extend_from_slice(&(pod_get_packed_len::<TransferFeeAmount>() as u16).to_le_bytes());
-        expect.extend_from_slice(&u64::from(withheld_amount).to_le_bytes());
-        assert_eq!(expect, buffer);
-
-        // fail unpack as a mint
-        assert_eq!(
-            PodStateWithExtensions::<PodMint>::unpack(&buffer),
-            Err(ProgramError::InvalidAccountData),
-        );
-    }
-
-    #[test]
-    fn account_with_multisig_len() {
-        let mut buffer = vec![0; Multisig::LEN];
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer),
-            Err(ProgramError::InvalidAccountData),
-        );
-        let account_size = ExtensionType::try_calculate_account_len::<PodAccount>(&[
-            ExtensionType::AccountPaddingTest,
-        ])
-        .unwrap();
-        assert_eq!(account_size, Multisig::LEN + size_of::<ExtensionType>());
-        let mut buffer = vec![0; account_size];
-
-        // write base account
-        let mut state =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_ACCOUNT;
-        state.init_account_type().unwrap();
-
-        // write padding
-        let extension = state.init_extension::<AccountPaddingTest>(true).unwrap();
-        extension.0.padding1 = [2; 128];
-        extension.0.padding2 = [2; 48];
-        extension.0.padding3 = [2; 9];
-
-        assert_eq!(
-            &state.get_extension_types().unwrap(),
-            &[ExtensionType::AccountPaddingTest]
-        );
-
-        // check raw buffer
-        let mut expect = TEST_ACCOUNT_SLICE.to_vec();
-        expect.push(AccountType::Account.into());
-        expect.extend_from_slice(&(ExtensionType::AccountPaddingTest as u16).to_le_bytes());
-        expect
-            .extend_from_slice(&(pod_get_packed_len::<AccountPaddingTest>() as u16).to_le_bytes());
-        expect.extend_from_slice(&vec![2; pod_get_packed_len::<AccountPaddingTest>()]);
-        expect.extend_from_slice(&(ExtensionType::Uninitialized as u16).to_le_bytes());
-        assert_eq!(expect, buffer);
-    }
-
-    #[test]
-    fn test_set_account_type() {
-        // account with buffer big enough for AccountType and Extension
-        let mut buffer = TEST_ACCOUNT_SLICE.to_vec();
-        let needed_len = ExtensionType::try_calculate_account_len::<PodAccount>(&[
-            ExtensionType::ImmutableOwner,
-        ])
-        .unwrap()
-            - buffer.len();
-        buffer.append(&mut vec![0; needed_len]);
-        let err = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        set_account_type::<PodAccount>(&mut buffer).unwrap();
-        // unpack is viable after manual set_account_type
-        let mut state = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_ACCOUNT);
-        assert_eq!(state.account_type[0], AccountType::Account as u8);
-        state.init_extension::<ImmutableOwner>(true).unwrap(); // just confirming initialization works
-
-        // account with buffer big enough for AccountType only
-        let mut buffer = TEST_ACCOUNT_SLICE.to_vec();
-        buffer.append(&mut vec![0; 2]);
-        let err = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        set_account_type::<PodAccount>(&mut buffer).unwrap();
-        // unpack is viable after manual set_account_type
-        let state = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_ACCOUNT);
-        assert_eq!(state.account_type[0], AccountType::Account as u8);
-
-        // account with AccountType already set => noop
-        let mut buffer = TEST_ACCOUNT_SLICE.to_vec();
-        buffer.append(&mut vec![2, 0]);
-        let _ = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap();
-        set_account_type::<PodAccount>(&mut buffer).unwrap();
-        let state = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_ACCOUNT);
-        assert_eq!(state.account_type[0], AccountType::Account as u8);
-
-        // account with wrong AccountType fails
-        let mut buffer = TEST_ACCOUNT_SLICE.to_vec();
-        buffer.append(&mut vec![1, 0]);
-        let err = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        let err = set_account_type::<PodAccount>(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        // mint with buffer big enough for AccountType and Extension
-        let mut buffer = TEST_MINT_SLICE.to_vec();
-        let needed_len = ExtensionType::try_calculate_account_len::<PodMint>(&[
-            ExtensionType::MintCloseAuthority,
-        ])
-        .unwrap()
-            - buffer.len();
-        buffer.append(&mut vec![0; needed_len]);
-        let err = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        set_account_type::<PodMint>(&mut buffer).unwrap();
-        // unpack is viable after manual set_account_type
-        let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-        assert_eq!(state.account_type[0], AccountType::Mint as u8);
-        state.init_extension::<MintCloseAuthority>(true).unwrap();
-
-        // mint with buffer big enough for AccountType only
-        let mut buffer = TEST_MINT_SLICE.to_vec();
-        buffer.append(&mut vec![0; PodAccount::SIZE_OF - PodMint::SIZE_OF]);
-        buffer.append(&mut vec![0; 2]);
-        let err = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        set_account_type::<PodMint>(&mut buffer).unwrap();
-        // unpack is viable after manual set_account_type
-        let state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-        assert_eq!(state.account_type[0], AccountType::Mint as u8);
-
-        // mint with AccountType already set => noop
-        let mut buffer = TEST_MINT_SLICE.to_vec();
-        buffer.append(&mut vec![0; PodAccount::SIZE_OF - PodMint::SIZE_OF]);
-        buffer.append(&mut vec![1, 0]);
-        set_account_type::<PodMint>(&mut buffer).unwrap();
-        let state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap();
-        assert_eq!(state.base, &TEST_POD_MINT);
-        assert_eq!(state.account_type[0], AccountType::Mint as u8);
-
-        // mint with wrong AccountType fails
-        let mut buffer = TEST_MINT_SLICE.to_vec();
-        buffer.append(&mut vec![0; PodAccount::SIZE_OF - PodMint::SIZE_OF]);
-        buffer.append(&mut vec![2, 0]);
-        let err = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-        let err = set_account_type::<PodMint>(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_set_account_type_wrongly() {
-        // try to set PodAccount account_type to PodMint
-        let mut buffer = TEST_ACCOUNT_SLICE.to_vec();
-        buffer.append(&mut vec![0; 2]);
-        let err = set_account_type::<PodMint>(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        // try to set PodMint account_type to PodAccount
-        let mut buffer = TEST_MINT_SLICE.to_vec();
-        buffer.append(&mut vec![0; PodAccount::SIZE_OF - PodMint::SIZE_OF]);
-        buffer.append(&mut vec![0; 2]);
-        let err = set_account_type::<PodAccount>(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_get_required_init_account_extensions() {
-        // Some mint extensions with no required account extensions
-        let mint_extensions = vec![
-            ExtensionType::MintCloseAuthority,
-            ExtensionType::Uninitialized,
-        ];
-        assert_eq!(
-            ExtensionType::get_required_init_account_extensions(&mint_extensions),
-            vec![]
-        );
-
-        // One mint extension with required account extension, one without
-        let mint_extensions = vec![
-            ExtensionType::TransferFeeConfig,
-            ExtensionType::MintCloseAuthority,
-        ];
-        assert_eq!(
-            ExtensionType::get_required_init_account_extensions(&mint_extensions),
-            vec![ExtensionType::TransferFeeAmount]
-        );
-
-        // Some mint extensions both with required account extensions
-        let mint_extensions = vec![
-            ExtensionType::TransferFeeConfig,
-            ExtensionType::MintPaddingTest,
-        ];
-        assert_eq!(
-            ExtensionType::get_required_init_account_extensions(&mint_extensions),
-            vec![
-                ExtensionType::TransferFeeAmount,
-                ExtensionType::AccountPaddingTest
-            ]
-        );
-
-        // Demonstrate that method does not dedupe inputs or outputs
-        let mint_extensions = vec![
-            ExtensionType::TransferFeeConfig,
-            ExtensionType::TransferFeeConfig,
-        ];
-        assert_eq!(
-            ExtensionType::get_required_init_account_extensions(&mint_extensions),
-            vec![
-                ExtensionType::TransferFeeAmount,
-                ExtensionType::TransferFeeAmount
-            ]
-        );
-    }
-
-    #[test]
-    fn mint_without_extensions() {
-        let space = ExtensionType::try_calculate_account_len::<PodMint>(&[]).unwrap();
-        let mut buffer = vec![0; space];
-        assert_eq!(
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer),
-            Err(ProgramError::InvalidAccountData),
-        );
-
-        // write base account
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        // fail init extension
-        assert_eq!(
-            state.init_extension::<TransferFeeConfig>(true),
-            Err(ProgramError::InvalidAccountData),
-        );
-
-        assert_eq!(TEST_MINT_SLICE, buffer);
-    }
-
-    #[test]
-    fn test_init_nonzero_default() {
-        let mint_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::MintPaddingTest])
-                .unwrap();
-        let mut buffer = vec![0; mint_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-        let extension = state.init_extension::<MintPaddingTest>(true).unwrap();
-        assert_eq!(extension.padding1, [1; 128]);
-        assert_eq!(extension.padding2, [2; 48]);
-        assert_eq!(extension.padding3, [3; 9]);
-    }
-
-    #[test]
-    fn test_init_buffer_too_small() {
-        let mint_size = ExtensionType::try_calculate_account_len::<PodMint>(&[
-            ExtensionType::MintCloseAuthority,
-        ])
-        .unwrap();
-        let mut buffer = vec![0; mint_size - 1];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        let err = state
-            .init_extension::<MintCloseAuthority>(true)
-            .unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        state.tlv_data[0] = 3;
-        state.tlv_data[2] = 32;
-        let err = state.get_extension_mut::<MintCloseAuthority>().unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        let mut buffer = vec![0; PodMint::SIZE_OF + 2];
-        let err =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        // OK since there are two bytes for the type, which is `Uninitialized`
-        let mut buffer = vec![0; BASE_ACCOUNT_LENGTH + 3];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        let err = state.get_extension_mut::<MintCloseAuthority>().unwrap_err();
-        assert_eq!(err, ProgramError::InvalidAccountData);
-
-        assert_eq!(state.get_extension_types().unwrap(), vec![]);
-
-        // OK, there aren't two bytes for the type, but that's fine
-        let mut buffer = vec![0; BASE_ACCOUNT_LENGTH + 2];
-        let state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        assert_eq!(state.get_extension_types().unwrap(), []);
-    }
-
-    #[test]
-    fn test_extension_with_no_data() {
-        let account_size = ExtensionType::try_calculate_account_len::<PodAccount>(&[
-            ExtensionType::ImmutableOwner,
-        ])
-        .unwrap();
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_ACCOUNT;
-        state.init_account_type().unwrap();
-
-        let err = state.get_extension::<ImmutableOwner>().unwrap_err();
-        assert_eq!(
-            err,
-            ProgramError::Custom(TokenError::ExtensionNotFound as u32)
-        );
-
-        state.init_extension::<ImmutableOwner>(true).unwrap();
-        assert_eq!(
-            get_first_extension_type(state.tlv_data).unwrap(),
-            Some(ExtensionType::ImmutableOwner)
-        );
-        assert_eq!(
-            get_tlv_data_info(state.tlv_data).unwrap(),
-            TlvDataInfo {
-                extension_types: vec![ExtensionType::ImmutableOwner],
-                used_len: add_type_and_length_to_len(0)
-            }
-        );
-    }
-
-    #[test]
-    fn fail_account_len_with_metadata() {
-        assert_eq!(
-            ExtensionType::try_calculate_account_len::<PodMint>(&[
-                ExtensionType::MintCloseAuthority,
-                ExtensionType::VariableLenMintTest,
-                ExtensionType::TransferFeeConfig,
-            ])
-            .unwrap_err(),
-            ProgramError::InvalidArgument
-        );
-    }
-
-    #[test]
-    fn alloc() {
-        let variable_len = VariableLenMintTest { data: vec![1] };
-        let alloc_size = variable_len.get_packed_len().unwrap();
-        let account_size =
-            BASE_ACCOUNT_LENGTH + size_of::<AccountType>() + add_type_and_length_to_len(alloc_size);
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        state
-            .init_variable_len_extension(&variable_len, false)
-            .unwrap();
-
-        // can't double alloc
-        assert_eq!(
-            state
-                .init_variable_len_extension(&variable_len, false)
-                .unwrap_err(),
-            TokenError::ExtensionAlreadyInitialized.into()
-        );
-
-        // unless overwrite is set
-        state
-            .init_variable_len_extension(&variable_len, true)
-            .unwrap();
-
-        // can't change the size during overwrite though
-        assert_eq!(
-            state
-                .init_variable_len_extension(&VariableLenMintTest { data: vec![] }, true)
-                .unwrap_err(),
-            TokenError::InvalidLengthForAlloc.into()
-        );
-
-        // try to write too far, fail earlier
-        assert_eq!(
-            state
-                .init_variable_len_extension(&VariableLenMintTest { data: vec![1, 2] }, true)
-                .unwrap_err(),
-            ProgramError::InvalidAccountData
-        );
-    }
-
-    #[test]
-    fn realloc() {
-        let small_variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3],
-        };
-        let base_variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3, 4],
-        };
-        let big_variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3, 4, 5],
-        };
-        let too_big_variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3, 4, 5, 6],
-        };
-        let account_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::MetadataPointer])
-                .unwrap()
-                + add_type_and_length_to_len(big_variable_len.get_packed_len().unwrap());
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-
-        // alloc both types
-        state
-            .init_variable_len_extension(&base_variable_len, false)
-            .unwrap();
-        let max_pubkey =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([255; 32]))).unwrap();
-        let extension = state.init_extension::<MetadataPointer>(false).unwrap();
-        extension.authority = max_pubkey;
-        extension.metadata_address = max_pubkey;
-
-        // realloc first entry to larger
-        state
-            .realloc_variable_len_extension(&big_variable_len)
-            .unwrap();
-        let extension = state
-            .get_variable_len_extension::<VariableLenMintTest>()
-            .unwrap();
-        assert_eq!(extension, big_variable_len);
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, max_pubkey);
-        assert_eq!(extension.metadata_address, max_pubkey);
-
-        // realloc to smaller
-        state
-            .realloc_variable_len_extension(&small_variable_len)
-            .unwrap();
-        let extension = state
-            .get_variable_len_extension::<VariableLenMintTest>()
-            .unwrap();
-        assert_eq!(extension, small_variable_len);
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, max_pubkey);
-        assert_eq!(extension.metadata_address, max_pubkey);
-        let diff = big_variable_len.get_packed_len().unwrap()
-            - small_variable_len.get_packed_len().unwrap();
-        assert_eq!(&buffer[account_size - diff..account_size], vec![0; diff]);
-
-        // unpack again since we dropped the last `state`
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        // realloc too much, fails
-        assert_eq!(
-            state
-                .realloc_variable_len_extension(&too_big_variable_len)
-                .unwrap_err(),
-            ProgramError::InvalidAccountData,
-        );
-    }
-
-    #[test]
-    fn account_len() {
-        let small_variable_len = VariableLenMintTest {
-            data: vec![20, 30, 40],
-        };
-        let variable_len = VariableLenMintTest {
-            data: vec![20, 30, 40, 50],
-        };
-        let big_variable_len = VariableLenMintTest {
-            data: vec![20, 30, 40, 50, 60],
-        };
-        let value_len = variable_len.get_packed_len().unwrap();
-        let account_size =
-            BASE_ACCOUNT_LENGTH + size_of::<AccountType>() + add_type_and_length_to_len(value_len);
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-
-        // With a new extension, new length must include padding, 1 byte for
-        // account type, 2 bytes for type, 2 for length
-        let current_len = state.try_get_account_len().unwrap();
-        assert_eq!(current_len, PodMint::SIZE_OF);
-        let new_len = state
-            .try_get_new_account_len_for_variable_len_extension::<VariableLenMintTest>(
-                &variable_len,
-            )
-            .unwrap();
-        assert_eq!(
-            new_len,
-            BASE_ACCOUNT_AND_TYPE_LENGTH.saturating_add(add_type_and_length_to_len(value_len))
-        );
-
-        state
-            .init_variable_len_extension::<VariableLenMintTest>(&variable_len, false)
-            .unwrap();
-        let current_len = state.try_get_account_len().unwrap();
-        assert_eq!(current_len, new_len);
-
-        // Reduce the extension size
-        let new_len = state
-            .try_get_new_account_len_for_variable_len_extension::<VariableLenMintTest>(
-                &small_variable_len,
-            )
-            .unwrap();
-        assert_eq!(current_len.checked_sub(new_len).unwrap(), 1);
-
-        // Increase the extension size
-        let new_len = state
-            .try_get_new_account_len_for_variable_len_extension::<VariableLenMintTest>(
-                &big_variable_len,
-            )
-            .unwrap();
-        assert_eq!(new_len.checked_sub(current_len).unwrap(), 1);
-
-        // Maintain the extension size
-        let new_len = state
-            .try_get_new_account_len_for_variable_len_extension::<VariableLenMintTest>(
-                &variable_len,
-            )
-            .unwrap();
-        assert_eq!(new_len, current_len);
-    }
-
-    /// Test helper for mimicking the data layout an on-chain `AccountInfo`,
-    /// which permits "reallocs" as the Solana runtime does it
-    struct SolanaAccountData {
-        data: Vec<u8>,
-        lamports: u64,
-        owner: Pubkey,
-    }
-    impl SolanaAccountData {
-        /// Create a new fake solana account data. The underlying vector is
-        /// overallocated to mimic the runtime
-        fn new(account_data: &[u8]) -> Self {
-            let mut data = vec![];
-            data.extend_from_slice(&(account_data.len() as u64).to_le_bytes());
-            data.extend_from_slice(account_data);
-            data.extend_from_slice(&[0; MAX_PERMITTED_DATA_INCREASE]);
-            Self {
-                data,
-                lamports: 10,
-                owner: Pubkey::new_unique(),
-            }
-        }
-
-        /// Data lops off the first 8 bytes, since those store the size of the
-        /// account for the Solana runtime
-        fn data(&self) -> &[u8] {
-            let start = size_of::<u64>();
-            let len = self.len();
-            &self.data[start..start + len]
-        }
-
-        /// Gets the runtime length of the account data
-        fn len(&self) -> usize {
-            self.data
-                .get(..size_of::<u64>())
-                .and_then(|slice| slice.try_into().ok())
-                .map(u64::from_le_bytes)
-                .unwrap() as usize
-        }
-    }
-    impl GetAccount for SolanaAccountData {
-        fn get(&mut self) -> (&mut u64, &mut [u8], &Pubkey, bool, Epoch) {
-            // need to pull out the data here to avoid a double-mutable borrow
-            let start = size_of::<u64>();
-            let len = self.len();
-            (
-                &mut self.lamports,
-                &mut self.data[start..start + len],
-                &self.owner,
-                false,
-                Epoch::default(),
-            )
-        }
-    }
-
-    #[test]
-    fn alloc_new_fixed_len_tlv_in_account_info_from_base_size() {
-        let fixed_len = FixedLenMintTest {
-            data: [1, 2, 3, 4, 5, 6, 7, 8],
-        };
-        let value_len = pod_get_packed_len::<FixedLenMintTest>();
-        let base_account_size = PodMint::SIZE_OF;
-        let mut buffer = vec![0; base_account_size];
-        let state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-
-        let mut data = SolanaAccountData::new(&buffer);
-        let key = Pubkey::new_unique();
-        let account_info = (&key, &mut data).into_account_info();
-
-        alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, false).unwrap();
-        let new_account_len = BASE_ACCOUNT_AND_TYPE_LENGTH + add_type_and_length_to_len(value_len);
-        assert_eq!(data.len(), new_account_len);
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        assert_eq!(
-            state.get_extension::<FixedLenMintTest>().unwrap(),
-            &fixed_len,
-        );
-
-        // alloc again succeeds with "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, true).unwrap();
-
-        // alloc again fails without "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        assert_eq!(
-            alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, false).unwrap_err(),
-            TokenError::ExtensionAlreadyInitialized.into()
-        );
-    }
-
-    #[test]
-    fn alloc_new_variable_len_tlv_in_account_info_from_base_size() {
-        let variable_len = VariableLenMintTest { data: vec![20, 99] };
-        let value_len = variable_len.get_packed_len().unwrap();
-        let base_account_size = PodMint::SIZE_OF;
-        let mut buffer = vec![0; base_account_size];
-        let state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-
-        let mut data = SolanaAccountData::new(&buffer);
-        let key = Pubkey::new_unique();
-        let account_info = (&key, &mut data).into_account_info();
-
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            false,
-        )
-        .unwrap();
-        let new_account_len = BASE_ACCOUNT_AND_TYPE_LENGTH + add_type_and_length_to_len(value_len);
-        assert_eq!(data.len(), new_account_len);
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        assert_eq!(
-            state
-                .get_variable_len_extension::<VariableLenMintTest>()
-                .unwrap(),
-            variable_len
-        );
-
-        // alloc again succeeds with "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            true,
-        )
-        .unwrap();
-
-        // alloc again fails without "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        assert_eq!(
-            alloc_and_serialize_variable_len_extension::<PodMint, _>(
-                &account_info,
-                &variable_len,
-                false,
-            )
-            .unwrap_err(),
-            TokenError::ExtensionAlreadyInitialized.into()
-        );
-    }
-
-    #[test]
-    fn alloc_new_fixed_len_tlv_in_account_info_from_extended_size() {
-        let fixed_len = FixedLenMintTest {
-            data: [1, 2, 3, 4, 5, 6, 7, 8],
-        };
-        let value_len = pod_get_packed_len::<FixedLenMintTest>();
-        let account_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::GroupPointer])
-                .unwrap()
-                + add_type_and_length_to_len(value_len);
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        let test_key =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([20; 32]))).unwrap();
-        let extension = state.init_extension::<GroupPointer>(false).unwrap();
-        extension.authority = test_key;
-        extension.group_address = test_key;
-
-        let mut data = SolanaAccountData::new(&buffer);
-        let key = Pubkey::new_unique();
-        let account_info = (&key, &mut data).into_account_info();
-
-        alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, false).unwrap();
-        let new_account_len = BASE_ACCOUNT_AND_TYPE_LENGTH
-            + add_type_and_length_to_len(value_len)
-            + add_type_and_length_to_len(size_of::<GroupPointer>());
-        assert_eq!(data.len(), new_account_len);
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        assert_eq!(
-            state.get_extension::<FixedLenMintTest>().unwrap(),
-            &fixed_len,
-        );
-        let extension = state.get_extension::<GroupPointer>().unwrap();
-        assert_eq!(extension.authority, test_key);
-        assert_eq!(extension.group_address, test_key);
-
-        // alloc again succeeds with "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, true).unwrap();
-
-        // alloc again fails without "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        assert_eq!(
-            alloc_and_serialize::<PodMint, _>(&account_info, &fixed_len, false).unwrap_err(),
-            TokenError::ExtensionAlreadyInitialized.into()
-        );
-    }
-
-    #[test]
-    fn alloc_new_variable_len_tlv_in_account_info_from_extended_size() {
-        let variable_len = VariableLenMintTest { data: vec![42, 6] };
-        let value_len = variable_len.get_packed_len().unwrap();
-        let account_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::MetadataPointer])
-                .unwrap()
-                + add_type_and_length_to_len(value_len);
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        let test_key =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([20; 32]))).unwrap();
-        let extension = state.init_extension::<MetadataPointer>(false).unwrap();
-        extension.authority = test_key;
-        extension.metadata_address = test_key;
-
-        let mut data = SolanaAccountData::new(&buffer);
-        let key = Pubkey::new_unique();
-        let account_info = (&key, &mut data).into_account_info();
-
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            false,
-        )
-        .unwrap();
-        let new_account_len = BASE_ACCOUNT_AND_TYPE_LENGTH
-            + add_type_and_length_to_len(value_len)
-            + add_type_and_length_to_len(size_of::<MetadataPointer>());
-        assert_eq!(data.len(), new_account_len);
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        assert_eq!(
-            state
-                .get_variable_len_extension::<VariableLenMintTest>()
-                .unwrap(),
-            variable_len
-        );
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, test_key);
-        assert_eq!(extension.metadata_address, test_key);
-
-        // alloc again succeeds with "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            true,
-        )
-        .unwrap();
-
-        // alloc again fails without "overwrite"
-        let account_info = (&key, &mut data).into_account_info();
-        assert_eq!(
-            alloc_and_serialize_variable_len_extension::<PodMint, _>(
-                &account_info,
-                &variable_len,
-                false,
-            )
-            .unwrap_err(),
-            TokenError::ExtensionAlreadyInitialized.into()
-        );
-    }
-
-    #[test]
-    fn realloc_variable_len_tlv_in_account_info() {
-        let variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3, 4, 5],
-        };
-        let alloc_size = variable_len.get_packed_len().unwrap();
-        let account_size =
-            ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::MetadataPointer])
-                .unwrap()
-                + add_type_and_length_to_len(alloc_size);
-        let mut buffer = vec![0; account_size];
-        let mut state =
-            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();
-        *state.base = TEST_POD_MINT;
-        state.init_account_type().unwrap();
-
-        // alloc both types
-        state
-            .init_variable_len_extension(&variable_len, false)
-            .unwrap();
-        let max_pubkey =
-            OptionalNonZeroPubkey::try_from(Some(Pubkey::new_from_array([255; 32]))).unwrap();
-        let extension = state.init_extension::<MetadataPointer>(false).unwrap();
-        extension.authority = max_pubkey;
-        extension.metadata_address = max_pubkey;
-
-        // reallocate to smaller, make sure existing extension is fine
-        let mut data = SolanaAccountData::new(&buffer);
-        let key = Pubkey::new_unique();
-        let account_info = (&key, &mut data).into_account_info();
-        let variable_len = VariableLenMintTest { data: vec![1, 2] };
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            true,
-        )
-        .unwrap();
-
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, max_pubkey);
-        assert_eq!(extension.metadata_address, max_pubkey);
-        let extension = state
-            .get_variable_len_extension::<VariableLenMintTest>()
-            .unwrap();
-        assert_eq!(extension, variable_len);
-        assert_eq!(data.len(), state.try_get_account_len().unwrap());
-
-        // reallocate to larger
-        let account_info = (&key, &mut data).into_account_info();
-        let variable_len = VariableLenMintTest {
-            data: vec![1, 2, 3, 4, 5, 6, 7],
-        };
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            true,
-        )
-        .unwrap();
-
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, max_pubkey);
-        assert_eq!(extension.metadata_address, max_pubkey);
-        let extension = state
-            .get_variable_len_extension::<VariableLenMintTest>()
-            .unwrap();
-        assert_eq!(extension, variable_len);
-        assert_eq!(data.len(), state.try_get_account_len().unwrap());
-
-        // reallocate to same
-        let account_info = (&key, &mut data).into_account_info();
-        let variable_len = VariableLenMintTest {
-            data: vec![7, 6, 5, 4, 3, 2, 1],
-        };
-        alloc_and_serialize_variable_len_extension::<PodMint, _>(
-            &account_info,
-            &variable_len,
-            true,
-        )
-        .unwrap();
-
-        let state = PodStateWithExtensions::<PodMint>::unpack(data.data()).unwrap();
-        let extension = state.get_extension::<MetadataPointer>().unwrap();
-        assert_eq!(extension.authority, max_pubkey);
-        assert_eq!(extension.metadata_address, max_pubkey);
-        let extension = state
-            .get_variable_len_extension::<VariableLenMintTest>()
-            .unwrap();
-        assert_eq!(extension, variable_len);
-        assert_eq!(data.len(), state.try_get_account_len().unwrap());
-    }
-}
diff --git a/token/program-2022/src/extension/non_transferable.rs b/token/program-2022/src/extension/non_transferable.rs
deleted file mode 100644
index f78b86142ad..00000000000
--- a/token/program-2022/src/extension/non_transferable.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-};
-
-/// Indicates that the tokens from this mint can't be transferred
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct NonTransferable;
-
-/// Indicates that the tokens from this account belong to a non-transferable
-/// mint
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct NonTransferableAccount;
-
-impl Extension for NonTransferable {
-    const TYPE: ExtensionType = ExtensionType::NonTransferable;
-}
-
-impl Extension for NonTransferableAccount {
-    const TYPE: ExtensionType = ExtensionType::NonTransferableAccount;
-}
diff --git a/token/program-2022/src/extension/permanent_delegate.rs b/token/program-2022/src/extension/permanent_delegate.rs
deleted file mode 100644
index cab3862a46a..00000000000
--- a/token/program-2022/src/extension/permanent_delegate.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::extension::{BaseState, BaseStateWithExtensions, Extension, ExtensionType},
-    bytemuck::{Pod, Zeroable},
-    solana_program::pubkey::Pubkey,
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-/// Permanent delegate extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct PermanentDelegate {
-    /// Optional permanent delegate for transferring or burning tokens
-    pub delegate: OptionalNonZeroPubkey,
-}
-impl Extension for PermanentDelegate {
-    const TYPE: ExtensionType = ExtensionType::PermanentDelegate;
-}
-
-/// Attempts to get the permanent delegate from the TLV data, returning None
-/// if the extension is not found
-pub fn get_permanent_delegate<S: BaseState, BSE: BaseStateWithExtensions<S>>(
-    state: &BSE,
-) -> Option<Pubkey> {
-    state
-        .get_extension::<PermanentDelegate>()
-        .ok()
-        .and_then(|e| Option::<Pubkey>::from(e.delegate))
-}
diff --git a/token/program-2022/src/extension/reallocate.rs b/token/program-2022/src/extension/reallocate.rs
deleted file mode 100644
index c21ada497d4..00000000000
--- a/token/program-2022/src/extension/reallocate.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use {
-    crate::{
-        error::TokenError,
-        extension::{
-            set_account_type, AccountType, BaseStateWithExtensions, ExtensionType,
-            StateWithExtensions, StateWithExtensionsMut,
-        },
-        processor::Processor,
-        state::Account,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program::invoke,
-        program_option::COption,
-        pubkey::Pubkey,
-        system_instruction,
-        sysvar::{rent::Rent, Sysvar},
-    },
-};
-
-/// Processes a [Reallocate](enum.TokenInstruction.html) instruction
-pub fn process_reallocate(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_extension_types: Vec<ExtensionType>,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let token_account_info = next_account_info(account_info_iter)?;
-    let payer_info = next_account_info(account_info_iter)?;
-    let system_program_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    // check that account is the right type and validate owner
-    let (mut current_extension_types, native_token_amount) = {
-        let token_account = token_account_info.data.borrow();
-        let account = StateWithExtensions::<Account>::unpack(&token_account)?;
-        Processor::validate_owner(
-            program_id,
-            &account.base.owner,
-            authority_info,
-            authority_info_data_len,
-            account_info_iter.as_slice(),
-        )?;
-        let native_token_amount = account.base.is_native().then_some(account.base.amount);
-        (account.get_extension_types()?, native_token_amount)
-    };
-
-    // check that all desired extensions are for the right account type
-    if new_extension_types
-        .iter()
-        .any(|extension_type| extension_type.get_account_type() != AccountType::Account)
-    {
-        return Err(TokenError::InvalidState.into());
-    }
-    // ExtensionType::try_calculate_account_len() dedupes types, so just a dumb
-    // concatenation is fine here
-    current_extension_types.extend_from_slice(&new_extension_types);
-    let needed_account_len =
-        ExtensionType::try_calculate_account_len::<Account>(&current_extension_types)?;
-
-    // if account is already large enough, return early
-    if token_account_info.data_len() >= needed_account_len {
-        return Ok(());
-    }
-
-    // reallocate
-    msg!(
-        "account needs realloc, +{:?} bytes",
-        needed_account_len - token_account_info.data_len()
-    );
-    token_account_info.realloc(needed_account_len, false)?;
-
-    // if additional lamports needed to remain rent-exempt, transfer them
-    let rent = Rent::get()?;
-    let new_rent_exempt_reserve = rent.minimum_balance(needed_account_len);
-
-    let current_lamport_reserve = token_account_info
-        .lamports()
-        .checked_sub(native_token_amount.unwrap_or(0))
-        .ok_or(TokenError::Overflow)?;
-    let lamports_diff = new_rent_exempt_reserve.saturating_sub(current_lamport_reserve);
-    if lamports_diff > 0 {
-        invoke(
-            &system_instruction::transfer(payer_info.key, token_account_info.key, lamports_diff),
-            &[
-                payer_info.clone(),
-                token_account_info.clone(),
-                system_program_info.clone(),
-            ],
-        )?;
-    }
-
-    // set account_type, if needed
-    let mut token_account_data = token_account_info.data.borrow_mut();
-    set_account_type::<Account>(&mut token_account_data)?;
-
-    // sync the rent exempt reserve for native accounts
-    if let Some(native_token_amount) = native_token_amount {
-        let mut token_account = StateWithExtensionsMut::<Account>::unpack(&mut token_account_data)?;
-        // sanity check that there are enough lamports to cover the token amount
-        // and the rent exempt reserve
-        let minimum_lamports = new_rent_exempt_reserve
-            .checked_add(native_token_amount)
-            .ok_or(TokenError::Overflow)?;
-        if token_account_info.lamports() < minimum_lamports {
-            return Err(TokenError::InvalidState.into());
-        }
-        token_account.base.is_native = COption::Some(new_rent_exempt_reserve);
-        token_account.pack_base();
-    }
-
-    Ok(())
-}
diff --git a/token/program-2022/src/extension/token_group/mod.rs b/token/program-2022/src/extension/token_group/mod.rs
deleted file mode 100644
index 1546ec92975..00000000000
--- a/token/program-2022/src/extension/token_group/mod.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use {
-    crate::extension::{Extension, ExtensionType},
-    spl_token_group_interface::state::{TokenGroup, TokenGroupMember},
-};
-
-/// Instruction processor for the TokenGroup extensions
-pub mod processor;
-
-impl Extension for TokenGroup {
-    const TYPE: ExtensionType = ExtensionType::TokenGroup;
-}
-
-impl Extension for TokenGroupMember {
-    const TYPE: ExtensionType = ExtensionType::TokenGroupMember;
-}
diff --git a/token/program-2022/src/extension/token_group/processor.rs b/token/program-2022/src/extension/token_group/processor.rs
deleted file mode 100644
index b723918ee52..00000000000
--- a/token/program-2022/src/extension/token_group/processor.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-//! Token-group processor
-
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            alloc_and_serialize, group_member_pointer::GroupMemberPointer,
-            group_pointer::GroupPointer, BaseStateWithExtensions, BaseStateWithExtensionsMut,
-            PodStateWithExtensions, PodStateWithExtensionsMut,
-        },
-        pod::{PodCOption, PodMint},
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_group_interface::{
-        error::TokenGroupError,
-        instruction::{
-            InitializeGroup, TokenGroupInstruction, UpdateGroupAuthority, UpdateGroupMaxSize,
-        },
-        state::{TokenGroup, TokenGroupMember},
-    },
-};
-
-fn check_update_authority(
-    update_authority_info: &AccountInfo,
-    expected_update_authority: &OptionalNonZeroPubkey,
-) -> Result<(), ProgramError> {
-    if !update_authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let update_authority = Option::<Pubkey>::from(*expected_update_authority)
-        .ok_or(TokenGroupError::ImmutableGroup)?;
-    if update_authority != *update_authority_info.key {
-        return Err(TokenGroupError::IncorrectUpdateAuthority.into());
-    }
-    Ok(())
-}
-
-/// Processes a [InitializeGroup](enum.TokenGroupInstruction.html) instruction.
-pub fn process_initialize_group(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: InitializeGroup,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let group_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let mint_authority_info = next_account_info(account_info_iter)?;
-
-    // check that the mint and group accounts are the same, since the group
-    // extension should only describe itself
-    if group_info.key != mint_info.key {
-        msg!("Group configurations for a mint must be initialized in the mint itself.");
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    // scope the mint authority check, since the mint is in the same account!
-    {
-        // This check isn't really needed since we'll be writing into the account,
-        // but auditors like it
-        check_program_account(mint_info.owner)?;
-        let mint_data = mint_info.try_borrow_data()?;
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-
-        if !mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if mint.base.mint_authority != PodCOption::some(*mint_authority_info.key) {
-            return Err(TokenGroupError::IncorrectMintAuthority.into());
-        }
-
-        if mint.get_extension::<GroupPointer>().is_err() {
-            msg!(
-                "A mint with group configurations must have the group-pointer extension \
-                 initialized"
-            );
-            return Err(TokenError::InvalidExtensionCombination.into());
-        }
-    }
-
-    // Allocate a TLV entry for the space and write it in
-    // Assumes that there's enough SOL for the new rent-exemption
-    let group = TokenGroup::new(mint_info.key, data.update_authority, data.max_size.into());
-    alloc_and_serialize::<PodMint, TokenGroup>(group_info, &group, false)?;
-
-    Ok(())
-}
-
-/// Processes an
-/// [UpdateGroupMaxSize](enum.TokenGroupInstruction.html)
-/// instruction
-pub fn process_update_group_max_size(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateGroupMaxSize,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let group_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer)?;
-    let group = state.get_extension_mut::<TokenGroup>()?;
-
-    check_update_authority(update_authority_info, &group.update_authority)?;
-
-    group.update_max_size(data.max_size.into())?;
-
-    Ok(())
-}
-
-/// Processes an
-/// [UpdateGroupAuthority](enum.TokenGroupInstruction.html)
-/// instruction
-pub fn process_update_group_authority(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateGroupAuthority,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let group_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer)?;
-    let group = state.get_extension_mut::<TokenGroup>()?;
-
-    check_update_authority(update_authority_info, &group.update_authority)?;
-
-    group.update_authority = data.new_authority;
-
-    Ok(())
-}
-
-/// Processes an [InitializeMember](enum.TokenGroupInstruction.html)
-/// instruction
-pub fn process_initialize_member(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let member_info = next_account_info(account_info_iter)?;
-    let member_mint_info = next_account_info(account_info_iter)?;
-    let member_mint_authority_info = next_account_info(account_info_iter)?;
-    let group_info = next_account_info(account_info_iter)?;
-    let group_update_authority_info = next_account_info(account_info_iter)?;
-
-    // check that the mint and member accounts are the same, since the member
-    // extension should only describe itself
-    if member_info.key != member_mint_info.key {
-        msg!("Group member configurations for a mint must be initialized in the mint itself.");
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    // scope the mint authority check, since the mint is in the same account!
-    {
-        // This check isn't really needed since we'll be writing into the account,
-        // but auditors like it
-        check_program_account(member_mint_info.owner)?;
-        let member_mint_data = member_mint_info.try_borrow_data()?;
-        let member_mint = PodStateWithExtensions::<PodMint>::unpack(&member_mint_data)?;
-
-        if !member_mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if member_mint.base.mint_authority != PodCOption::some(*member_mint_authority_info.key) {
-            return Err(TokenGroupError::IncorrectMintAuthority.into());
-        }
-
-        if member_mint.get_extension::<GroupMemberPointer>().is_err() {
-            msg!(
-                "A mint with group member configurations must have the group-member-pointer \
-                 extension initialized"
-            );
-            return Err(TokenError::InvalidExtensionCombination.into());
-        }
-    }
-
-    // Make sure the member mint is not the same as the group mint
-    if member_info.key == group_info.key {
-        return Err(TokenGroupError::MemberAccountIsGroupAccount.into());
-    }
-
-    // Increment the size of the group
-    let mut buffer = group_info.try_borrow_mut_data()?;
-    let mut state = PodStateWithExtensionsMut::<PodMint>::unpack(&mut buffer)?;
-    let group = state.get_extension_mut::<TokenGroup>()?;
-
-    check_update_authority(group_update_authority_info, &group.update_authority)?;
-    let member_number = group.increment_size()?;
-
-    // Allocate a TLV entry for the space and write it in
-    let member = TokenGroupMember::new(member_mint_info.key, group_info.key, member_number);
-    alloc_and_serialize::<PodMint, TokenGroupMember>(member_info, &member, false)?;
-
-    Ok(())
-}
-
-/// Processes an [Instruction](enum.Instruction.html).
-#[cfg(feature = "token-group")]
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction: TokenGroupInstruction,
-) -> ProgramResult {
-    match instruction {
-        TokenGroupInstruction::InitializeGroup(data) => {
-            msg!("TokenGroupInstruction: InitializeGroup");
-            process_initialize_group(program_id, accounts, data)
-        }
-        TokenGroupInstruction::UpdateGroupMaxSize(data) => {
-            msg!("TokenGroupInstruction: UpdateGroupMaxSize");
-            process_update_group_max_size(program_id, accounts, data)
-        }
-        TokenGroupInstruction::UpdateGroupAuthority(data) => {
-            msg!("TokenGroupInstruction: UpdateGroupAuthority");
-            process_update_group_authority(program_id, accounts, data)
-        }
-        TokenGroupInstruction::InitializeMember(_) => {
-            msg!("TokenGroupInstruction: InitializeMember");
-            process_initialize_member(program_id, accounts)
-        }
-    }
-}
-
-/// Processes an [Instruction](enum.Instruction.html).
-#[cfg(not(feature = "token-group"))]
-pub fn process_instruction(
-    _program_id: &Pubkey,
-    _accounts: &[AccountInfo],
-    _instruction: TokenGroupInstruction,
-) -> ProgramResult {
-    Err(TokenError::InvalidInstruction.into())
-}
diff --git a/token/program-2022/src/extension/token_metadata/mod.rs b/token/program-2022/src/extension/token_metadata/mod.rs
deleted file mode 100644
index cc96af20b5a..00000000000
--- a/token/program-2022/src/extension/token_metadata/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use {
-    crate::extension::{Extension, ExtensionType},
-    spl_token_metadata_interface::state::TokenMetadata,
-};
-
-/// Instruction processor for the TokenMetadata extension
-pub mod processor;
-
-impl Extension for TokenMetadata {
-    const TYPE: ExtensionType = ExtensionType::TokenMetadata;
-}
diff --git a/token/program-2022/src/extension/token_metadata/processor.rs b/token/program-2022/src/extension/token_metadata/processor.rs
deleted file mode 100644
index 278e734c7fa..00000000000
--- a/token/program-2022/src/extension/token_metadata/processor.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-//! Token-metadata processor
-
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            alloc_and_serialize_variable_len_extension, metadata_pointer::MetadataPointer,
-            BaseStateWithExtensions, PodStateWithExtensions,
-        },
-        pod::{PodCOption, PodMint},
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program::set_return_data,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    spl_token_metadata_interface::{
-        error::TokenMetadataError,
-        instruction::{
-            Emit, Initialize, RemoveKey, TokenMetadataInstruction, UpdateAuthority, UpdateField,
-        },
-        state::TokenMetadata,
-    },
-};
-
-fn check_update_authority(
-    update_authority_info: &AccountInfo,
-    expected_update_authority: &OptionalNonZeroPubkey,
-) -> Result<(), ProgramError> {
-    if !update_authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let update_authority = Option::<Pubkey>::from(*expected_update_authority)
-        .ok_or(TokenMetadataError::ImmutableMetadata)?;
-    if update_authority != *update_authority_info.key {
-        return Err(TokenMetadataError::IncorrectUpdateAuthority.into());
-    }
-    Ok(())
-}
-
-/// Processes a [Initialize](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_initialize(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: Initialize,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let mint_authority_info = next_account_info(account_info_iter)?;
-
-    // check that the mint and metadata accounts are the same, since the metadata
-    // extension should only describe itself
-    if metadata_info.key != mint_info.key {
-        msg!("Metadata for a mint must be initialized in the mint itself.");
-        return Err(TokenError::MintMismatch.into());
-    }
-
-    // scope the mint authority check, since the mint is in the same account!
-    {
-        // This check isn't really needed since we'll be writing into the account,
-        // but auditors like it
-        check_program_account(mint_info.owner)?;
-        let mint_data = mint_info.try_borrow_data()?;
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-
-        if !mint_authority_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        if mint.base.mint_authority != PodCOption::some(*mint_authority_info.key) {
-            return Err(TokenMetadataError::IncorrectMintAuthority.into());
-        }
-
-        if mint.get_extension::<MetadataPointer>().is_err() {
-            msg!("A mint with metadata must have the metadata-pointer extension initialized");
-            return Err(TokenError::InvalidExtensionCombination.into());
-        }
-    }
-
-    // Create the token metadata
-    let update_authority = OptionalNonZeroPubkey::try_from(Some(*update_authority_info.key))?;
-    let token_metadata = TokenMetadata {
-        name: data.name,
-        symbol: data.symbol,
-        uri: data.uri,
-        update_authority,
-        mint: *mint_info.key,
-        ..Default::default()
-    };
-
-    // allocate a TLV entry for the space and write it in, assumes that there's
-    // enough SOL for the new rent-exemption
-    alloc_and_serialize_variable_len_extension::<PodMint, _>(
-        metadata_info,
-        &token_metadata,
-        false,
-    )?;
-
-    Ok(())
-}
-
-/// Processes an [UpdateField](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_update_field(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateField,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll probably
-    // realloc the account
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&buffer)?;
-        mint.get_variable_len_extension::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-
-    // Update the field
-    token_metadata.update(data.field, data.value);
-
-    // Update / realloc the account
-    alloc_and_serialize_variable_len_extension::<PodMint, _>(metadata_info, &token_metadata, true)?;
-
-    Ok(())
-}
-
-/// Processes a [RemoveKey](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_remove_key(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: RemoveKey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll probably
-    // realloc the account
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&buffer)?;
-        mint.get_variable_len_extension::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-    if !token_metadata.remove_key(&data.key) && !data.idempotent {
-        return Err(TokenMetadataError::KeyNotFound.into());
-    }
-    alloc_and_serialize_variable_len_extension::<PodMint, _>(metadata_info, &token_metadata, true)?;
-    Ok(())
-}
-
-/// Processes a [UpdateAuthority](enum.TokenMetadataInstruction.html)
-/// instruction.
-pub fn process_update_authority(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    data: UpdateAuthority,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-    let update_authority_info = next_account_info(account_info_iter)?;
-
-    // deserialize the metadata, but scope the data borrow since we'll write
-    // to the account later
-    let mut token_metadata = {
-        let buffer = metadata_info.try_borrow_data()?;
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&buffer)?;
-        mint.get_variable_len_extension::<TokenMetadata>()?
-    };
-
-    check_update_authority(update_authority_info, &token_metadata.update_authority)?;
-    token_metadata.update_authority = data.new_authority;
-    // Update the account, no realloc needed!
-    alloc_and_serialize_variable_len_extension::<PodMint, _>(metadata_info, &token_metadata, true)?;
-
-    Ok(())
-}
-
-/// Processes an [Emit](enum.TokenMetadataInstruction.html) instruction.
-pub fn process_emit(program_id: &Pubkey, accounts: &[AccountInfo], data: Emit) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let metadata_info = next_account_info(account_info_iter)?;
-
-    if metadata_info.owner != program_id {
-        return Err(ProgramError::IllegalOwner);
-    }
-
-    let buffer = metadata_info.try_borrow_data()?;
-    let state = PodStateWithExtensions::<PodMint>::unpack(&buffer)?;
-    let metadata_bytes = state.get_extension_bytes::<TokenMetadata>()?;
-
-    if let Some(range) = TokenMetadata::get_slice(metadata_bytes, data.start, data.end) {
-        set_return_data(range);
-    }
-    Ok(())
-}
-
-/// Processes an [Instruction](enum.Instruction.html).
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction: TokenMetadataInstruction,
-) -> ProgramResult {
-    match instruction {
-        TokenMetadataInstruction::Initialize(data) => {
-            msg!("TokenMetadataInstruction: Initialize");
-            process_initialize(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::UpdateField(data) => {
-            msg!("TokenMetadataInstruction: UpdateField");
-            process_update_field(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::RemoveKey(data) => {
-            msg!("TokenMetadataInstruction: RemoveKey");
-            process_remove_key(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::UpdateAuthority(data) => {
-            msg!("TokenMetadataInstruction: UpdateAuthority");
-            process_update_authority(program_id, accounts, data)
-        }
-        TokenMetadataInstruction::Emit(data) => {
-            msg!("TokenMetadataInstruction: Emit");
-            process_emit(program_id, accounts, data)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/transfer_fee/instruction.rs b/token/program-2022/src/extension/transfer_fee/instruction.rs
deleted file mode 100644
index 7b634f4350b..00000000000
--- a/token/program-2022/src/extension/transfer_fee/instruction.rs
+++ /dev/null
@@ -1,497 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use {
-    crate::serialization::coption_fromstr,
-    serde::{Deserialize, Serialize},
-};
-use {
-    crate::{check_program_account, error::TokenError, instruction::TokenInstruction},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::Pubkey,
-    },
-    std::convert::TryFrom,
-};
-
-/// Transfer Fee extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(
-    feature = "serde-traits",
-    serde(rename_all = "camelCase", rename_all_fields = "camelCase")
-)]
-#[derive(Clone, Copy, Debug, PartialEq)]
-#[repr(u8)]
-pub enum TransferFeeInstruction {
-    /// Initialize the transfer fee on a new mint.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    InitializeTransferFeeConfig {
-        /// Pubkey that may update the fees
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        transfer_fee_config_authority: COption<Pubkey>,
-        /// Withdraw instructions must be signed by this key
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        withdraw_withheld_authority: COption<Pubkey>,
-        /// Amount of transfer collected as fees, expressed as basis points of
-        /// the transfer amount
-        transfer_fee_basis_points: u16,
-        /// Maximum fee assessed on transfers
-        maximum_fee: u64,
-    },
-    /// Transfer, providing expected mint information and fees
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The source account. Must include the
-    ///      `TransferFeeAmount` extension.
-    ///   1. `[]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   2. `[writable]` The destination account. Must include the
-    ///      `TransferFeeAmount` extension.
-    ///   3. `[signer]` The source account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[writable]` The destination account.
-    ///   3. `[]` The source account's multisignature owner/delegate.
-    ///   4. ..4+M `[signer]` M signer accounts.
-    TransferCheckedWithFee {
-        /// The amount of tokens to transfer.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-        /// Expected fee assessed on this transfer, calculated off-chain based
-        /// on the transfer_fee_basis_points and maximum_fee of the
-        /// mint.
-        fee: u64,
-    },
-    /// Transfer all withheld tokens in the mint to an account. Signed by the
-    /// mint's withdraw withheld tokens authority.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` extension associated with the provided mint.
-    ///   2. `[signer]` The mint's `withdraw_withheld_authority`.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The token mint.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The mint's multisig `withdraw_withheld_authority`.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    WithdrawWithheldTokensFromMint,
-    /// Transfer all withheld tokens to an account. Signed by the mint's
-    /// withdraw withheld tokens authority.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[]` The token mint. Must include the `TransferFeeConfig`
-    ///      extension.
-    ///   1. `[writable]` The fee receiver account. Must include the
-    ///      `TransferFeeAmount` extension and be associated with the provided
-    ///      mint.
-    ///   2. `[signer]` The mint's `withdraw_withheld_authority`.
-    ///   3. ..3+N `[writable]` The source accounts to withdraw from.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[]` The token mint.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The mint's multisig `withdraw_withheld_authority`.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    ///   3+M+1. ..3+M+N `[writable]` The source accounts to withdraw from.
-    WithdrawWithheldTokensFromAccounts {
-        /// Number of token accounts harvested
-        num_token_accounts: u8,
-    },
-    /// Permissionless instruction to transfer all withheld tokens to the mint.
-    ///
-    /// Succeeds for frozen accounts.
-    ///
-    /// Accounts provided should include the `TransferFeeAmount` extension. If
-    /// not, the account is skipped.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint.
-    ///   1. ..1+N `[writable]` The source accounts to harvest from.
-    HarvestWithheldTokensToMint,
-    /// Set transfer fee. Only supported for mints that include the
-    /// `TransferFeeConfig` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The mint's fee account owner.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's multisignature fee account owner.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    SetTransferFee {
-        /// Amount of transfer collected as fees, expressed as basis points of
-        /// the transfer amount
-        transfer_fee_basis_points: u16,
-        /// Maximum fee assessed on transfers
-        maximum_fee: u64,
-    },
-}
-impl TransferFeeInstruction {
-    /// Unpacks a byte buffer into a TransferFeeInstruction
-    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
-        use TokenError::InvalidInstruction;
-
-        let (&tag, rest) = input.split_first().ok_or(InvalidInstruction)?;
-        Ok(match tag {
-            0 => {
-                let (transfer_fee_config_authority, rest) =
-                    TokenInstruction::unpack_pubkey_option(rest)?;
-                let (withdraw_withheld_authority, rest) =
-                    TokenInstruction::unpack_pubkey_option(rest)?;
-                let (transfer_fee_basis_points, rest) = TokenInstruction::unpack_u16(rest)?;
-                let (maximum_fee, _) = TokenInstruction::unpack_u64(rest)?;
-                Self::InitializeTransferFeeConfig {
-                    transfer_fee_config_authority,
-                    withdraw_withheld_authority,
-                    transfer_fee_basis_points,
-                    maximum_fee,
-                }
-            }
-            1 => {
-                let (amount, decimals, rest) = TokenInstruction::unpack_amount_decimals(rest)?;
-                let (fee, _) = TokenInstruction::unpack_u64(rest)?;
-                Self::TransferCheckedWithFee {
-                    amount,
-                    decimals,
-                    fee,
-                }
-            }
-            2 => Self::WithdrawWithheldTokensFromMint,
-            3 => {
-                let (&num_token_accounts, _) = rest.split_first().ok_or(InvalidInstruction)?;
-                Self::WithdrawWithheldTokensFromAccounts { num_token_accounts }
-            }
-            4 => Self::HarvestWithheldTokensToMint,
-            5 => {
-                let (transfer_fee_basis_points, rest) = TokenInstruction::unpack_u16(rest)?;
-                let (maximum_fee, _) = TokenInstruction::unpack_u64(rest)?;
-                Self::SetTransferFee {
-                    transfer_fee_basis_points,
-                    maximum_fee,
-                }
-            }
-            _ => return Err(TokenError::InvalidInstruction.into()),
-        })
-    }
-
-    /// Packs a TransferFeeInstruction into a byte buffer.
-    pub fn pack(&self, buffer: &mut Vec<u8>) {
-        match *self {
-            Self::InitializeTransferFeeConfig {
-                ref transfer_fee_config_authority,
-                ref withdraw_withheld_authority,
-                transfer_fee_basis_points,
-                maximum_fee,
-            } => {
-                buffer.push(0);
-                TokenInstruction::pack_pubkey_option(transfer_fee_config_authority, buffer);
-                TokenInstruction::pack_pubkey_option(withdraw_withheld_authority, buffer);
-                buffer.extend_from_slice(&transfer_fee_basis_points.to_le_bytes());
-                buffer.extend_from_slice(&maximum_fee.to_le_bytes());
-            }
-            Self::TransferCheckedWithFee {
-                amount,
-                decimals,
-                fee,
-            } => {
-                buffer.push(1);
-                buffer.extend_from_slice(&amount.to_le_bytes());
-                buffer.extend_from_slice(&decimals.to_le_bytes());
-                buffer.extend_from_slice(&fee.to_le_bytes());
-            }
-            Self::WithdrawWithheldTokensFromMint => {
-                buffer.push(2);
-            }
-            Self::WithdrawWithheldTokensFromAccounts { num_token_accounts } => {
-                buffer.push(3);
-                buffer.push(num_token_accounts);
-            }
-            Self::HarvestWithheldTokensToMint => {
-                buffer.push(4);
-            }
-            Self::SetTransferFee {
-                transfer_fee_basis_points,
-                maximum_fee,
-            } => {
-                buffer.push(5);
-                buffer.extend_from_slice(&transfer_fee_basis_points.to_le_bytes());
-                buffer.extend_from_slice(&maximum_fee.to_le_bytes());
-            }
-        }
-    }
-}
-
-fn encode_instruction_data(transfer_fee_instruction: TransferFeeInstruction) -> Vec<u8> {
-    let mut data = TokenInstruction::TransferFeeExtension.pack();
-    transfer_fee_instruction.pack(&mut data);
-    data
-}
-
-/// Create a `InitializeTransferFeeConfig` instruction
-pub fn initialize_transfer_fee_config(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    transfer_fee_config_authority: Option<&Pubkey>,
-    withdraw_withheld_authority: Option<&Pubkey>,
-    transfer_fee_basis_points: u16,
-    maximum_fee: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let transfer_fee_config_authority = transfer_fee_config_authority.cloned().into();
-    let withdraw_withheld_authority = withdraw_withheld_authority.cloned().into();
-    let data = encode_instruction_data(TransferFeeInstruction::InitializeTransferFeeConfig {
-        transfer_fee_config_authority,
-        withdraw_withheld_authority,
-        transfer_fee_basis_points,
-        maximum_fee,
-    });
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*mint, false)],
-        data,
-    })
-}
-
-/// Create a `TransferCheckedWithFee` instruction
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_checked_with_fee(
-    token_program_id: &Pubkey,
-    source: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-    fee: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = encode_instruction_data(TransferFeeInstruction::TransferCheckedWithFee {
-        amount,
-        decimals,
-        fee,
-    });
-
-    let mut accounts = Vec::with_capacity(4 + signers.len());
-    accounts.push(AccountMeta::new(*source, false));
-    accounts.push(AccountMeta::new_readonly(*mint, false));
-    accounts.push(AccountMeta::new(*destination, false));
-    accounts.push(AccountMeta::new_readonly(*authority, signers.is_empty()));
-    for signer in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `WithdrawWithheldTokensFromMint` instruction
-pub fn withdraw_withheld_tokens_from_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = Vec::with_capacity(3 + signers.len());
-    accounts.push(AccountMeta::new(*mint, false));
-    accounts.push(AccountMeta::new(*destination, false));
-    accounts.push(AccountMeta::new_readonly(*authority, signers.is_empty()));
-    for signer in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: encode_instruction_data(TransferFeeInstruction::WithdrawWithheldTokensFromMint),
-    })
-}
-
-/// Creates a `WithdrawWithheldTokensFromAccounts` instruction
-pub fn withdraw_withheld_tokens_from_accounts(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    sources: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let num_token_accounts =
-        u8::try_from(sources.len()).map_err(|_| ProgramError::InvalidInstructionData)?;
-    let mut accounts = Vec::with_capacity(3 + signers.len() + sources.len());
-    accounts.push(AccountMeta::new_readonly(*mint, false));
-    accounts.push(AccountMeta::new(*destination, false));
-    accounts.push(AccountMeta::new_readonly(*authority, signers.is_empty()));
-    for signer in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer, true));
-    }
-    for source in sources.iter() {
-        accounts.push(AccountMeta::new(**source, false));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: encode_instruction_data(TransferFeeInstruction::WithdrawWithheldTokensFromAccounts {
-            num_token_accounts,
-        }),
-    })
-}
-
-/// Creates a `HarvestWithheldTokensToMint` instruction
-pub fn harvest_withheld_tokens_to_mint(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    sources: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = Vec::with_capacity(1 + sources.len());
-    accounts.push(AccountMeta::new(*mint, false));
-    for source in sources.iter() {
-        accounts.push(AccountMeta::new(**source, false));
-    }
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: encode_instruction_data(TransferFeeInstruction::HarvestWithheldTokensToMint),
-    })
-}
-
-/// Creates a `SetTransferFee` instruction
-pub fn set_transfer_fee(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    transfer_fee_basis_points: u16,
-    maximum_fee: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = Vec::with_capacity(2 + signers.len());
-    accounts.push(AccountMeta::new(*mint, false));
-    accounts.push(AccountMeta::new_readonly(*authority, signers.is_empty()));
-    for signer in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: encode_instruction_data(TransferFeeInstruction::SetTransferFee {
-            transfer_fee_basis_points,
-            maximum_fee,
-        }),
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_instruction_packing() {
-        let check = TransferFeeInstruction::InitializeTransferFeeConfig {
-            transfer_fee_config_authority: COption::Some(Pubkey::new_from_array([11u8; 32])),
-            withdraw_withheld_authority: COption::None,
-            transfer_fee_basis_points: 111,
-            maximum_fee: u64::MAX,
-        };
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let mut expect = vec![0, 1];
-        expect.extend_from_slice(&[11u8; 32]);
-        expect.extend_from_slice(&[0]);
-        expect.extend_from_slice(&111u16.to_le_bytes());
-        expect.extend_from_slice(&u64::MAX.to_le_bytes());
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TransferFeeInstruction::TransferCheckedWithFee {
-            amount: 24,
-            decimals: 24,
-            fee: 23,
-        };
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let mut expect = vec![1];
-        expect.extend_from_slice(&24u64.to_le_bytes());
-        expect.extend_from_slice(&[24u8]);
-        expect.extend_from_slice(&23u64.to_le_bytes());
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TransferFeeInstruction::WithdrawWithheldTokensFromMint;
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let expect = [2];
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let num_token_accounts = 255;
-        let check =
-            TransferFeeInstruction::WithdrawWithheldTokensFromAccounts { num_token_accounts };
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let expect = [3, num_token_accounts];
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TransferFeeInstruction::HarvestWithheldTokensToMint;
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let expect = [4];
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TransferFeeInstruction::SetTransferFee {
-            transfer_fee_basis_points: u16::MAX,
-            maximum_fee: u64::MAX,
-        };
-        let mut packed = vec![];
-        check.pack(&mut packed);
-        let mut expect = vec![5];
-        expect.extend_from_slice(&u16::MAX.to_le_bytes());
-        expect.extend_from_slice(&u64::MAX.to_le_bytes());
-        assert_eq!(packed, expect);
-        let unpacked = TransferFeeInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-    }
-}
diff --git a/token/program-2022/src/extension/transfer_fee/mod.rs b/token/program-2022/src/extension/transfer_fee/mod.rs
deleted file mode 100644
index 3ccc6d890b7..00000000000
--- a/token/program-2022/src/extension/transfer_fee/mod.rs
+++ /dev/null
@@ -1,447 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        error::TokenError,
-        extension::{Extension, ExtensionType},
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::{clock::Epoch, entrypoint::ProgramResult},
-    spl_pod::{
-        optional_keys::OptionalNonZeroPubkey,
-        primitives::{PodU16, PodU64},
-    },
-    std::{
-        cmp,
-        convert::{TryFrom, TryInto},
-    },
-};
-
-/// Transfer fee extension instructions
-pub mod instruction;
-
-/// Transfer fee extension processor
-pub mod processor;
-
-/// Maximum possible fee in basis points is 100%, aka 10_000 basis points
-pub const MAX_FEE_BASIS_POINTS: u16 = 10_000;
-const ONE_IN_BASIS_POINTS: u128 = MAX_FEE_BASIS_POINTS as u128;
-
-/// Transfer fee information
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct TransferFee {
-    /// First epoch where the transfer fee takes effect
-    pub epoch: PodU64, // Epoch,
-    /// Maximum fee assessed on transfers, expressed as an amount of tokens
-    pub maximum_fee: PodU64,
-    /// Amount of transfer collected as fees, expressed as basis points of the
-    /// transfer amount, ie. increments of 0.01%
-    pub transfer_fee_basis_points: PodU16,
-}
-impl TransferFee {
-    /// Calculate ceiling-division
-    ///
-    /// Ceiling-division
-    ///     `ceil[ numerator / denominator ]`
-    /// can be represented as a floor-division
-    ///     `floor[ (numerator + denominator - 1) / denominator]`
-    fn ceil_div(numerator: u128, denominator: u128) -> Option<u128> {
-        numerator
-            .checked_add(denominator)?
-            .checked_sub(1)?
-            .checked_div(denominator)
-    }
-
-    /// Calculate the transfer fee
-    pub fn calculate_fee(&self, pre_fee_amount: u64) -> Option<u64> {
-        let transfer_fee_basis_points = u16::from(self.transfer_fee_basis_points) as u128;
-        if transfer_fee_basis_points == 0 || pre_fee_amount == 0 {
-            Some(0)
-        } else {
-            let numerator = (pre_fee_amount as u128).checked_mul(transfer_fee_basis_points)?;
-            let raw_fee = Self::ceil_div(numerator, ONE_IN_BASIS_POINTS)?
-                .try_into() // guaranteed to be okay
-                .ok()?;
-
-            Some(cmp::min(raw_fee, u64::from(self.maximum_fee)))
-        }
-    }
-
-    /// Calculate the gross transfer amount after deducting fees
-    pub fn calculate_post_fee_amount(&self, pre_fee_amount: u64) -> Option<u64> {
-        pre_fee_amount.checked_sub(self.calculate_fee(pre_fee_amount)?)
-    }
-
-    /// Calculate the transfer amount that will result in a specified net
-    /// transfer amount.
-    ///
-    /// The original transfer amount may not always be unique due to rounding.
-    /// In this case, the smaller amount will be chosen.
-    /// e.g. Both transfer amount 10, 11 with 10% fee rate results in net
-    /// transfer amount of 9. In this case, 10 will be chosen.
-    /// e.g. Fee rate is 100%. In this case, 0 will be chosen.
-    ///
-    /// The original transfer amount may not always exist on large net transfer
-    /// amounts due to overflow. In this case, `None` is returned.
-    /// e.g. The net fee amount is `u64::MAX` with a positive fee rate.
-    pub fn calculate_pre_fee_amount(&self, post_fee_amount: u64) -> Option<u64> {
-        let maximum_fee = u64::from(self.maximum_fee);
-        let transfer_fee_basis_points = u16::from(self.transfer_fee_basis_points) as u128;
-        match (transfer_fee_basis_points, post_fee_amount) {
-            // no fee, same amount
-            (0, _) => Some(post_fee_amount),
-            // 0 zero out, 0 in
-            (_, 0) => Some(0),
-            // 100%, cap at max fee
-            (ONE_IN_BASIS_POINTS, _) => maximum_fee.checked_add(post_fee_amount),
-            _ => {
-                let numerator = (post_fee_amount as u128).checked_mul(ONE_IN_BASIS_POINTS)?;
-                let denominator = ONE_IN_BASIS_POINTS.checked_sub(transfer_fee_basis_points)?;
-                let raw_pre_fee_amount = Self::ceil_div(numerator, denominator)?;
-
-                if raw_pre_fee_amount.checked_sub(post_fee_amount as u128)? >= maximum_fee as u128 {
-                    post_fee_amount.checked_add(maximum_fee)
-                } else {
-                    // should return `None` if `pre_fee_amount` overflows
-                    u64::try_from(raw_pre_fee_amount).ok()
-                }
-            }
-        }
-    }
-
-    /// Calculate the fee that would produce the given output
-    pub fn calculate_inverse_fee(&self, post_fee_amount: u64) -> Option<u64> {
-        let pre_fee_amount = self.calculate_pre_fee_amount(post_fee_amount)?;
-        self.calculate_fee(pre_fee_amount)
-    }
-}
-
-/// Transfer fee extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct TransferFeeConfig {
-    /// Optional authority to set the fee
-    pub transfer_fee_config_authority: OptionalNonZeroPubkey,
-    /// Withdraw from mint instructions must be signed by this key
-    pub withdraw_withheld_authority: OptionalNonZeroPubkey,
-    /// Withheld transfer fee tokens that have been moved to the mint for
-    /// withdrawal
-    pub withheld_amount: PodU64,
-    /// Older transfer fee, used if the current epoch < new_transfer_fee.epoch
-    pub older_transfer_fee: TransferFee,
-    /// Newer transfer fee, used if the current epoch >= new_transfer_fee.epoch
-    pub newer_transfer_fee: TransferFee,
-}
-impl TransferFeeConfig {
-    /// Get the fee for the given epoch
-    pub fn get_epoch_fee(&self, epoch: Epoch) -> &TransferFee {
-        if epoch >= self.newer_transfer_fee.epoch.into() {
-            &self.newer_transfer_fee
-        } else {
-            &self.older_transfer_fee
-        }
-    }
-    /// Calculate the fee for the given epoch and input amount
-    pub fn calculate_epoch_fee(&self, epoch: Epoch, pre_fee_amount: u64) -> Option<u64> {
-        self.get_epoch_fee(epoch).calculate_fee(pre_fee_amount)
-    }
-    /// Calculate the fee for the given epoch and output amount
-    pub fn calculate_inverse_epoch_fee(&self, epoch: Epoch, post_fee_amount: u64) -> Option<u64> {
-        self.get_epoch_fee(epoch)
-            .calculate_inverse_fee(post_fee_amount)
-    }
-}
-impl Extension for TransferFeeConfig {
-    const TYPE: ExtensionType = ExtensionType::TransferFeeConfig;
-}
-
-/// Transfer fee extension data for accounts.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct TransferFeeAmount {
-    /// Amount withheld during transfers, to be harvested to the mint
-    pub withheld_amount: PodU64,
-}
-impl TransferFeeAmount {
-    /// Check if the extension is in a closable state
-    pub fn closable(&self) -> ProgramResult {
-        if self.withheld_amount == 0.into() {
-            Ok(())
-        } else {
-            Err(TokenError::AccountHasWithheldTransferFees.into())
-        }
-    }
-}
-impl Extension for TransferFeeAmount {
-    const TYPE: ExtensionType = ExtensionType::TransferFeeAmount;
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use {super::*, proptest::prelude::*, solana_program::pubkey::Pubkey, std::convert::TryFrom};
-
-    const NEWER_EPOCH: u64 = 100;
-    const OLDER_EPOCH: u64 = 1;
-
-    pub(crate) fn test_transfer_fee_config() -> TransferFeeConfig {
-        TransferFeeConfig {
-            transfer_fee_config_authority: OptionalNonZeroPubkey::try_from(Some(
-                Pubkey::new_from_array([10; 32]),
-            ))
-            .unwrap(),
-            withdraw_withheld_authority: OptionalNonZeroPubkey::try_from(Some(
-                Pubkey::new_from_array([11; 32]),
-            ))
-            .unwrap(),
-            withheld_amount: PodU64::from(u64::MAX),
-            older_transfer_fee: TransferFee {
-                epoch: PodU64::from(OLDER_EPOCH),
-                maximum_fee: PodU64::from(10),
-                transfer_fee_basis_points: PodU16::from(100),
-            },
-            newer_transfer_fee: TransferFee {
-                epoch: PodU64::from(NEWER_EPOCH),
-                maximum_fee: PodU64::from(5_000),
-                transfer_fee_basis_points: PodU16::from(1),
-            },
-        }
-    }
-
-    #[test]
-    fn epoch_fee() {
-        let transfer_fee_config = test_transfer_fee_config();
-        // during epoch 100 and after, use newer transfer fee
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(NEWER_EPOCH).epoch,
-            NEWER_EPOCH.into()
-        );
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(NEWER_EPOCH + 1).epoch,
-            NEWER_EPOCH.into()
-        );
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(u64::MAX).epoch,
-            NEWER_EPOCH.into()
-        );
-        // before that, use older transfer fee
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(NEWER_EPOCH - 1).epoch,
-            OLDER_EPOCH.into()
-        );
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(OLDER_EPOCH).epoch,
-            OLDER_EPOCH.into()
-        );
-        assert_eq!(
-            transfer_fee_config.get_epoch_fee(OLDER_EPOCH + 1).epoch,
-            OLDER_EPOCH.into()
-        );
-    }
-
-    #[test]
-    fn calculate_fee_max() {
-        let one = u64::try_from(ONE_IN_BASIS_POINTS).unwrap();
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(5_000),
-            transfer_fee_basis_points: PodU16::from(1),
-        };
-        let maximum_fee = u64::from(transfer_fee.maximum_fee);
-        // hit maximum fee
-        assert_eq!(maximum_fee, transfer_fee.calculate_fee(u64::MAX).unwrap());
-        // at exactly the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee.calculate_fee(maximum_fee * one).unwrap()
-        );
-        // one token above, normally rounds up, but we're at the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee.calculate_fee(maximum_fee * one + 1).unwrap()
-        );
-        // one token below, rounds up to the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee.calculate_fee(maximum_fee * one - 1).unwrap()
-        );
-    }
-
-    #[test]
-    fn calculate_fee_min() {
-        let one = u64::try_from(ONE_IN_BASIS_POINTS).unwrap();
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(5_000),
-            transfer_fee_basis_points: PodU16::from(1),
-        };
-        let minimum_fee = 1;
-        // hit minimum fee even with 1 token
-        assert_eq!(minimum_fee, transfer_fee.calculate_fee(1).unwrap());
-        // still minimum at 2 tokens
-        assert_eq!(minimum_fee, transfer_fee.calculate_fee(2).unwrap());
-        // still minimum at 10_000 tokens
-        assert_eq!(minimum_fee, transfer_fee.calculate_fee(one).unwrap());
-        // 2 token fee at 10_001
-        assert_eq!(
-            minimum_fee + 1,
-            transfer_fee.calculate_fee(one + 1).unwrap()
-        );
-        // zero is always zero
-        assert_eq!(0, transfer_fee.calculate_fee(0).unwrap());
-    }
-
-    #[test]
-    fn calculate_fee_zero() {
-        let one = u64::try_from(ONE_IN_BASIS_POINTS).unwrap();
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(u64::MAX),
-            transfer_fee_basis_points: PodU16::from(0),
-        };
-        // always zero fee
-        assert_eq!(0, transfer_fee.calculate_fee(0).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(u64::MAX).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(1).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(one).unwrap());
-
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(0),
-            transfer_fee_basis_points: PodU16::from(MAX_FEE_BASIS_POINTS),
-        };
-        // always zero fee
-        assert_eq!(0, transfer_fee.calculate_fee(0).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(u64::MAX).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(1).unwrap());
-        assert_eq!(0, transfer_fee.calculate_fee(one).unwrap());
-    }
-
-    #[test]
-    fn calculate_fee_exact_out_max() {
-        let one = u64::try_from(ONE_IN_BASIS_POINTS).unwrap();
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(5_000),
-            transfer_fee_basis_points: PodU16::from(1),
-        };
-        let maximum_fee = u64::from(transfer_fee.maximum_fee);
-        // hit maximum fee
-        assert_eq!(
-            maximum_fee,
-            transfer_fee
-                .calculate_inverse_fee(u64::MAX - maximum_fee)
-                .unwrap()
-        );
-        // at exactly the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee
-                .calculate_inverse_fee(maximum_fee * one - maximum_fee)
-                .unwrap()
-        );
-        // one token above, normally rounds up, but we're at the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee
-                .calculate_inverse_fee(maximum_fee * one - maximum_fee + 1)
-                .unwrap()
-        );
-        // one token below, rounds up to the max
-        assert_eq!(
-            maximum_fee,
-            transfer_fee
-                .calculate_inverse_fee(maximum_fee * one - maximum_fee - 1)
-                .unwrap()
-        );
-    }
-
-    #[test]
-    fn calculate_pre_fee_amount_edge_cases() {
-        let maximum_fee = 5_000;
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(maximum_fee),
-            transfer_fee_basis_points: PodU16::from(u16::try_from(ONE_IN_BASIS_POINTS).unwrap()),
-        };
-
-        // 0 zero out, 0 in
-        assert_eq!(0, transfer_fee.calculate_pre_fee_amount(0).unwrap());
-
-        // cap at max fee
-        assert_eq!(
-            1 + maximum_fee,
-            transfer_fee.calculate_pre_fee_amount(1).unwrap()
-        );
-
-        // no fee same amount
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(maximum_fee),
-            transfer_fee_basis_points: PodU16::from(0),
-        };
-        assert_eq!(1, transfer_fee.calculate_pre_fee_amount(1).unwrap());
-    }
-
-    #[test]
-    fn calculate_fee_exact_out_min() {
-        let one = u64::try_from(ONE_IN_BASIS_POINTS).unwrap();
-        let transfer_fee = TransferFee {
-            epoch: PodU64::from(0),
-            maximum_fee: PodU64::from(5_000),
-            transfer_fee_basis_points: PodU16::from(1),
-        };
-        let minimum_fee = 1;
-        // hit minimum fee even with 1 token
-        assert_eq!(minimum_fee, transfer_fee.calculate_inverse_fee(1).unwrap());
-        // still minimum at 2 tokens
-        assert_eq!(minimum_fee, transfer_fee.calculate_inverse_fee(2).unwrap());
-        // still minimum at 9_999 tokens
-        assert_eq!(
-            minimum_fee,
-            transfer_fee.calculate_inverse_fee(one - 1).unwrap()
-        );
-        // 2 token fee at 10_000
-        assert_eq!(
-            minimum_fee + 1,
-            transfer_fee.calculate_inverse_fee(one).unwrap()
-        );
-        // zero is zero token
-        assert_eq!(0, transfer_fee.calculate_inverse_fee(0).unwrap());
-    }
-
-    proptest! {
-        #[test]
-        fn round_trip_fee_calculation(
-            transfer_fee_basis_points in 0u16..MAX_FEE_BASIS_POINTS,
-            maximum_fee in u64::MIN..=u64::MAX,
-            amount_in in 0..=u64::MAX
-        ) {
-            let transfer_fee = TransferFee {
-                epoch: PodU64::from(0),
-                maximum_fee: PodU64::from(maximum_fee),
-                transfer_fee_basis_points: PodU16::from(transfer_fee_basis_points),
-            };
-            let fee = transfer_fee.calculate_fee(amount_in).unwrap();
-            let amount_out = amount_in.checked_sub(fee).unwrap();
-            let fee_exact_out = transfer_fee.calculate_inverse_fee(amount_out).unwrap();
-            let diff = if fee > fee_exact_out {
-                fee - fee_exact_out
-            } else {
-                fee_exact_out - fee
-            };
-            // We lose precision with every division by 10000, so for huge amounts,
-            // the difference can be in the hundreds. This comes out to less than
-            // 1 / 10^15
-            let one = MAX_FEE_BASIS_POINTS as u64;
-            let precision = amount_in / one / one / one;
-            assert!(diff < precision, "diff is {} for precision {}", diff, precision);
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/transfer_fee/processor.rs b/token/program-2022/src/extension/transfer_fee/processor.rs
deleted file mode 100644
index 0e158f850a0..00000000000
--- a/token/program-2022/src/extension/transfer_fee/processor.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            transfer_fee::{
-                instruction::TransferFeeInstruction, TransferFee, TransferFeeAmount,
-                TransferFeeConfig, MAX_FEE_BASIS_POINTS,
-            },
-            BaseStateWithExtensions, BaseStateWithExtensionsMut, PodStateWithExtensions,
-            PodStateWithExtensionsMut,
-        },
-        pod::{PodAccount, PodMint},
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        clock::Clock,
-        entrypoint::ProgramResult,
-        msg,
-        program_option::COption,
-        pubkey::Pubkey,
-        sysvar::Sysvar,
-    },
-    std::convert::TryInto,
-};
-
-fn process_initialize_transfer_fee_config(
-    accounts: &[AccountInfo],
-    transfer_fee_config_authority: COption<Pubkey>,
-    withdraw_withheld_authority: COption<Pubkey>,
-    transfer_fee_basis_points: u16,
-    maximum_fee: u64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-    let extension = mint.init_extension::<TransferFeeConfig>(true)?;
-    extension.transfer_fee_config_authority = transfer_fee_config_authority.try_into()?;
-    extension.withdraw_withheld_authority = withdraw_withheld_authority.try_into()?;
-    extension.withheld_amount = 0u64.into();
-
-    if transfer_fee_basis_points > MAX_FEE_BASIS_POINTS {
-        return Err(TokenError::TransferFeeExceedsMaximum.into());
-    }
-    // To be safe, set newer and older transfer fees to the same thing on init,
-    // but only newer will actually be used
-    let epoch = Clock::get()?.epoch;
-    let transfer_fee = TransferFee {
-        epoch: epoch.into(),
-        transfer_fee_basis_points: transfer_fee_basis_points.into(),
-        maximum_fee: maximum_fee.into(),
-    };
-    extension.older_transfer_fee = transfer_fee;
-    extension.newer_transfer_fee = transfer_fee;
-
-    Ok(())
-}
-
-fn process_set_transfer_fee(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    transfer_fee_basis_points: u16,
-    maximum_fee: u64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<TransferFeeConfig>()?;
-
-    let transfer_fee_config_authority =
-        Option::<Pubkey>::from(extension.transfer_fee_config_authority)
-            .ok_or(TokenError::NoAuthorityExists)?;
-    Processor::validate_owner(
-        program_id,
-        &transfer_fee_config_authority,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    if transfer_fee_basis_points > MAX_FEE_BASIS_POINTS {
-        return Err(TokenError::TransferFeeExceedsMaximum.into());
-    }
-
-    // When setting the transfer fee, we have two situations:
-    // * newer transfer fee epoch <= current epoch: newer transfer fee is the active
-    //   one, so overwrite older transfer fee with newer, then overwrite newer
-    //   transfer fee
-    // * newer transfer fee epoch >= next epoch: it was never used, so just
-    //   overwrite next transfer fee
-    let epoch = Clock::get()?.epoch;
-    if u64::from(extension.newer_transfer_fee.epoch) <= epoch {
-        extension.older_transfer_fee = extension.newer_transfer_fee;
-    }
-    // set two epochs ahead to avoid rug pulls at the end of an epoch
-    let newer_fee_start_epoch = epoch.saturating_add(2);
-    let transfer_fee = TransferFee {
-        epoch: newer_fee_start_epoch.into(),
-        transfer_fee_basis_points: transfer_fee_basis_points.into(),
-        maximum_fee: maximum_fee.into(),
-    };
-    extension.newer_transfer_fee = transfer_fee;
-
-    Ok(())
-}
-
-fn process_withdraw_withheld_tokens_from_mint(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-
-    // unnecessary check, but helps for clarity
-    check_program_account(mint_account_info.owner)?;
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<TransferFeeConfig>()?;
-
-    let withdraw_withheld_authority = Option::<Pubkey>::from(extension.withdraw_withheld_authority)
-        .ok_or(TokenError::NoAuthorityExists)?;
-    Processor::validate_owner(
-        program_id,
-        &withdraw_withheld_authority,
-        authority_info,
-        authority_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    let mut destination_account_data = destination_account_info.data.borrow_mut();
-    let destination_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-    if destination_account.base.mint != *mint_account_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-    if destination_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-    let withheld_amount = u64::from(extension.withheld_amount);
-    extension.withheld_amount = 0.into();
-    destination_account.base.amount = u64::from(destination_account.base.amount)
-        .checked_add(withheld_amount)
-        .ok_or(TokenError::Overflow)?
-        .into();
-
-    Ok(())
-}
-
-fn harvest_from_account<'b>(
-    mint_key: &'b Pubkey,
-    token_account_info: &'b AccountInfo<'_>,
-) -> Result<u64, TokenError> {
-    let mut token_account_data = token_account_info.data.borrow_mut();
-    let mut token_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut token_account_data)
-            .map_err(|_| TokenError::InvalidState)?;
-    if token_account.base.mint != *mint_key {
-        return Err(TokenError::MintMismatch);
-    }
-    check_program_account(token_account_info.owner).map_err(|_| TokenError::InvalidState)?;
-    let token_account_extension = token_account
-        .get_extension_mut::<TransferFeeAmount>()
-        .map_err(|_| TokenError::InvalidState)?;
-    let account_withheld_amount = u64::from(token_account_extension.withheld_amount);
-    token_account_extension.withheld_amount = 0.into();
-    Ok(account_withheld_amount)
-}
-
-fn process_harvest_withheld_tokens_to_mint(accounts: &[AccountInfo]) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let token_account_infos = account_info_iter.as_slice();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let mint_extension = mint.get_extension_mut::<TransferFeeConfig>()?;
-
-    for token_account_info in token_account_infos {
-        match harvest_from_account(mint_account_info.key, token_account_info) {
-            Ok(amount) => {
-                let mint_withheld_amount = u64::from(mint_extension.withheld_amount);
-                mint_extension.withheld_amount = mint_withheld_amount
-                    .checked_add(amount)
-                    .ok_or(TokenError::Overflow)?
-                    .into();
-            }
-            Err(e) => {
-                msg!("Error harvesting from {}: {}", token_account_info.key, e);
-            }
-        }
-    }
-    Ok(())
-}
-
-fn process_withdraw_withheld_tokens_from_accounts(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    num_token_accounts: u8,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let authority_info_data_len = authority_info.data_len();
-    let account_infos = account_info_iter.as_slice();
-    let num_signers = account_infos
-        .len()
-        .saturating_sub(num_token_accounts as usize);
-
-    // unnecessary check, but helps for clarity
-    check_program_account(mint_account_info.owner)?;
-
-    let mint_data = mint_account_info.data.borrow();
-    let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-    let extension = mint.get_extension::<TransferFeeConfig>()?;
-
-    let withdraw_withheld_authority = Option::<Pubkey>::from(extension.withdraw_withheld_authority)
-        .ok_or(TokenError::NoAuthorityExists)?;
-    Processor::validate_owner(
-        program_id,
-        &withdraw_withheld_authority,
-        authority_info,
-        authority_info_data_len,
-        &account_infos[..num_signers],
-    )?;
-
-    let mut destination_account_data = destination_account_info.data.borrow_mut();
-    let mut destination_account =
-        PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-    if destination_account.base.mint != *mint_account_info.key {
-        return Err(TokenError::MintMismatch.into());
-    }
-    if destination_account.base.is_frozen() {
-        return Err(TokenError::AccountFrozen.into());
-    }
-    for account_info in &account_infos[num_signers..] {
-        // self-harvest, can't double-borrow the underlying data
-        if account_info.key == destination_account_info.key {
-            let token_account_extension = destination_account
-                .get_extension_mut::<TransferFeeAmount>()
-                .map_err(|_| TokenError::InvalidState)?;
-            let account_withheld_amount = u64::from(token_account_extension.withheld_amount);
-            token_account_extension.withheld_amount = 0.into();
-            destination_account.base.amount = u64::from(destination_account.base.amount)
-                .checked_add(account_withheld_amount)
-                .ok_or(TokenError::Overflow)?
-                .into();
-        } else {
-            match harvest_from_account(mint_account_info.key, account_info) {
-                Ok(amount) => {
-                    destination_account.base.amount = u64::from(destination_account.base.amount)
-                        .checked_add(amount)
-                        .ok_or(TokenError::Overflow)?
-                        .into();
-                }
-                Err(e) => {
-                    msg!("Error harvesting from {}: {}", account_info.key, e);
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let instruction = TransferFeeInstruction::unpack(input)?;
-    check_program_account(program_id)?;
-
-    match instruction {
-        TransferFeeInstruction::InitializeTransferFeeConfig {
-            transfer_fee_config_authority,
-            withdraw_withheld_authority,
-            transfer_fee_basis_points,
-            maximum_fee,
-        } => process_initialize_transfer_fee_config(
-            accounts,
-            transfer_fee_config_authority,
-            withdraw_withheld_authority,
-            transfer_fee_basis_points,
-            maximum_fee,
-        ),
-        TransferFeeInstruction::TransferCheckedWithFee {
-            amount,
-            decimals,
-            fee,
-        } => {
-            msg!("TransferFeeInstruction: TransferCheckedWithFee");
-            Processor::process_transfer(program_id, accounts, amount, Some(decimals), Some(fee))
-        }
-        TransferFeeInstruction::WithdrawWithheldTokensFromMint => {
-            msg!("TransferFeeInstruction: WithdrawWithheldTokensFromMint");
-            process_withdraw_withheld_tokens_from_mint(program_id, accounts)
-        }
-        TransferFeeInstruction::WithdrawWithheldTokensFromAccounts { num_token_accounts } => {
-            msg!("TransferFeeInstruction: WithdrawWithheldTokensFromAccounts");
-            process_withdraw_withheld_tokens_from_accounts(program_id, accounts, num_token_accounts)
-        }
-        TransferFeeInstruction::HarvestWithheldTokensToMint => {
-            msg!("TransferFeeInstruction: HarvestWithheldTokensToMint");
-            process_harvest_withheld_tokens_to_mint(accounts)
-        }
-        TransferFeeInstruction::SetTransferFee {
-            transfer_fee_basis_points,
-            maximum_fee,
-        } => {
-            msg!("TransferFeeInstruction: SetTransferFee");
-            process_set_transfer_fee(program_id, accounts, transfer_fee_basis_points, maximum_fee)
-        }
-    }
-}
diff --git a/token/program-2022/src/extension/transfer_hook/instruction.rs b/token/program-2022/src/extension/transfer_hook/instruction.rs
deleted file mode 100644
index 735b2866899..00000000000
--- a/token/program-2022/src/extension/transfer_hook/instruction.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        check_program_account,
-        instruction::{encode_instruction, TokenInstruction},
-    },
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-    std::convert::TryInto,
-};
-
-/// Transfer hook extension instructions
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
-#[repr(u8)]
-pub enum TransferHookInstruction {
-    /// Initialize a new mint with a transfer hook program.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::transfer_hook::instruction::InitializeInstructionData`
-    Initialize,
-    /// Update the transfer hook program id. Only supported for mints that
-    /// include the `TransferHook` extension.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[signer]` The transfer hook authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[]` The mint's transfer hook authority.
-    ///   2. ..2+M `[signer]` M signer accounts.
-    ///
-    /// Data expected by this instruction:
-    ///   `crate::extension::transfer_hook::UpdateInstructionData`
-    Update,
-}
-
-/// Data expected by `Initialize`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct InitializeInstructionData {
-    /// The public key for the account that can update the program id
-    pub authority: OptionalNonZeroPubkey,
-    /// The program id that performs logic during transfers
-    pub program_id: OptionalNonZeroPubkey,
-}
-
-/// Data expected by `Update`
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-pub struct UpdateInstructionData {
-    /// The program id that performs logic during transfers
-    pub program_id: OptionalNonZeroPubkey,
-}
-
-/// Create an `Initialize` instruction
-pub fn initialize(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: Option<Pubkey>,
-    transfer_hook_program_id: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let accounts = vec![AccountMeta::new(*mint, false)];
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::TransferHookExtension,
-        TransferHookInstruction::Initialize,
-        &InitializeInstructionData {
-            authority: authority.try_into()?,
-            program_id: transfer_hook_program_id.try_into()?,
-        },
-    ))
-}
-
-/// Create an `Update` instruction
-pub fn update(
-    token_program_id: &Pubkey,
-    mint: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-    transfer_hook_program_id: Option<Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let mut accounts = vec![
-        AccountMeta::new(*mint, false),
-        AccountMeta::new_readonly(*authority, signers.is_empty()),
-    ];
-    for signer_pubkey in signers.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-    Ok(encode_instruction(
-        token_program_id,
-        accounts,
-        TokenInstruction::TransferHookExtension,
-        TransferHookInstruction::Update,
-        &UpdateInstructionData {
-            program_id: transfer_hook_program_id.try_into()?,
-        },
-    ))
-}
diff --git a/token/program-2022/src/extension/transfer_hook/mod.rs b/token/program-2022/src/extension/transfer_hook/mod.rs
deleted file mode 100644
index be896bb65e6..00000000000
--- a/token/program-2022/src/extension/transfer_hook/mod.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-#[cfg(feature = "serde-traits")]
-use serde::{Deserialize, Serialize};
-use {
-    crate::{
-        extension::{
-            BaseState, BaseStateWithExtensions, BaseStateWithExtensionsMut, Extension,
-            ExtensionType, PodStateWithExtensionsMut,
-        },
-        pod::PodAccount,
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
-    spl_pod::{optional_keys::OptionalNonZeroPubkey, primitives::PodBool},
-};
-
-/// Instructions for the TransferHook extension
-pub mod instruction;
-/// Instruction processor for the TransferHook extension
-pub mod processor;
-
-/// Transfer hook extension data for mints.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct TransferHook {
-    /// Authority that can set the transfer hook program id
-    pub authority: OptionalNonZeroPubkey,
-    /// Program that authorizes the transfer
-    pub program_id: OptionalNonZeroPubkey,
-}
-
-/// Indicates that the tokens from this account belong to a mint with a transfer
-/// hook
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-#[repr(transparent)]
-pub struct TransferHookAccount {
-    /// Flag to indicate that the account is in the middle of a transfer
-    pub transferring: PodBool,
-}
-
-impl Extension for TransferHook {
-    const TYPE: ExtensionType = ExtensionType::TransferHook;
-}
-
-impl Extension for TransferHookAccount {
-    const TYPE: ExtensionType = ExtensionType::TransferHookAccount;
-}
-
-/// Attempts to get the transfer hook program id from the TLV data, returning
-/// None if the extension is not found
-pub fn get_program_id<S: BaseState, BSE: BaseStateWithExtensions<S>>(
-    state: &BSE,
-) -> Option<Pubkey> {
-    state
-        .get_extension::<TransferHook>()
-        .ok()
-        .and_then(|e| Option::<Pubkey>::from(e.program_id))
-}
-
-/// Helper function to set the transferring flag before calling into transfer
-/// hook
-pub fn set_transferring<BSE: BaseStateWithExtensionsMut<S>, S: BaseState>(
-    account: &mut BSE,
-) -> Result<(), ProgramError> {
-    let account_extension = account.get_extension_mut::<TransferHookAccount>()?;
-    account_extension.transferring = true.into();
-    Ok(())
-}
-
-/// Helper function to unset the transferring flag after a transfer
-pub fn unset_transferring(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    let mut account_data = account_info.data.borrow_mut();
-    let mut account = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut account_data)?;
-    let account_extension = account.get_extension_mut::<TransferHookAccount>()?;
-    account_extension.transferring = false.into();
-    Ok(())
-}
diff --git a/token/program-2022/src/extension/transfer_hook/processor.rs b/token/program-2022/src/extension/transfer_hook/processor.rs
deleted file mode 100644
index 4eb63c120f6..00000000000
--- a/token/program-2022/src/extension/transfer_hook/processor.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use {
-    crate::{
-        check_program_account,
-        error::TokenError,
-        extension::{
-            transfer_hook::{
-                instruction::{
-                    InitializeInstructionData, TransferHookInstruction, UpdateInstructionData,
-                },
-                TransferHook,
-            },
-            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
-        },
-        instruction::{decode_instruction_data, decode_instruction_type},
-        pod::PodMint,
-        processor::Processor,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
-};
-
-fn process_initialize(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    authority: &OptionalNonZeroPubkey,
-    transfer_hook_program_id: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-
-    let extension = mint.init_extension::<TransferHook>(true)?;
-    extension.authority = *authority;
-
-    if let Some(transfer_hook_program_id) = Option::<Pubkey>::from(*transfer_hook_program_id) {
-        if transfer_hook_program_id == *program_id {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-    } else if Option::<Pubkey>::from(*authority).is_none() {
-        msg!("The transfer hook extension requires at least an authority or a program id for initialization, neither was provided");
-        Err(TokenError::InvalidInstruction)?;
-    }
-    extension.program_id = *transfer_hook_program_id;
-    Ok(())
-}
-
-fn process_update(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    new_program_id: &OptionalNonZeroPubkey,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-    let mint_account_info = next_account_info(account_info_iter)?;
-    let owner_info = next_account_info(account_info_iter)?;
-    let owner_info_data_len = owner_info.data_len();
-
-    let mut mint_data = mint_account_info.data.borrow_mut();
-    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-    let extension = mint.get_extension_mut::<TransferHook>()?;
-    let authority =
-        Option::<Pubkey>::from(extension.authority).ok_or(TokenError::NoAuthorityExists)?;
-
-    Processor::validate_owner(
-        program_id,
-        &authority,
-        owner_info,
-        owner_info_data_len,
-        account_info_iter.as_slice(),
-    )?;
-
-    if let Some(new_program_id) = Option::<Pubkey>::from(*new_program_id) {
-        if new_program_id == *program_id {
-            return Err(ProgramError::IncorrectProgramId);
-        }
-    }
-
-    extension.program_id = *new_program_id;
-    Ok(())
-}
-
-pub(crate) fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    check_program_account(program_id)?;
-    match decode_instruction_type(input)? {
-        TransferHookInstruction::Initialize => {
-            msg!("TransferHookInstruction::Initialize");
-            let InitializeInstructionData {
-                authority,
-                program_id: transfer_hook_program_id,
-            } = decode_instruction_data(input)?;
-            process_initialize(program_id, accounts, authority, transfer_hook_program_id)
-        }
-        TransferHookInstruction::Update => {
-            msg!("TransferHookInstruction::Update");
-            let UpdateInstructionData {
-                program_id: transfer_hook_program_id,
-            } = decode_instruction_data(input)?;
-            process_update(program_id, accounts, transfer_hook_program_id)
-        }
-    }
-}
diff --git a/token/program-2022/src/generic_token_account.rs b/token/program-2022/src/generic_token_account.rs
deleted file mode 100644
index 69496c95e83..00000000000
--- a/token/program-2022/src/generic_token_account.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-//! Generic Token Account, copied from spl_token::state
-// Remove all of this and use spl-token's version once token 3.4.0 is released
-use {
-    crate::state::AccountState,
-    solana_program::pubkey::{Pubkey, PUBKEY_BYTES},
-};
-
-const SPL_TOKEN_ACCOUNT_MINT_OFFSET: usize = 0;
-const SPL_TOKEN_ACCOUNT_OWNER_OFFSET: usize = 32;
-
-/// A trait for token Account structs to enable efficiently unpacking various
-/// fields without unpacking the complete state.
-pub trait GenericTokenAccount {
-    /// Check if the account data is a valid token account
-    fn valid_account_data(account_data: &[u8]) -> bool;
-
-    /// Call after account length has already been verified to unpack the
-    /// account owner
-    fn unpack_account_owner_unchecked(account_data: &[u8]) -> &Pubkey {
-        Self::unpack_pubkey_unchecked(account_data, SPL_TOKEN_ACCOUNT_OWNER_OFFSET)
-    }
-
-    /// Call after account length has already been verified to unpack the
-    /// account mint
-    fn unpack_account_mint_unchecked(account_data: &[u8]) -> &Pubkey {
-        Self::unpack_pubkey_unchecked(account_data, SPL_TOKEN_ACCOUNT_MINT_OFFSET)
-    }
-
-    /// Call after account length has already been verified to unpack a Pubkey
-    /// at the specified offset. Panics if `account_data.len()` is less than
-    /// `PUBKEY_BYTES`
-    fn unpack_pubkey_unchecked(account_data: &[u8], offset: usize) -> &Pubkey {
-        bytemuck::from_bytes(&account_data[offset..offset + PUBKEY_BYTES])
-    }
-
-    /// Unpacks an account's owner from opaque account data.
-    fn unpack_account_owner(account_data: &[u8]) -> Option<&Pubkey> {
-        if Self::valid_account_data(account_data) {
-            Some(Self::unpack_account_owner_unchecked(account_data))
-        } else {
-            None
-        }
-    }
-
-    /// Unpacks an account's mint from opaque account data.
-    fn unpack_account_mint(account_data: &[u8]) -> Option<&Pubkey> {
-        if Self::valid_account_data(account_data) {
-            Some(Self::unpack_account_mint_unchecked(account_data))
-        } else {
-            None
-        }
-    }
-}
-
-/// The offset of state field in Account's C representation
-pub const ACCOUNT_INITIALIZED_INDEX: usize = 108;
-
-/// Check if the account data buffer represents an initialized account.
-/// This is checking the `state` (AccountState) field of an Account object.
-pub fn is_initialized_account(account_data: &[u8]) -> bool {
-    *account_data
-        .get(ACCOUNT_INITIALIZED_INDEX)
-        .unwrap_or(&(AccountState::Uninitialized as u8))
-        != AccountState::Uninitialized as u8
-}
diff --git a/token/program-2022/src/instruction.rs b/token/program-2022/src/instruction.rs
deleted file mode 100644
index 9b2cb55109b..00000000000
--- a/token/program-2022/src/instruction.rs
+++ /dev/null
@@ -1,2781 +0,0 @@
-//! Instruction types
-
-// Needed to avoid deprecation warning when generating serde implementation for
-// TokenInstruction
-#![allow(deprecated)]
-
-#[cfg(feature = "serde-traits")]
-use {
-    crate::serialization::coption_fromstr,
-    serde::{Deserialize, Serialize},
-    serde_with::{As, DisplayFromStr},
-};
-use {
-    crate::{
-        check_program_account, check_spl_token_program_account, error::TokenError,
-        extension::ExtensionType,
-    },
-    bytemuck::Pod,
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::{Pubkey, PUBKEY_BYTES},
-        system_program, sysvar,
-    },
-    spl_pod::bytemuck::{pod_from_bytes, pod_get_packed_len},
-    std::{
-        convert::{TryFrom, TryInto},
-        mem::size_of,
-    },
-};
-
-/// Minimum number of multisignature signers (min N)
-pub const MIN_SIGNERS: usize = 1;
-/// Maximum number of multisignature signers (max N)
-pub const MAX_SIGNERS: usize = 11;
-/// Serialized length of a u16, for unpacking
-const U16_BYTES: usize = 2;
-/// Serialized length of a u64, for unpacking
-const U64_BYTES: usize = 8;
-
-/// Instructions supported by the token program.
-#[repr(C)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(
-    feature = "serde-traits",
-    serde(rename_all_fields = "camelCase", rename_all = "camelCase")
-)]
-#[derive(Clone, Debug, PartialEq)]
-pub enum TokenInstruction<'a> {
-    // 0
-    /// Initializes a new mint and optionally deposits all the newly minted
-    /// tokens in an account.
-    ///
-    /// The `InitializeMint` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// All extensions must be initialized before calling this instruction.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///   1. `[]` Rent sysvar
-    InitializeMint {
-        /// Number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-        /// The authority/multisignature to mint tokens.
-        #[cfg_attr(feature = "serde-traits", serde(with = "As::<DisplayFromStr>"))]
-        mint_authority: Pubkey,
-        /// The freeze authority/multisignature of the mint.
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        freeze_authority: COption<Pubkey>,
-    },
-    /// Initializes a new account to hold tokens.  If this account is associated
-    /// with the native mint then the token balance of the initialized account
-    /// will be equal to the amount of SOL in the account. If this account is
-    /// associated with another mint, that mint must be initialized before this
-    /// command can succeed.
-    ///
-    /// The `InitializeAccount` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    ///   2. `[]` The new account's owner/multisignature.
-    ///   3. `[]` Rent sysvar
-    InitializeAccount,
-    /// Initializes a multisignature account with N provided signers.
-    ///
-    /// Multisignature accounts can used in place of any single owner/delegate
-    /// accounts in any token instruction that require an owner/delegate to be
-    /// present.  The variant field represents the number of signers (M)
-    /// required to validate this multisignature account.
-    ///
-    /// The `InitializeMultisig` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The multisignature account to initialize.
-    ///   1. `[]` Rent sysvar
-    ///   2. ..2+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-    ///      11.
-    InitializeMultisig {
-        /// The number of signers (M) required to validate this multisignature
-        /// account.
-        m: u8,
-    },
-    /// NOTE This instruction is deprecated in favor of `TransferChecked` or
-    /// `TransferCheckedWithFee`
-    ///
-    /// Transfers tokens from one account to another either directly or via a
-    /// delegate.  If this account is associated with the native mint then equal
-    /// amounts of SOL and Tokens will be transferred to the destination
-    /// account.
-    ///
-    /// If either account contains an `TransferFeeAmount` extension, this will
-    /// fail. Mints with the `TransferFeeConfig` extension are required in
-    /// order to assess the fee.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[signer]` The source account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The source account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    #[deprecated(
-        since = "4.0.0",
-        note = "please use `TransferChecked` or `TransferCheckedWithFee` instead"
-    )]
-    Transfer {
-        /// The amount of tokens to transfer.
-        amount: u64,
-    },
-    /// Approves a delegate.  A delegate is given the authority over tokens on
-    /// behalf of the source account's owner.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The delegate.
-    ///   2. `[signer]` The source account owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The delegate.
-    ///   2. `[]` The source account's multisignature owner.
-    ///   3. ..3+M `[signer]` M signer accounts
-    Approve {
-        /// The amount of tokens the delegate is approved for.
-        amount: u64,
-    },
-    // 5
-    /// Revokes the delegate's authority.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[signer]` The source account owner or current delegate.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The source account's multisignature owner or current delegate.
-    ///   2. ..2+M `[signer]` M signer accounts
-    Revoke,
-    /// Sets a new authority of a mint or account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint or account to change the authority of.
-    ///   1. `[signer]` The current authority of the mint or account.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint or account to change the authority of.
-    ///   1. `[]` The mint's or account's current multisignature authority.
-    ///   2. ..2+M `[signer]` M signer accounts
-    SetAuthority {
-        /// The type of authority to update.
-        authority_type: AuthorityType,
-        /// The new authority
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        new_authority: COption<Pubkey>,
-    },
-    /// Mints new tokens to an account.  The native mint does not support
-    /// minting.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[signer]` The mint's minting authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[]` The mint's multisignature mint-tokens authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    MintTo {
-        /// The amount of new tokens to mint.
-        amount: u64,
-    },
-    /// Burns tokens by removing them from an account.  `Burn` does not support
-    /// accounts associated with the native mint, use `CloseAccount` instead.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[signer]` The account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[]` The account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    Burn {
-        /// The amount of tokens to burn.
-        amount: u64,
-    },
-    /// Close an account by transferring all its SOL to the destination account.
-    /// Non-native accounts may only be closed if its token amount is zero.
-    ///
-    /// Accounts with the `TransferFeeAmount` extension may only be closed if
-    /// the withheld amount is zero.
-    ///
-    /// Accounts with the `ConfidentialTransfer` extension may only be closed if
-    /// the pending and available balance ciphertexts are empty. Use
-    /// `ConfidentialTransferInstruction::ApplyPendingBalance` and
-    /// `ConfidentialTransferInstruction::EmptyAccount` to empty these
-    /// ciphertexts.
-    ///
-    /// Accounts with the `ConfidentialTransferFee` extension may only be closed
-    /// if the withheld amount ciphertext is empty. Use
-    /// `ConfidentialTransferFeeInstruction::HarvestWithheldTokensToMint` to
-    /// empty this ciphertext.
-    ///
-    /// Mints may be closed if they have the `MintCloseAuthority` extension and
-    /// their token supply is zero
-    ///
-    /// Accounts
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to close.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to close.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The account's multisignature owner.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    CloseAccount,
-    // 10
-    /// Freeze an Initialized account using the Mint's freeze_authority (if
-    /// set).
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[signer]` The mint freeze authority.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The mint's multisignature freeze authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    FreezeAccount,
-    /// Thaw a Frozen account using the Mint's freeze_authority (if set).
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[signer]` The mint freeze authority.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The mint's multisignature freeze authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    ThawAccount,
-
-    /// Transfers tokens from one account to another either directly or via a
-    /// delegate.  If this account is associated with the native mint then equal
-    /// amounts of SOL and Tokens will be transferred to the destination
-    /// account.
-    ///
-    /// This instruction differs from Transfer in that the token mint and
-    /// decimals value is checked by the caller.  This may be useful when
-    /// creating transactions offline or within a hardware wallet.
-    ///
-    /// If either account contains an `TransferFeeAmount` extension, the fee is
-    /// withheld in the destination account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[writable]` The destination account.
-    ///   3. `[signer]` The source account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[writable]` The destination account.
-    ///   3. `[]` The source account's multisignature owner/delegate.
-    ///   4. ..4+M `[signer]` M signer accounts.
-    TransferChecked {
-        /// The amount of tokens to transfer.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Approves a delegate.  A delegate is given the authority over tokens on
-    /// behalf of the source account's owner.
-    ///
-    /// This instruction differs from Approve in that the token mint and
-    /// decimals value is checked by the caller.  This may be useful when
-    /// creating transactions offline or within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The delegate.
-    ///   3. `[signer]` The source account owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The delegate.
-    ///   3. `[]` The source account's multisignature owner.
-    ///   4. ..4+M `[signer]` M signer accounts
-    ApproveChecked {
-        /// The amount of tokens the delegate is approved for.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Mints new tokens to an account.  The native mint does not support
-    /// minting.
-    ///
-    /// This instruction differs from MintTo in that the decimals value is
-    /// checked by the caller.  This may be useful when creating transactions
-    /// offline or within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[signer]` The mint's minting authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[]` The mint's multisignature mint-tokens authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    MintToChecked {
-        /// The amount of new tokens to mint.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    // 15
-    /// Burns tokens by removing them from an account.  `BurnChecked` does not
-    /// support accounts associated with the native mint, use `CloseAccount`
-    /// instead.
-    ///
-    /// This instruction differs from Burn in that the decimals value is checked
-    /// by the caller. This may be useful when creating transactions offline or
-    /// within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[signer]` The account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[]` The account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    BurnChecked {
-        /// The amount of tokens to burn.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Like InitializeAccount, but the owner pubkey is passed via instruction
-    /// data rather than the accounts list. This variant may be preferable
-    /// when using Cross Program Invocation from an instruction that does
-    /// not need the owner's `AccountInfo` otherwise.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    ///   2. `[]` Rent sysvar
-    InitializeAccount2 {
-        /// The new account's owner/multisignature.
-        #[cfg_attr(feature = "serde-traits", serde(with = "As::<DisplayFromStr>"))]
-        owner: Pubkey,
-    },
-    /// Given a wrapped / native token account (a token account containing SOL)
-    /// updates its amount field based on the account's underlying `lamports`.
-    /// This is useful if a non-wrapped SOL account uses
-    /// `system_instruction::transfer` to move lamports to a wrapped token
-    /// account, and needs to have its token `amount` field updated.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The native token account to sync with its underlying
-    ///      lamports.
-    SyncNative,
-    /// Like InitializeAccount2, but does not require the Rent sysvar to be
-    /// provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    InitializeAccount3 {
-        /// The new account's owner/multisignature.
-        #[cfg_attr(feature = "serde-traits", serde(with = "As::<DisplayFromStr>"))]
-        owner: Pubkey,
-    },
-    /// Like InitializeMultisig, but does not require the Rent sysvar to be
-    /// provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The multisignature account to initialize.
-    ///   1. ..1+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-    ///      11.
-    InitializeMultisig2 {
-        /// The number of signers (M) required to validate this multisignature
-        /// account.
-        m: u8,
-    },
-    // 20
-    /// Like InitializeMint, but does not require the Rent sysvar to be provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    InitializeMint2 {
-        /// Number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-        /// The authority/multisignature to mint tokens.
-        #[cfg_attr(feature = "serde-traits", serde(with = "As::<DisplayFromStr>"))]
-        mint_authority: Pubkey,
-        /// The freeze authority/multisignature of the mint.
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        freeze_authority: COption<Pubkey>,
-    },
-    /// Gets the required size of an account for the given mint as a
-    /// little-endian `u64`.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserializing
-    /// the return data as a little-endian `u64`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    GetAccountDataSize {
-        /// Additional extension types to include in the returned account size
-        extension_types: Vec<ExtensionType>,
-    },
-    /// Initialize the Immutable Owner extension for the given token account
-    ///
-    /// Fails if the account has already been initialized, so must be called
-    /// before `InitializeAccount`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    InitializeImmutableOwner,
-    /// Convert an Amount of tokens to a UiAmount `string`, using the given
-    /// mint.
-    ///
-    /// Fails on an invalid mint.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserialized
-    /// with `String::from_utf8`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    AmountToUiAmount {
-        /// The amount of tokens to convert.
-        amount: u64,
-    },
-    /// Convert a UiAmount of tokens to a little-endian `u64` raw Amount, using
-    /// the given mint.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserializing
-    /// the return data as a little-endian `u64`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    UiAmountToAmount {
-        /// The ui_amount of tokens to convert.
-        ui_amount: &'a str,
-    },
-    // 25
-    /// Initialize the close account authority on a new mint.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    InitializeMintCloseAuthority {
-        /// Authority that must sign the `CloseAccount` instruction on a mint
-        #[cfg_attr(feature = "serde-traits", serde(with = "coption_fromstr"))]
-        close_authority: COption<Pubkey>,
-    },
-    /// The common instruction prefix for Transfer Fee extension instructions.
-    ///
-    /// See `extension::transfer_fee::instruction::TransferFeeInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    TransferFeeExtension,
-    /// The common instruction prefix for Confidential Transfer extension
-    /// instructions.
-    ///
-    /// See `extension::confidential_transfer::instruction::ConfidentialTransferInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    ConfidentialTransferExtension,
-    /// The common instruction prefix for Default Account State extension
-    /// instructions.
-    ///
-    /// See `extension::default_account_state::instruction::DefaultAccountStateInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    DefaultAccountStateExtension,
-    /// Check to see if a token account is large enough for a list of
-    /// ExtensionTypes, and if not, use reallocation to increase the data
-    /// size.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to reallocate.
-    ///   1. `[signer, writable]` The payer account to fund reallocation
-    ///   2. `[]` System program for reallocation funding
-    ///   3. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to reallocate.
-    ///   1. `[signer, writable]` The payer account to fund reallocation
-    ///   2. `[]` System program for reallocation funding
-    ///   3. `[]` The account's multisignature owner/delegate.
-    ///   4. ..4+M `[signer]` M signer accounts.
-    Reallocate {
-        /// New extension types to include in the reallocated account
-        extension_types: Vec<ExtensionType>,
-    },
-    // 30
-    /// The common instruction prefix for Memo Transfer account extension
-    /// instructions.
-    ///
-    /// See `extension::memo_transfer::instruction::RequiredMemoTransfersInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    MemoTransferExtension,
-    /// Creates the native mint.
-    ///
-    /// This instruction only needs to be invoked once after deployment and is
-    /// permissionless, Wrapped SOL (`native_mint::id()`) will not be
-    /// available until this instruction is successfully executed.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writeable,signer]` Funding account (must be a system account)
-    ///   1. `[writable]` The native mint address
-    ///   2. `[]` System program for mint account funding
-    CreateNativeMint,
-    /// Initialize the non transferable extension for the given mint account
-    ///
-    /// Fails if the account has already been initialized, so must be called
-    /// before `InitializeMint`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The mint account to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    InitializeNonTransferableMint,
-    /// The common instruction prefix for Interest Bearing extension
-    /// instructions.
-    ///
-    /// See `extension::interest_bearing_mint::instruction::InterestBearingMintInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    InterestBearingMintExtension,
-    /// The common instruction prefix for CPI Guard account extension
-    /// instructions.
-    ///
-    /// See `extension::cpi_guard::instruction::CpiGuardInstruction` for
-    /// further details about the extended instructions that share this
-    /// instruction prefix
-    CpiGuardExtension,
-    // 35
-    /// Initialize the permanent delegate on a new mint.
-    ///
-    /// Fails if the mint has already been initialized, so must be called before
-    /// `InitializeMint`.
-    ///
-    /// The mint must have exactly enough space allocated for the base mint (82
-    /// bytes), plus 83 bytes of padding, 1 byte reserved for the account type,
-    /// then space required for this extension, plus any others.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   Pubkey for the permanent delegate
-    InitializePermanentDelegate {
-        /// Authority that may sign for `Transfer`s and `Burn`s on any account
-        #[cfg_attr(feature = "serde-traits", serde(with = "As::<DisplayFromStr>"))]
-        delegate: Pubkey,
-    },
-    /// The common instruction prefix for transfer hook extension instructions.
-    ///
-    /// See `extension::transfer_hook::instruction::TransferHookInstruction`
-    /// for further details about the extended instructions that share this
-    /// instruction prefix
-    TransferHookExtension,
-    /// The common instruction prefix for the confidential transfer fee
-    /// extension instructions.
-    ///
-    /// See `extension::confidential_transfer_fee::instruction::ConfidentialTransferFeeInstruction`
-    /// for further details about the extended instructions that share this
-    /// instruction prefix
-    ConfidentialTransferFeeExtension,
-    /// This instruction is to be used to rescue SOLs sent to any TokenProgram
-    /// owned account by sending them to any other account, leaving behind only
-    /// lamports for rent exemption.
-    ///
-    /// 0. `[writable]` Source Account owned by the token program
-    /// 1. `[writable]` Destination account
-    /// 2. `[signer]` Authority
-    /// 3. ..2+M `[signer]` M signer accounts.
-    WithdrawExcessLamports,
-    /// The common instruction prefix for metadata pointer extension
-    /// instructions.
-    ///
-    /// See `extension::metadata_pointer::instruction::MetadataPointerInstruction`
-    /// for further details about the extended instructions that share this
-    /// instruction prefix
-    MetadataPointerExtension,
-    // 40
-    /// The common instruction prefix for group pointer extension instructions.
-    ///
-    /// See `extension::group_pointer::instruction::GroupPointerInstruction`
-    /// for further details about the extended instructions that share this
-    /// instruction prefix
-    GroupPointerExtension,
-    /// The common instruction prefix for group member pointer extension
-    /// instructions.
-    ///
-    /// See `extension::group_member_pointer::instruction::GroupMemberPointerInstruction`
-    /// for further details about the extended instructions that share this
-    /// instruction prefix
-    GroupMemberPointerExtension,
-}
-impl<'a> TokenInstruction<'a> {
-    /// Unpacks a byte buffer into a
-    /// [TokenInstruction](enum.TokenInstruction.html).
-    pub fn unpack(input: &'a [u8]) -> Result<Self, ProgramError> {
-        use TokenError::InvalidInstruction;
-
-        let (&tag, rest) = input.split_first().ok_or(InvalidInstruction)?;
-        Ok(match tag {
-            0 => {
-                let (&decimals, rest) = rest.split_first().ok_or(InvalidInstruction)?;
-                let (mint_authority, rest) = Self::unpack_pubkey(rest)?;
-                let (freeze_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-                Self::InitializeMint {
-                    mint_authority,
-                    freeze_authority,
-                    decimals,
-                }
-            }
-            1 => Self::InitializeAccount,
-            2 => {
-                let &m = rest.first().ok_or(InvalidInstruction)?;
-                Self::InitializeMultisig { m }
-            }
-            3 | 4 | 7 | 8 => {
-                let amount = rest
-                    .get(..U64_BYTES)
-                    .and_then(|slice| slice.try_into().ok())
-                    .map(u64::from_le_bytes)
-                    .ok_or(InvalidInstruction)?;
-                match tag {
-                    #[allow(deprecated)]
-                    3 => Self::Transfer { amount },
-                    4 => Self::Approve { amount },
-                    7 => Self::MintTo { amount },
-                    8 => Self::Burn { amount },
-                    _ => unreachable!(),
-                }
-            }
-            5 => Self::Revoke,
-            6 => {
-                let (authority_type, rest) = rest
-                    .split_first()
-                    .ok_or_else(|| ProgramError::from(InvalidInstruction))
-                    .and_then(|(&t, rest)| Ok((AuthorityType::from(t)?, rest)))?;
-                let (new_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-
-                Self::SetAuthority {
-                    authority_type,
-                    new_authority,
-                }
-            }
-            9 => Self::CloseAccount,
-            10 => Self::FreezeAccount,
-            11 => Self::ThawAccount,
-            12 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::TransferChecked { amount, decimals }
-            }
-            13 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::ApproveChecked { amount, decimals }
-            }
-            14 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::MintToChecked { amount, decimals }
-            }
-            15 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::BurnChecked { amount, decimals }
-            }
-            16 => {
-                let (owner, _rest) = Self::unpack_pubkey(rest)?;
-                Self::InitializeAccount2 { owner }
-            }
-            17 => Self::SyncNative,
-            18 => {
-                let (owner, _rest) = Self::unpack_pubkey(rest)?;
-                Self::InitializeAccount3 { owner }
-            }
-            19 => {
-                let &m = rest.first().ok_or(InvalidInstruction)?;
-                Self::InitializeMultisig2 { m }
-            }
-            20 => {
-                let (&decimals, rest) = rest.split_first().ok_or(InvalidInstruction)?;
-                let (mint_authority, rest) = Self::unpack_pubkey(rest)?;
-                let (freeze_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-                Self::InitializeMint2 {
-                    mint_authority,
-                    freeze_authority,
-                    decimals,
-                }
-            }
-            21 => {
-                let mut extension_types = vec![];
-                for chunk in rest.chunks(size_of::<ExtensionType>()) {
-                    extension_types.push(chunk.try_into()?);
-                }
-                Self::GetAccountDataSize { extension_types }
-            }
-            22 => Self::InitializeImmutableOwner,
-            23 => {
-                let (amount, _rest) = Self::unpack_u64(rest)?;
-                Self::AmountToUiAmount { amount }
-            }
-            24 => {
-                let ui_amount = std::str::from_utf8(rest).map_err(|_| InvalidInstruction)?;
-                Self::UiAmountToAmount { ui_amount }
-            }
-            25 => {
-                let (close_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-                Self::InitializeMintCloseAuthority { close_authority }
-            }
-            26 => Self::TransferFeeExtension,
-            27 => Self::ConfidentialTransferExtension,
-            28 => Self::DefaultAccountStateExtension,
-            29 => {
-                let mut extension_types = vec![];
-                for chunk in rest.chunks(size_of::<ExtensionType>()) {
-                    extension_types.push(chunk.try_into()?);
-                }
-                Self::Reallocate { extension_types }
-            }
-            30 => Self::MemoTransferExtension,
-            31 => Self::CreateNativeMint,
-            32 => Self::InitializeNonTransferableMint,
-            33 => Self::InterestBearingMintExtension,
-            34 => Self::CpiGuardExtension,
-            35 => {
-                let (delegate, _rest) = Self::unpack_pubkey(rest)?;
-                Self::InitializePermanentDelegate { delegate }
-            }
-            36 => Self::TransferHookExtension,
-            37 => Self::ConfidentialTransferFeeExtension,
-            38 => Self::WithdrawExcessLamports,
-            39 => Self::MetadataPointerExtension,
-            40 => Self::GroupPointerExtension,
-            41 => Self::GroupMemberPointerExtension,
-            _ => return Err(TokenError::InvalidInstruction.into()),
-        })
-    }
-
-    /// Packs a [TokenInstruction](enum.TokenInstruction.html) into a byte
-    /// buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = Vec::with_capacity(size_of::<Self>());
-        match self {
-            &Self::InitializeMint {
-                ref mint_authority,
-                ref freeze_authority,
-                decimals,
-            } => {
-                buf.push(0);
-                buf.push(decimals);
-                buf.extend_from_slice(mint_authority.as_ref());
-                Self::pack_pubkey_option(freeze_authority, &mut buf);
-            }
-            Self::InitializeAccount => buf.push(1),
-            &Self::InitializeMultisig { m } => {
-                buf.push(2);
-                buf.push(m);
-            }
-            #[allow(deprecated)]
-            &Self::Transfer { amount } => {
-                buf.push(3);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::Approve { amount } => {
-                buf.push(4);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::MintTo { amount } => {
-                buf.push(7);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::Burn { amount } => {
-                buf.push(8);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            Self::Revoke => buf.push(5),
-            Self::SetAuthority {
-                authority_type,
-                ref new_authority,
-            } => {
-                buf.push(6);
-                buf.push(authority_type.into());
-                Self::pack_pubkey_option(new_authority, &mut buf);
-            }
-            Self::CloseAccount => buf.push(9),
-            Self::FreezeAccount => buf.push(10),
-            Self::ThawAccount => buf.push(11),
-            &Self::TransferChecked { amount, decimals } => {
-                buf.push(12);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::ApproveChecked { amount, decimals } => {
-                buf.push(13);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::MintToChecked { amount, decimals } => {
-                buf.push(14);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::BurnChecked { amount, decimals } => {
-                buf.push(15);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::InitializeAccount2 { owner } => {
-                buf.push(16);
-                buf.extend_from_slice(owner.as_ref());
-            }
-            &Self::SyncNative => {
-                buf.push(17);
-            }
-            &Self::InitializeAccount3 { owner } => {
-                buf.push(18);
-                buf.extend_from_slice(owner.as_ref());
-            }
-            &Self::InitializeMultisig2 { m } => {
-                buf.push(19);
-                buf.push(m);
-            }
-            &Self::InitializeMint2 {
-                ref mint_authority,
-                ref freeze_authority,
-                decimals,
-            } => {
-                buf.push(20);
-                buf.push(decimals);
-                buf.extend_from_slice(mint_authority.as_ref());
-                Self::pack_pubkey_option(freeze_authority, &mut buf);
-            }
-            Self::GetAccountDataSize { extension_types } => {
-                buf.push(21);
-                for extension_type in extension_types {
-                    buf.extend_from_slice(&<[u8; 2]>::from(*extension_type));
-                }
-            }
-            &Self::InitializeImmutableOwner => {
-                buf.push(22);
-            }
-            &Self::AmountToUiAmount { amount } => {
-                buf.push(23);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            Self::UiAmountToAmount { ui_amount } => {
-                buf.push(24);
-                buf.extend_from_slice(ui_amount.as_bytes());
-            }
-            Self::InitializeMintCloseAuthority { close_authority } => {
-                buf.push(25);
-                Self::pack_pubkey_option(close_authority, &mut buf);
-            }
-            Self::TransferFeeExtension => {
-                buf.push(26);
-            }
-            &Self::ConfidentialTransferExtension => {
-                buf.push(27);
-            }
-            &Self::DefaultAccountStateExtension => {
-                buf.push(28);
-            }
-            Self::Reallocate { extension_types } => {
-                buf.push(29);
-                for extension_type in extension_types {
-                    buf.extend_from_slice(&<[u8; 2]>::from(*extension_type));
-                }
-            }
-            &Self::MemoTransferExtension => {
-                buf.push(30);
-            }
-            &Self::CreateNativeMint => {
-                buf.push(31);
-            }
-            &Self::InitializeNonTransferableMint => {
-                buf.push(32);
-            }
-            &Self::InterestBearingMintExtension => {
-                buf.push(33);
-            }
-            &Self::CpiGuardExtension => {
-                buf.push(34);
-            }
-            Self::InitializePermanentDelegate { delegate } => {
-                buf.push(35);
-                buf.extend_from_slice(delegate.as_ref());
-            }
-            &Self::TransferHookExtension => {
-                buf.push(36);
-            }
-            &Self::ConfidentialTransferFeeExtension => {
-                buf.push(37);
-            }
-            &Self::WithdrawExcessLamports => {
-                buf.push(38);
-            }
-            &Self::MetadataPointerExtension => {
-                buf.push(39);
-            }
-            &Self::GroupPointerExtension => {
-                buf.push(40);
-            }
-            &Self::GroupMemberPointerExtension => {
-                buf.push(41);
-            }
-        };
-        buf
-    }
-
-    pub(crate) fn unpack_pubkey(input: &[u8]) -> Result<(Pubkey, &[u8]), ProgramError> {
-        let pk = input
-            .get(..PUBKEY_BYTES)
-            .and_then(|x| Pubkey::try_from(x).ok())
-            .ok_or(TokenError::InvalidInstruction)?;
-        Ok((pk, &input[PUBKEY_BYTES..]))
-    }
-
-    pub(crate) fn unpack_pubkey_option(
-        input: &[u8],
-    ) -> Result<(COption<Pubkey>, &[u8]), ProgramError> {
-        match input.split_first() {
-            Option::Some((&0, rest)) => Ok((COption::None, rest)),
-            Option::Some((&1, rest)) => {
-                let (pk, rest) = Self::unpack_pubkey(rest)?;
-                Ok((COption::Some(pk), rest))
-            }
-            _ => Err(TokenError::InvalidInstruction.into()),
-        }
-    }
-
-    pub(crate) fn pack_pubkey_option(value: &COption<Pubkey>, buf: &mut Vec<u8>) {
-        match *value {
-            COption::Some(ref key) => {
-                buf.push(1);
-                buf.extend_from_slice(&key.to_bytes());
-            }
-            COption::None => buf.push(0),
-        }
-    }
-
-    pub(crate) fn unpack_u16(input: &[u8]) -> Result<(u16, &[u8]), ProgramError> {
-        let value = input
-            .get(..U16_BYTES)
-            .and_then(|slice| slice.try_into().ok())
-            .map(u16::from_le_bytes)
-            .ok_or(TokenError::InvalidInstruction)?;
-        Ok((value, &input[U16_BYTES..]))
-    }
-
-    pub(crate) fn unpack_u64(input: &[u8]) -> Result<(u64, &[u8]), ProgramError> {
-        let value = input
-            .get(..U64_BYTES)
-            .and_then(|slice| slice.try_into().ok())
-            .map(u64::from_le_bytes)
-            .ok_or(TokenError::InvalidInstruction)?;
-        Ok((value, &input[U64_BYTES..]))
-    }
-
-    pub(crate) fn unpack_amount_decimals(input: &[u8]) -> Result<(u64, u8, &[u8]), ProgramError> {
-        let (amount, rest) = Self::unpack_u64(input)?;
-        let (&decimals, rest) = rest.split_first().ok_or(TokenError::InvalidInstruction)?;
-        Ok((amount, decimals, rest))
-    }
-}
-
-/// Specifies the authority type for SetAuthority instructions
-#[repr(u8)]
-#[cfg_attr(feature = "serde-traits", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde-traits", serde(rename_all = "camelCase"))]
-#[derive(Clone, Debug, PartialEq)]
-pub enum AuthorityType {
-    /// Authority to mint new tokens
-    MintTokens,
-    /// Authority to freeze any account associated with the Mint
-    FreezeAccount,
-    /// Owner of a given token account
-    AccountOwner,
-    /// Authority to close a token account
-    CloseAccount,
-    /// Authority to set the transfer fee
-    TransferFeeConfig,
-    /// Authority to withdraw withheld tokens from a mint
-    WithheldWithdraw,
-    /// Authority to close a mint account
-    CloseMint,
-    /// Authority to set the interest rate
-    InterestRate,
-    /// Authority to transfer or burn any tokens for a mint
-    PermanentDelegate,
-    /// Authority to update confidential transfer mint and aprove accounts for
-    /// confidential transfers
-    ConfidentialTransferMint,
-    /// Authority to set the transfer hook program id
-    TransferHookProgramId,
-    /// Authority to set the withdraw withheld authority encryption key
-    ConfidentialTransferFeeConfig,
-    /// Authority to set the metadata address
-    MetadataPointer,
-    /// Authority to set the group address
-    GroupPointer,
-    /// Authority to set the group member address
-    GroupMemberPointer,
-}
-
-impl AuthorityType {
-    fn into(&self) -> u8 {
-        match self {
-            AuthorityType::MintTokens => 0,
-            AuthorityType::FreezeAccount => 1,
-            AuthorityType::AccountOwner => 2,
-            AuthorityType::CloseAccount => 3,
-            AuthorityType::TransferFeeConfig => 4,
-            AuthorityType::WithheldWithdraw => 5,
-            AuthorityType::CloseMint => 6,
-            AuthorityType::InterestRate => 7,
-            AuthorityType::PermanentDelegate => 8,
-            AuthorityType::ConfidentialTransferMint => 9,
-            AuthorityType::TransferHookProgramId => 10,
-            AuthorityType::ConfidentialTransferFeeConfig => 11,
-            AuthorityType::MetadataPointer => 12,
-            AuthorityType::GroupPointer => 13,
-            AuthorityType::GroupMemberPointer => 14,
-        }
-    }
-
-    pub(crate) fn from(index: u8) -> Result<Self, ProgramError> {
-        match index {
-            0 => Ok(AuthorityType::MintTokens),
-            1 => Ok(AuthorityType::FreezeAccount),
-            2 => Ok(AuthorityType::AccountOwner),
-            3 => Ok(AuthorityType::CloseAccount),
-            4 => Ok(AuthorityType::TransferFeeConfig),
-            5 => Ok(AuthorityType::WithheldWithdraw),
-            6 => Ok(AuthorityType::CloseMint),
-            7 => Ok(AuthorityType::InterestRate),
-            8 => Ok(AuthorityType::PermanentDelegate),
-            9 => Ok(AuthorityType::ConfidentialTransferMint),
-            10 => Ok(AuthorityType::TransferHookProgramId),
-            11 => Ok(AuthorityType::ConfidentialTransferFeeConfig),
-            12 => Ok(AuthorityType::MetadataPointer),
-            13 => Ok(AuthorityType::GroupPointer),
-            14 => Ok(AuthorityType::GroupMemberPointer),
-            _ => Err(TokenError::InvalidInstruction.into()),
-        }
-    }
-}
-
-/// Creates a `InitializeMint` instruction.
-pub fn initialize_mint(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    mint_authority_pubkey: &Pubkey,
-    freeze_authority_pubkey: Option<&Pubkey>,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let freeze_authority = freeze_authority_pubkey.cloned().into();
-    let data = TokenInstruction::InitializeMint {
-        mint_authority: *mint_authority_pubkey,
-        freeze_authority,
-        decimals,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*mint_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMint2` instruction.
-pub fn initialize_mint2(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    mint_authority_pubkey: &Pubkey,
-    freeze_authority_pubkey: Option<&Pubkey>,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let freeze_authority = freeze_authority_pubkey.cloned().into();
-    let data = TokenInstruction::InitializeMint2 {
-        mint_authority: *mint_authority_pubkey,
-        freeze_authority,
-        decimals,
-    }
-    .pack();
-
-    let accounts = vec![AccountMeta::new(*mint_pubkey, false)];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount` instruction.
-pub fn initialize_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount.pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(*owner_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount2` instruction.
-pub fn initialize_account2(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount2 {
-        owner: *owner_pubkey,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount3` instruction.
-pub fn initialize_account3(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount3 {
-        owner: *owner_pubkey,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMultisig` instruction.
-pub fn initialize_multisig(
-    token_program_id: &Pubkey,
-    multisig_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    m: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    if !is_valid_signer_index(m as usize)
-        || !is_valid_signer_index(signer_pubkeys.len())
-        || m as usize > signer_pubkeys.len()
-    {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let data = TokenInstruction::InitializeMultisig { m }.pack();
-
-    let mut accounts = Vec::with_capacity(1 + 1 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*multisig_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(sysvar::rent::id(), false));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, false));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMultisig2` instruction.
-pub fn initialize_multisig2(
-    token_program_id: &Pubkey,
-    multisig_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    m: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    if !is_valid_signer_index(m as usize)
-        || !is_valid_signer_index(signer_pubkeys.len())
-        || m as usize > signer_pubkeys.len()
-    {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let data = TokenInstruction::InitializeMultisig2 { m }.pack();
-
-    let mut accounts = Vec::with_capacity(1 + 1 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*multisig_pubkey, false));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, false));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Transfer` instruction.
-#[deprecated(
-    since = "4.0.0",
-    note = "please use `transfer_checked` or `transfer_checked_with_fee` instead"
-)]
-pub fn transfer(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    #[allow(deprecated)]
-    let data = TokenInstruction::Transfer { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates an `Approve` instruction.
-pub fn approve(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    delegate_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::Approve { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*delegate_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Revoke` instruction.
-pub fn revoke(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::Revoke.pack();
-
-    let mut accounts = Vec::with_capacity(2 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `SetAuthority` instruction.
-pub fn set_authority(
-    token_program_id: &Pubkey,
-    owned_pubkey: &Pubkey,
-    new_authority_pubkey: Option<&Pubkey>,
-    authority_type: AuthorityType,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let new_authority = new_authority_pubkey.cloned().into();
-    let data = TokenInstruction::SetAuthority {
-        authority_type,
-        new_authority,
-    }
-    .pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*owned_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `MintTo` instruction.
-pub fn mint_to(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    account_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::MintTo { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Burn` instruction.
-pub fn burn(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::Burn { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `CloseAccount` instruction.
-pub fn close_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::CloseAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `FreezeAccount` instruction.
-pub fn freeze_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::FreezeAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `ThawAccount` instruction.
-pub fn thaw_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::ThawAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `TransferChecked` instruction.
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_checked(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::TransferChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(4 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates an `ApproveChecked` instruction.
-#[allow(clippy::too_many_arguments)]
-pub fn approve_checked(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    delegate_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::ApproveChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(4 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*delegate_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `MintToChecked` instruction.
-pub fn mint_to_checked(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    account_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::MintToChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `BurnChecked` instruction.
-pub fn burn_checked(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    let data = TokenInstruction::BurnChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `SyncNative` instruction
-pub fn sync_native(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*account_pubkey, false)],
-        data: TokenInstruction::SyncNative.pack(),
-    })
-}
-
-/// Creates a `GetAccountDataSize` instruction
-pub fn get_account_data_size(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    extension_types: &[ExtensionType],
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::GetAccountDataSize {
-            extension_types: extension_types.to_vec(),
-        }
-        .pack(),
-    })
-}
-
-/// Creates an `InitializeMintCloseAuthority` instruction
-pub fn initialize_mint_close_authority(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    close_authority: Option<&Pubkey>,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let close_authority = close_authority.cloned().into();
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*mint_pubkey, false)],
-        data: TokenInstruction::InitializeMintCloseAuthority { close_authority }.pack(),
-    })
-}
-
-/// Create an `InitializeImmutableOwner` instruction
-pub fn initialize_immutable_owner(
-    token_program_id: &Pubkey,
-    token_account: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*token_account, false)],
-        data: TokenInstruction::InitializeImmutableOwner.pack(),
-    })
-}
-
-/// Creates an `AmountToUiAmount` instruction
-pub fn amount_to_ui_amount(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::AmountToUiAmount { amount }.pack(),
-    })
-}
-
-/// Creates a `UiAmountToAmount` instruction
-pub fn ui_amount_to_amount(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    ui_amount: &str,
-) -> Result<Instruction, ProgramError> {
-    check_spl_token_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::UiAmountToAmount { ui_amount }.pack(),
-    })
-}
-
-/// Creates a `Reallocate` instruction
-pub fn reallocate(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    payer: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    extension_types: &[ExtensionType],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    let mut accounts = Vec::with_capacity(4 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*payer, true));
-    accounts.push(AccountMeta::new_readonly(system_program::id(), false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: TokenInstruction::Reallocate {
-            extension_types: extension_types.to_vec(),
-        }
-        .pack(),
-    })
-}
-
-/// Creates a `CreateNativeMint` instruction
-pub fn create_native_mint(
-    token_program_id: &Pubkey,
-    payer: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![
-            AccountMeta::new(*payer, true),
-            AccountMeta::new(crate::native_mint::id(), false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-        data: TokenInstruction::CreateNativeMint.pack(),
-    })
-}
-
-/// Creates an `InitializeNonTransferableMint` instruction
-pub fn initialize_non_transferable_mint(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*mint_pubkey, false)],
-        data: TokenInstruction::InitializeNonTransferableMint.pack(),
-    })
-}
-
-/// Creates an `InitializePermanentDelegate` instruction
-pub fn initialize_permanent_delegate(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    delegate: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*mint_pubkey, false)],
-        data: TokenInstruction::InitializePermanentDelegate {
-            delegate: *delegate,
-        }
-        .pack(),
-    })
-}
-
-/// Utility function that checks index is between MIN_SIGNERS and MAX_SIGNERS
-pub fn is_valid_signer_index(index: usize) -> bool {
-    (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)
-}
-
-/// Utility function for decoding just the instruction type
-pub fn decode_instruction_type<T: TryFrom<u8>>(input: &[u8]) -> Result<T, ProgramError> {
-    if input.is_empty() {
-        Err(ProgramError::InvalidInstructionData)
-    } else {
-        T::try_from(input[0]).map_err(|_| TokenError::InvalidInstruction.into())
-    }
-}
-
-/// Utility function for decoding instruction data
-///
-/// Note: This function expects the entire instruction input, including the
-/// instruction type as the first byte.  This makes the code concise and safe
-/// at the expense of clarity, allowing flows such as:
-///
-/// match decode_instruction_type(input)? {
-///     InstructionType::First => {
-///         let FirstData { ... } = decode_instruction_data(input)?;
-///     }
-/// }
-pub fn decode_instruction_data<T: Pod>(input_with_type: &[u8]) -> Result<&T, ProgramError> {
-    if input_with_type.len() != pod_get_packed_len::<T>().saturating_add(1) {
-        Err(ProgramError::InvalidInstructionData)
-    } else {
-        pod_from_bytes(&input_with_type[1..])
-    }
-}
-
-/// Utility function for encoding instruction data
-pub(crate) fn encode_instruction<T: Into<u8>, D: Pod>(
-    token_program_id: &Pubkey,
-    accounts: Vec<AccountMeta>,
-    token_instruction_type: TokenInstruction,
-    instruction_type: T,
-    instruction_data: &D,
-) -> Instruction {
-    let mut data = token_instruction_type.pack();
-    data.push(T::into(instruction_type));
-    data.extend_from_slice(bytemuck::bytes_of(instruction_data));
-    Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates a `WithdrawExcessLamports` Instruction
-pub fn withdraw_excess_lamports(
-    token_program_id: &Pubkey,
-    source_account: &Pubkey,
-    destination_account: &Pubkey,
-    authority: &Pubkey,
-    signers: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    let mut accounts = vec![
-        AccountMeta::new(*source_account, false),
-        AccountMeta::new(*destination_account, false),
-        AccountMeta::new_readonly(*authority, signers.is_empty()),
-    ];
-
-    for signer in signers {
-        accounts.push(AccountMeta::new_readonly(**signer, true))
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data: TokenInstruction::WithdrawExcessLamports.pack(),
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, crate::pod_instruction::*, proptest::prelude::*};
-
-    #[test]
-    fn test_initialize_mint_packing() {
-        let decimals = 2;
-        let mint_authority = Pubkey::new_from_array([1u8; 32]);
-        let freeze_authority = COption::None;
-        let check = TokenInstruction::InitializeMint {
-            decimals,
-            mint_authority,
-            freeze_authority,
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([0u8, 2]);
-        expect.extend_from_slice(&[1u8; 32]);
-        expect.extend_from_slice(&[0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMint);
-        let (pod, pod_freeze_authority) =
-            decode_instruction_data_with_coption_pubkey::<InitializeMintData>(&packed).unwrap();
-        assert_eq!(pod.decimals, decimals);
-        assert_eq!(pod.mint_authority, mint_authority);
-        assert_eq!(pod_freeze_authority, freeze_authority.into());
-
-        let mint_authority = Pubkey::new_from_array([2u8; 32]);
-        let freeze_authority = COption::Some(Pubkey::new_from_array([3u8; 32]));
-        let check = TokenInstruction::InitializeMint {
-            decimals,
-            mint_authority,
-            freeze_authority,
-        };
-        let packed = check.pack();
-        let mut expect = vec![0u8, 2];
-        expect.extend_from_slice(&[2u8; 32]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[3u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMint);
-        let (pod, pod_freeze_authority) =
-            decode_instruction_data_with_coption_pubkey::<InitializeMintData>(&packed).unwrap();
-        assert_eq!(pod.decimals, decimals);
-        assert_eq!(pod.mint_authority, mint_authority);
-        assert_eq!(pod_freeze_authority, freeze_authority.into());
-    }
-
-    #[test]
-    fn test_initialize_account_packing() {
-        let check = TokenInstruction::InitializeAccount;
-        let packed = check.pack();
-        let expect = Vec::from([1u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeAccount);
-    }
-
-    #[test]
-    fn test_initialize_multisig_packing() {
-        let m = 1;
-        let check = TokenInstruction::InitializeMultisig { m };
-        let packed = check.pack();
-        let expect = Vec::from([2u8, 1]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMultisig);
-        let pod = decode_instruction_data::<InitializeMultisigData>(&packed).unwrap();
-        assert_eq!(pod.m, m);
-    }
-
-    #[test]
-    fn test_transfer_packing() {
-        let amount = 1;
-        #[allow(deprecated)]
-        let check = TokenInstruction::Transfer { amount };
-        let packed = check.pack();
-        let expect = Vec::from([3u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::Transfer);
-        let pod = decode_instruction_data::<AmountData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-    }
-
-    #[test]
-    fn test_approve_packing() {
-        let amount = 1;
-        let check = TokenInstruction::Approve { amount };
-        let packed = check.pack();
-        let expect = Vec::from([4u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::Approve);
-        let pod = decode_instruction_data::<AmountData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-    }
-
-    #[test]
-    fn test_revoke_packing() {
-        let check = TokenInstruction::Revoke;
-        let packed = check.pack();
-        let expect = Vec::from([5u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::Revoke);
-    }
-
-    #[test]
-    fn test_set_authority_packing() {
-        let authority_type = AuthorityType::FreezeAccount;
-        let new_authority = COption::Some(Pubkey::new_from_array([4u8; 32]));
-        let check = TokenInstruction::SetAuthority {
-            authority_type: authority_type.clone(),
-            new_authority,
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([6u8, 1]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[4u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::SetAuthority);
-        let (pod, pod_new_authority) =
-            decode_instruction_data_with_coption_pubkey::<SetAuthorityData>(&packed).unwrap();
-        assert_eq!(
-            AuthorityType::from(pod.authority_type).unwrap(),
-            authority_type
-        );
-        assert_eq!(pod_new_authority, new_authority.into());
-    }
-
-    #[test]
-    fn test_mint_to_packing() {
-        let amount = 1;
-        let check = TokenInstruction::MintTo { amount };
-        let packed = check.pack();
-        let expect = Vec::from([7u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::MintTo);
-        let pod = decode_instruction_data::<AmountData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-    }
-
-    #[test]
-    fn test_burn_packing() {
-        let amount = 1;
-        let check = TokenInstruction::Burn { amount };
-        let packed = check.pack();
-        let expect = Vec::from([8u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::Burn);
-        let pod = decode_instruction_data::<AmountData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-    }
-
-    #[test]
-    fn test_close_account_packing() {
-        let check = TokenInstruction::CloseAccount;
-        let packed = check.pack();
-        let expect = Vec::from([9u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::CloseAccount);
-    }
-
-    #[test]
-    fn test_freeze_account_packing() {
-        let check = TokenInstruction::FreezeAccount;
-        let packed = check.pack();
-        let expect = Vec::from([10u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::FreezeAccount);
-    }
-
-    #[test]
-    fn test_thaw_account_packing() {
-        let check = TokenInstruction::ThawAccount;
-        let packed = check.pack();
-        let expect = Vec::from([11u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::ThawAccount);
-    }
-
-    #[test]
-    fn test_transfer_checked_packing() {
-        let amount = 1;
-        let decimals = 2;
-        let check = TokenInstruction::TransferChecked { amount, decimals };
-        let packed = check.pack();
-        let expect = Vec::from([12u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::TransferChecked);
-        let pod = decode_instruction_data::<AmountCheckedData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-        assert_eq!(pod.decimals, decimals);
-    }
-
-    #[test]
-    fn test_approve_checked_packing() {
-        let amount = 1;
-        let decimals = 2;
-
-        let check = TokenInstruction::ApproveChecked { amount, decimals };
-        let packed = check.pack();
-        let expect = Vec::from([13u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::ApproveChecked);
-        let pod = decode_instruction_data::<AmountCheckedData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-        assert_eq!(pod.decimals, decimals);
-    }
-
-    #[test]
-    fn test_mint_to_checked_packing() {
-        let amount = 1;
-        let decimals = 2;
-        let check = TokenInstruction::MintToChecked { amount, decimals };
-        let packed = check.pack();
-        let expect = Vec::from([14u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::MintToChecked);
-        let pod = decode_instruction_data::<AmountCheckedData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-        assert_eq!(pod.decimals, decimals);
-    }
-
-    #[test]
-    fn test_burn_checked_packing() {
-        let amount = 1;
-        let decimals = 2;
-        let check = TokenInstruction::BurnChecked { amount, decimals };
-        let packed = check.pack();
-        let expect = Vec::from([15u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::BurnChecked);
-        let pod = decode_instruction_data::<AmountCheckedData>(&packed).unwrap();
-        assert_eq!(pod.amount, amount.into());
-        assert_eq!(pod.decimals, decimals);
-    }
-
-    #[test]
-    fn test_initialize_account2_packing() {
-        let owner = Pubkey::new_from_array([2u8; 32]);
-        let check = TokenInstruction::InitializeAccount2 { owner };
-        let packed = check.pack();
-        let mut expect = vec![16u8];
-        expect.extend_from_slice(&[2u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeAccount2);
-        let pod_owner = decode_instruction_data::<Pubkey>(&packed).unwrap();
-        assert_eq!(*pod_owner, owner);
-    }
-
-    #[test]
-    fn test_sync_native_packing() {
-        let check = TokenInstruction::SyncNative;
-        let packed = check.pack();
-        let expect = vec![17u8];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::SyncNative);
-    }
-
-    #[test]
-    fn test_initialize_account3_packing() {
-        let owner = Pubkey::new_from_array([2u8; 32]);
-        let check = TokenInstruction::InitializeAccount3 { owner };
-        let packed = check.pack();
-        let mut expect = vec![18u8];
-        expect.extend_from_slice(&[2u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeAccount3);
-        let pod_owner = decode_instruction_data::<Pubkey>(&packed).unwrap();
-        assert_eq!(*pod_owner, owner);
-    }
-
-    #[test]
-    fn test_initialize_multisig2_packing() {
-        let m = 1;
-        let check = TokenInstruction::InitializeMultisig2 { m };
-        let packed = check.pack();
-        let expect = Vec::from([19u8, 1]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMultisig2);
-        let pod = decode_instruction_data::<InitializeMultisigData>(&packed).unwrap();
-        assert_eq!(pod.m, m);
-    }
-
-    #[test]
-    fn test_initialize_mint2_packing() {
-        let decimals = 2;
-        let mint_authority = Pubkey::new_from_array([1u8; 32]);
-        let freeze_authority = COption::None;
-        let check = TokenInstruction::InitializeMint2 {
-            decimals,
-            mint_authority,
-            freeze_authority,
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([20u8, 2]);
-        expect.extend_from_slice(&[1u8; 32]);
-        expect.extend_from_slice(&[0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMint2);
-        let (pod, pod_freeze_authority) =
-            decode_instruction_data_with_coption_pubkey::<InitializeMintData>(&packed).unwrap();
-        assert_eq!(pod.decimals, decimals);
-        assert_eq!(pod.mint_authority, mint_authority);
-        assert_eq!(pod_freeze_authority, freeze_authority.into());
-
-        let decimals = 2;
-        let mint_authority = Pubkey::new_from_array([2u8; 32]);
-        let freeze_authority = COption::Some(Pubkey::new_from_array([3u8; 32]));
-        let check = TokenInstruction::InitializeMint2 {
-            decimals,
-            mint_authority,
-            freeze_authority,
-        };
-        let packed = check.pack();
-        let mut expect = vec![20u8, 2];
-        expect.extend_from_slice(&[2u8; 32]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[3u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::InitializeMint2);
-        let (pod, pod_freeze_authority) =
-            decode_instruction_data_with_coption_pubkey::<InitializeMintData>(&packed).unwrap();
-        assert_eq!(pod.decimals, decimals);
-        assert_eq!(pod.mint_authority, mint_authority);
-        assert_eq!(pod_freeze_authority, freeze_authority.into());
-    }
-
-    #[test]
-    fn test_get_account_data_size_packing() {
-        let extension_types = vec![];
-        let check = TokenInstruction::GetAccountDataSize {
-            extension_types: extension_types.clone(),
-        };
-        let packed = check.pack();
-        let expect = [21u8];
-        assert_eq!(packed, &[21u8]);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::GetAccountDataSize);
-        let pod_extension_types = packed[1..]
-            .chunks(std::mem::size_of::<ExtensionType>())
-            .map(ExtensionType::try_from)
-            .collect::<Result<Vec<_>, _>>()
-            .unwrap();
-        assert_eq!(pod_extension_types, extension_types);
-
-        let extension_types = vec![
-            ExtensionType::TransferFeeConfig,
-            ExtensionType::TransferFeeAmount,
-        ];
-        let check = TokenInstruction::GetAccountDataSize {
-            extension_types: extension_types.clone(),
-        };
-        let packed = check.pack();
-        let expect = [21u8, 1, 0, 2, 0];
-        assert_eq!(packed, &[21u8, 1, 0, 2, 0]);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::GetAccountDataSize);
-        let pod_extension_types = packed[1..]
-            .chunks(std::mem::size_of::<ExtensionType>())
-            .map(ExtensionType::try_from)
-            .collect::<Result<Vec<_>, _>>()
-            .unwrap();
-        assert_eq!(pod_extension_types, extension_types);
-    }
-
-    #[test]
-    fn test_amount_to_ui_amount_packing() {
-        let amount = 42;
-        let check = TokenInstruction::AmountToUiAmount { amount };
-        let packed = check.pack();
-        let expect = vec![23u8, 42, 0, 0, 0, 0, 0, 0, 0];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::AmountToUiAmount);
-        let data = decode_instruction_data::<AmountData>(&packed).unwrap();
-        assert_eq!(data.amount, amount.into());
-    }
-
-    #[test]
-    fn test_ui_amount_to_amount_packing() {
-        let ui_amount = "0.42";
-        let check = TokenInstruction::UiAmountToAmount { ui_amount };
-        let packed = check.pack();
-        let expect = vec![24u8, 48, 46, 52, 50];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::UiAmountToAmount);
-        let pod_ui_amount = std::str::from_utf8(&packed[1..]).unwrap();
-        assert_eq!(pod_ui_amount, ui_amount);
-    }
-
-    #[test]
-    fn test_initialize_mint_close_authority_packing() {
-        let close_authority = COption::Some(Pubkey::new_from_array([10u8; 32]));
-        let check = TokenInstruction::InitializeMintCloseAuthority { close_authority };
-        let packed = check.pack();
-        let mut expect = vec![25u8, 1];
-        expect.extend_from_slice(&[10u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(
-            instruction_type,
-            PodTokenInstruction::InitializeMintCloseAuthority
-        );
-        let (_, pod_close_authority) =
-            decode_instruction_data_with_coption_pubkey::<()>(&packed).unwrap();
-        assert_eq!(pod_close_authority, close_authority.into());
-    }
-
-    #[test]
-    fn test_create_native_mint_packing() {
-        let check = TokenInstruction::CreateNativeMint;
-        let packed = check.pack();
-        let expect = vec![31u8];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(instruction_type, PodTokenInstruction::CreateNativeMint);
-    }
-
-    #[test]
-    fn test_initialize_permanent_delegate_packing() {
-        let delegate = Pubkey::new_from_array([11u8; 32]);
-        let check = TokenInstruction::InitializePermanentDelegate { delegate };
-        let packed = check.pack();
-        let mut expect = vec![35u8];
-        expect.extend_from_slice(&[11u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let instruction_type = decode_instruction_type::<PodTokenInstruction>(&packed).unwrap();
-        assert_eq!(
-            instruction_type,
-            PodTokenInstruction::InitializePermanentDelegate
-        );
-        let pod_delegate = decode_instruction_data::<Pubkey>(&packed).unwrap();
-        assert_eq!(*pod_delegate, delegate);
-    }
-
-    macro_rules! test_instruction {
-        ($a:ident($($b:tt)*)) => {
-            let instruction_v3 = spl_token::instruction::$a($($b)*).unwrap();
-            let instruction_2022 = $a($($b)*).unwrap();
-            assert_eq!(instruction_v3, instruction_2022);
-        }
-    }
-
-    #[test]
-    fn test_v3_compatibility() {
-        let token_program_id = spl_token::id();
-        let mint_pubkey = Pubkey::new_unique();
-        let mint_authority_pubkey = Pubkey::new_unique();
-        let freeze_authority_pubkey = Pubkey::new_unique();
-        let decimals = 9u8;
-
-        let account_pubkey = Pubkey::new_unique();
-        let owner_pubkey = Pubkey::new_unique();
-
-        let multisig_pubkey = Pubkey::new_unique();
-        let signer_pubkeys_vec = vec![Pubkey::new_unique(); MAX_SIGNERS];
-        let signer_pubkeys = signer_pubkeys_vec.iter().collect::<Vec<_>>();
-        let m = 10u8;
-
-        let source_pubkey = Pubkey::new_unique();
-        let destination_pubkey = Pubkey::new_unique();
-        let authority_pubkey = Pubkey::new_unique();
-        let amount = 1_000_000_000_000;
-
-        let delegate_pubkey = Pubkey::new_unique();
-        let owned_pubkey = Pubkey::new_unique();
-        let new_authority_pubkey = Pubkey::new_unique();
-
-        let ui_amount = "100000.00";
-
-        test_instruction!(initialize_mint(
-            &token_program_id,
-            &mint_pubkey,
-            &mint_authority_pubkey,
-            None,
-            decimals,
-        ));
-        test_instruction!(initialize_mint2(
-            &token_program_id,
-            &mint_pubkey,
-            &mint_authority_pubkey,
-            Some(&freeze_authority_pubkey),
-            decimals,
-        ));
-
-        test_instruction!(initialize_account(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &owner_pubkey,
-        ));
-        test_instruction!(initialize_account2(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &owner_pubkey,
-        ));
-        test_instruction!(initialize_account3(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &owner_pubkey,
-        ));
-        test_instruction!(initialize_multisig(
-            &token_program_id,
-            &multisig_pubkey,
-            &signer_pubkeys,
-            m,
-        ));
-        test_instruction!(initialize_multisig2(
-            &token_program_id,
-            &multisig_pubkey,
-            &signer_pubkeys,
-            m,
-        ));
-        #[allow(deprecated)]
-        {
-            test_instruction!(transfer(
-                &token_program_id,
-                &source_pubkey,
-                &destination_pubkey,
-                &authority_pubkey,
-                &signer_pubkeys,
-                amount
-            ));
-        }
-        test_instruction!(transfer_checked(
-            &token_program_id,
-            &source_pubkey,
-            &mint_pubkey,
-            &destination_pubkey,
-            &authority_pubkey,
-            &signer_pubkeys,
-            amount,
-            decimals,
-        ));
-        test_instruction!(approve(
-            &token_program_id,
-            &source_pubkey,
-            &delegate_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-            amount
-        ));
-        test_instruction!(approve_checked(
-            &token_program_id,
-            &source_pubkey,
-            &mint_pubkey,
-            &delegate_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-            amount,
-            decimals
-        ));
-        test_instruction!(revoke(
-            &token_program_id,
-            &source_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-        ));
-
-        // set_authority
-        {
-            let instruction_v3 = spl_token::instruction::set_authority(
-                &token_program_id,
-                &owned_pubkey,
-                Some(&new_authority_pubkey),
-                spl_token::instruction::AuthorityType::AccountOwner,
-                &owner_pubkey,
-                &signer_pubkeys,
-            )
-            .unwrap();
-            let instruction_2022 = set_authority(
-                &token_program_id,
-                &owned_pubkey,
-                Some(&new_authority_pubkey),
-                AuthorityType::AccountOwner,
-                &owner_pubkey,
-                &signer_pubkeys,
-            )
-            .unwrap();
-            assert_eq!(instruction_v3, instruction_2022);
-        }
-
-        test_instruction!(mint_to(
-            &token_program_id,
-            &mint_pubkey,
-            &account_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-            amount,
-        ));
-        test_instruction!(mint_to_checked(
-            &token_program_id,
-            &mint_pubkey,
-            &account_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-            amount,
-            decimals,
-        ));
-        test_instruction!(burn(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &authority_pubkey,
-            &signer_pubkeys,
-            amount,
-        ));
-        test_instruction!(burn_checked(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &authority_pubkey,
-            &signer_pubkeys,
-            amount,
-            decimals,
-        ));
-        test_instruction!(close_account(
-            &token_program_id,
-            &account_pubkey,
-            &destination_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-        ));
-        test_instruction!(freeze_account(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-        ));
-        test_instruction!(thaw_account(
-            &token_program_id,
-            &account_pubkey,
-            &mint_pubkey,
-            &owner_pubkey,
-            &signer_pubkeys,
-        ));
-        test_instruction!(sync_native(&token_program_id, &account_pubkey,));
-
-        // get_account_data_size
-        {
-            let instruction_v3 =
-                spl_token::instruction::get_account_data_size(&token_program_id, &mint_pubkey)
-                    .unwrap();
-            let instruction_2022 =
-                get_account_data_size(&token_program_id, &mint_pubkey, &[]).unwrap();
-            assert_eq!(instruction_v3, instruction_2022);
-        }
-
-        test_instruction!(initialize_immutable_owner(
-            &token_program_id,
-            &account_pubkey,
-        ));
-
-        test_instruction!(amount_to_ui_amount(&token_program_id, &mint_pubkey, amount,));
-
-        test_instruction!(ui_amount_to_amount(
-            &token_program_id,
-            &mint_pubkey,
-            ui_amount,
-        ));
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(1024))]
-        #[test]
-        fn test_instruction_unpack_proptest(
-            data in prop::collection::vec(any::<u8>(), 0..255)
-        ) {
-            let _no_panic = TokenInstruction::unpack(&data);
-        }
-    }
-}
diff --git a/token/program-2022/src/lib.rs b/token/program-2022/src/lib.rs
deleted file mode 100644
index 74f827f67e5..00000000000
--- a/token/program-2022/src/lib.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-//! An ERC20-like Token program for the Solana blockchain
-
-pub mod error;
-pub mod extension;
-pub mod generic_token_account;
-pub mod instruction;
-pub mod native_mint;
-pub mod offchain;
-pub mod onchain;
-pub mod pod;
-pub mod pod_instruction;
-pub mod processor;
-pub mod proof;
-#[cfg(feature = "serde-traits")]
-pub mod serialization;
-pub mod state;
-
-#[cfg(not(feature = "no-entrypoint"))]
-mod entrypoint;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-use solana_program::{
-    entrypoint::ProgramResult,
-    program_error::ProgramError,
-    program_memory::sol_memcmp,
-    pubkey::{Pubkey, PUBKEY_BYTES},
-    system_program,
-};
-pub use {solana_program, solana_zk_token_sdk};
-
-/// Convert the UI representation of a token amount (using the decimals field
-/// defined in its mint) to the raw amount
-pub fn ui_amount_to_amount(ui_amount: f64, decimals: u8) -> u64 {
-    (ui_amount * 10_usize.pow(decimals as u32) as f64) as u64
-}
-
-/// Convert a raw amount to its UI representation (using the decimals field
-/// defined in its mint)
-pub fn amount_to_ui_amount(amount: u64, decimals: u8) -> f64 {
-    amount as f64 / 10_usize.pow(decimals as u32) as f64
-}
-
-/// Convert a raw amount to its UI representation (using the decimals field
-/// defined in its mint)
-pub fn amount_to_ui_amount_string(amount: u64, decimals: u8) -> String {
-    let decimals = decimals as usize;
-    if decimals > 0 {
-        // Left-pad zeros to decimals + 1, so we at least have an integer zero
-        let mut s = format!("{:01$}", amount, decimals + 1);
-        // Add the decimal point (Sorry, "," locales!)
-        s.insert(s.len() - decimals, '.');
-        s
-    } else {
-        amount.to_string()
-    }
-}
-
-/// Convert a raw amount to its UI representation using the given decimals field
-/// Excess zeroes or unneeded decimal point are trimmed.
-pub fn amount_to_ui_amount_string_trimmed(amount: u64, decimals: u8) -> String {
-    let mut s = amount_to_ui_amount_string(amount, decimals);
-    if decimals > 0 {
-        let zeros_trimmed = s.trim_end_matches('0');
-        s = zeros_trimmed.trim_end_matches('.').to_string();
-    }
-    s
-}
-
-/// Try to convert a UI representation of a token amount to its raw amount using
-/// the given decimals field
-pub fn try_ui_amount_into_amount(ui_amount: String, decimals: u8) -> Result<u64, ProgramError> {
-    let decimals = decimals as usize;
-    let mut parts = ui_amount.split('.');
-    // splitting a string, even an empty one, will always yield an iterator of at
-    // least length == 1
-    let mut amount_str = parts.next().unwrap().to_string();
-    let after_decimal = parts.next().unwrap_or("");
-    let after_decimal = after_decimal.trim_end_matches('0');
-    if (amount_str.is_empty() && after_decimal.is_empty())
-        || parts.next().is_some()
-        || after_decimal.len() > decimals
-    {
-        return Err(ProgramError::InvalidArgument);
-    }
-
-    amount_str.push_str(after_decimal);
-    for _ in 0..decimals.saturating_sub(after_decimal.len()) {
-        amount_str.push('0');
-    }
-    amount_str
-        .parse::<u64>()
-        .map_err(|_| ProgramError::InvalidArgument)
-}
-
-solana_program::declare_id!("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
-
-/// Checks that the supplied program ID is correct for spl-token-2022
-pub fn check_program_account(spl_token_program_id: &Pubkey) -> ProgramResult {
-    if spl_token_program_id != &id() {
-        return Err(ProgramError::IncorrectProgramId);
-    }
-    Ok(())
-}
-
-/// Checks that the supplied program ID is correct for spl-token or
-/// spl-token-2022
-pub fn check_spl_token_program_account(spl_token_program_id: &Pubkey) -> ProgramResult {
-    if spl_token_program_id != &id() && spl_token_program_id != &spl_token::id() {
-        return Err(ProgramError::IncorrectProgramId);
-    }
-    Ok(())
-}
-
-/// Checks that the supplied program ID is correct for the ZK Token proof
-/// program
-pub fn check_zk_token_proof_program_account(zk_token_proof_program_id: &Pubkey) -> ProgramResult {
-    if zk_token_proof_program_id != &solana_zk_token_sdk::zk_token_proof_program::id() {
-        return Err(ProgramError::IncorrectProgramId);
-    }
-    Ok(())
-}
-
-/// Checks if the spplied program ID is that of the system program
-pub fn check_system_program_account(system_program_id: &Pubkey) -> ProgramResult {
-    if system_program_id != &system_program::id() {
-        return Err(ProgramError::IncorrectProgramId);
-    }
-    Ok(())
-}
-
-/// Checks two pubkeys for equality in a computationally cheap way using
-/// `sol_memcmp`
-pub fn cmp_pubkeys(a: &Pubkey, b: &Pubkey) -> bool {
-    sol_memcmp(a.as_ref(), b.as_ref(), PUBKEY_BYTES) == 0
-}
diff --git a/token/program-2022/src/native_mint.rs b/token/program-2022/src/native_mint.rs
deleted file mode 100644
index 48c993b0786..00000000000
--- a/token/program-2022/src/native_mint.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! The Mint that represents the native token
-
-/// There are 10^9 lamports in one SOL
-pub const DECIMALS: u8 = 9;
-
-// The Mint for native SOL Token accounts
-solana_program::declare_id!("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP");
-
-/// Seed for the native_mint's program-derived address
-pub const PROGRAM_ADDRESS_SEEDS: &[&[u8]] = &["native-mint".as_bytes(), &[255]];
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        solana_program::{native_token::*, pubkey::Pubkey},
-    };
-
-    #[test]
-    fn test_decimals() {
-        assert!(
-            (lamports_to_sol(42) - crate::amount_to_ui_amount(42, DECIMALS)).abs() < f64::EPSILON
-        );
-        assert_eq!(
-            sol_to_lamports(42.),
-            crate::ui_amount_to_amount(42., DECIMALS)
-        );
-    }
-
-    #[test]
-    fn expected_native_mint_id() {
-        let native_mint_id =
-            Pubkey::create_program_address(PROGRAM_ADDRESS_SEEDS, &crate::id()).unwrap();
-        assert_eq!(id(), native_mint_id);
-    }
-}
diff --git a/token/program-2022/src/offchain.rs b/token/program-2022/src/offchain.rs
deleted file mode 100644
index 800f3dd2b31..00000000000
--- a/token/program-2022/src/offchain.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-//! Offchain helper for fetching required accounts to build instructions
-
-pub use spl_transfer_hook_interface::offchain::{AccountDataResult, AccountFetchError};
-use {
-    crate::{
-        extension::{transfer_hook, StateWithExtensions},
-        state::Mint,
-    },
-    solana_program::{instruction::Instruction, program_error::ProgramError, pubkey::Pubkey},
-    spl_transfer_hook_interface::offchain::add_extra_account_metas_for_execute,
-    std::future::Future,
-};
-
-/// Offchain helper to create a `TransferChecked` instruction with all
-/// additional required account metas for a transfer, including the ones
-/// required by the transfer hook.
-///
-/// To be client-agnostic and to avoid pulling in the full solana-sdk, this
-/// simply takes a function that will return its data as `Future<Vec<u8>>` for
-/// the given address. Can be called in the following way:
-///
-/// ```rust,ignore
-/// let instruction = create_transfer_checked_instruction_with_extra_metas(
-///     &spl_token_2022::id(),
-///     &source,
-///     &mint,
-///     &destination,
-///     &authority,
-///     &[],
-///     amount,
-///     decimals,
-///     |address| self.client.get_account(&address).map_ok(|opt| opt.map(|acc| acc.data)),
-/// )
-/// .await?
-/// ```
-#[allow(clippy::too_many_arguments)]
-pub async fn create_transfer_checked_instruction_with_extra_metas<F, Fut>(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-    fetch_account_data_fn: F,
-) -> Result<Instruction, AccountFetchError>
-where
-    F: Fn(Pubkey) -> Fut,
-    Fut: Future<Output = AccountDataResult>,
-{
-    let mut transfer_instruction = crate::instruction::transfer_checked(
-        token_program_id,
-        source_pubkey,
-        mint_pubkey,
-        destination_pubkey,
-        authority_pubkey,
-        signer_pubkeys,
-        amount,
-        decimals,
-    )?;
-
-    add_extra_account_metas(
-        &mut transfer_instruction,
-        source_pubkey,
-        mint_pubkey,
-        destination_pubkey,
-        authority_pubkey,
-        amount,
-        fetch_account_data_fn,
-    )
-    .await?;
-
-    Ok(transfer_instruction)
-}
-
-/// Offchain helper to add required account metas to an instruction, including
-/// the ones required by the transfer hook.
-///
-/// To be client-agnostic and to avoid pulling in the full solana-sdk, this
-/// simply takes a function that will return its data as `Future<Vec<u8>>` for
-/// the given address. Can be called in the following way:
-///
-/// ```rust,ignore
-/// let mut transfer_instruction = spl_token_2022::instruction::transfer_checked(
-///     &spl_token_2022::id(),
-///     source_pubkey,
-///     mint_pubkey,
-///     destination_pubkey,
-///     authority_pubkey,
-///     signer_pubkeys,
-///     amount,
-///     decimals,
-/// )?;
-/// add_extra_account_metas(
-///     &mut transfer_instruction,
-///     source_pubkey,
-///     mint_pubkey,
-///     destination_pubkey,
-///     authority_pubkey,
-///     amount,
-///     fetch_account_data_fn,
-/// ).await?;
-/// ```
-pub async fn add_extra_account_metas<F, Fut>(
-    instruction: &mut Instruction,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    amount: u64,
-    fetch_account_data_fn: F,
-) -> Result<(), AccountFetchError>
-where
-    F: Fn(Pubkey) -> Fut,
-    Fut: Future<Output = AccountDataResult>,
-{
-    let mint_data = fetch_account_data_fn(*mint_pubkey)
-        .await?
-        .ok_or(ProgramError::InvalidAccountData)?;
-    let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-
-    if let Some(program_id) = transfer_hook::get_program_id(&mint) {
-        add_extra_account_metas_for_execute(
-            instruction,
-            &program_id,
-            source_pubkey,
-            mint_pubkey,
-            destination_pubkey,
-            authority_pubkey,
-            amount,
-            fetch_account_data_fn,
-        )
-        .await?;
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::extension::{
-            transfer_hook::TransferHook, BaseStateWithExtensionsMut, ExtensionType,
-            StateWithExtensionsMut,
-        },
-        solana_program::{instruction::AccountMeta, program_option::COption},
-        solana_program_test::tokio,
-        spl_pod::optional_keys::OptionalNonZeroPubkey,
-        spl_tlv_account_resolution::{
-            account::ExtraAccountMeta, seeds::Seed, state::ExtraAccountMetaList,
-        },
-        spl_transfer_hook_interface::{
-            get_extra_account_metas_address, instruction::ExecuteInstruction,
-        },
-    };
-
-    const DECIMALS: u8 = 0;
-    const MINT_PUBKEY: Pubkey = Pubkey::new_from_array([1u8; 32]);
-    const TRANSFER_HOOK_PROGRAM_ID: Pubkey = Pubkey::new_from_array([2u8; 32]);
-    const EXTRA_META_1: Pubkey = Pubkey::new_from_array([3u8; 32]);
-    const EXTRA_META_2: Pubkey = Pubkey::new_from_array([4u8; 32]);
-
-    // Mock to return the mint data or the validation state account data
-    async fn mock_fetch_account_data_fn(address: Pubkey) -> AccountDataResult {
-        if address == MINT_PUBKEY {
-            let mint_len =
-                ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::TransferHook])
-                    .unwrap();
-            let mut data = vec![0u8; mint_len];
-            let mut mint = StateWithExtensionsMut::<Mint>::unpack_uninitialized(&mut data).unwrap();
-
-            let extension = mint.init_extension::<TransferHook>(true).unwrap();
-            extension.program_id =
-                OptionalNonZeroPubkey::try_from(Some(TRANSFER_HOOK_PROGRAM_ID)).unwrap();
-
-            mint.base.mint_authority = COption::Some(Pubkey::new_unique());
-            mint.base.decimals = DECIMALS;
-            mint.base.is_initialized = true;
-            mint.base.freeze_authority = COption::None;
-            mint.pack_base();
-            mint.init_account_type().unwrap();
-
-            Ok(Some(data))
-        } else if address
-            == get_extra_account_metas_address(&MINT_PUBKEY, &TRANSFER_HOOK_PROGRAM_ID)
-        {
-            let extra_metas = vec![
-                ExtraAccountMeta::new_with_pubkey(&EXTRA_META_1, true, false).unwrap(),
-                ExtraAccountMeta::new_with_pubkey(&EXTRA_META_2, true, false).unwrap(),
-                ExtraAccountMeta::new_with_seeds(
-                    &[
-                        Seed::AccountKey { index: 0 }, // source
-                        Seed::AccountKey { index: 2 }, // destination
-                        Seed::AccountKey { index: 4 }, // validation state
-                    ],
-                    false,
-                    true,
-                )
-                .unwrap(),
-                ExtraAccountMeta::new_with_seeds(
-                    &[
-                        Seed::InstructionData {
-                            index: 8,
-                            length: 8,
-                        }, // amount
-                        Seed::AccountKey { index: 2 }, // destination
-                        Seed::AccountKey { index: 5 }, // extra meta 1
-                        Seed::AccountKey { index: 7 }, // extra meta 3 (PDA)
-                    ],
-                    false,
-                    true,
-                )
-                .unwrap(),
-            ];
-            let account_size = ExtraAccountMetaList::size_of(extra_metas.len()).unwrap();
-            let mut data = vec![0u8; account_size];
-            ExtraAccountMetaList::init::<ExecuteInstruction>(&mut data, &extra_metas)?;
-            Ok(Some(data))
-        } else {
-            Ok(None)
-        }
-    }
-
-    #[tokio::test]
-    async fn test_create_transfer_checked_instruction_with_extra_metas() {
-        let source = Pubkey::new_unique();
-        let destination = Pubkey::new_unique();
-        let authority = Pubkey::new_unique();
-        let amount = 100u64;
-
-        let validate_state_pubkey =
-            get_extra_account_metas_address(&MINT_PUBKEY, &TRANSFER_HOOK_PROGRAM_ID);
-        let extra_meta_3_pubkey = Pubkey::find_program_address(
-            &[
-                source.as_ref(),
-                destination.as_ref(),
-                validate_state_pubkey.as_ref(),
-            ],
-            &TRANSFER_HOOK_PROGRAM_ID,
-        )
-        .0;
-        let extra_meta_4_pubkey = Pubkey::find_program_address(
-            &[
-                amount.to_le_bytes().as_ref(),
-                destination.as_ref(),
-                EXTRA_META_1.as_ref(),
-                extra_meta_3_pubkey.as_ref(),
-            ],
-            &TRANSFER_HOOK_PROGRAM_ID,
-        )
-        .0;
-
-        let instruction = create_transfer_checked_instruction_with_extra_metas(
-            &crate::id(),
-            &source,
-            &MINT_PUBKEY,
-            &destination,
-            &authority,
-            &[],
-            amount,
-            DECIMALS,
-            mock_fetch_account_data_fn,
-        )
-        .await
-        .unwrap();
-
-        let check_metas = [
-            AccountMeta::new(source, false),
-            AccountMeta::new_readonly(MINT_PUBKEY, false),
-            AccountMeta::new(destination, false),
-            AccountMeta::new_readonly(authority, true),
-            AccountMeta::new_readonly(EXTRA_META_1, true),
-            AccountMeta::new_readonly(EXTRA_META_2, true),
-            AccountMeta::new(extra_meta_3_pubkey, false),
-            AccountMeta::new(extra_meta_4_pubkey, false),
-            AccountMeta::new_readonly(TRANSFER_HOOK_PROGRAM_ID, false),
-            AccountMeta::new_readonly(validate_state_pubkey, false),
-        ];
-
-        assert_eq!(instruction.accounts, check_metas);
-
-        // With additional signers
-        let signer_1 = Pubkey::new_unique();
-        let signer_2 = Pubkey::new_unique();
-        let signer_3 = Pubkey::new_unique();
-
-        let instruction = create_transfer_checked_instruction_with_extra_metas(
-            &crate::id(),
-            &source,
-            &MINT_PUBKEY,
-            &destination,
-            &authority,
-            &[&signer_1, &signer_2, &signer_3],
-            amount,
-            DECIMALS,
-            mock_fetch_account_data_fn,
-        )
-        .await
-        .unwrap();
-
-        let check_metas = [
-            AccountMeta::new(source, false),
-            AccountMeta::new_readonly(MINT_PUBKEY, false),
-            AccountMeta::new(destination, false),
-            AccountMeta::new_readonly(authority, false), // False because of additional signers
-            AccountMeta::new_readonly(signer_1, true),
-            AccountMeta::new_readonly(signer_2, true),
-            AccountMeta::new_readonly(signer_3, true),
-            AccountMeta::new_readonly(EXTRA_META_1, true),
-            AccountMeta::new_readonly(EXTRA_META_2, true),
-            AccountMeta::new(extra_meta_3_pubkey, false),
-            AccountMeta::new(extra_meta_4_pubkey, false),
-            AccountMeta::new_readonly(TRANSFER_HOOK_PROGRAM_ID, false),
-            AccountMeta::new_readonly(validate_state_pubkey, false),
-        ];
-
-        assert_eq!(instruction.accounts, check_metas);
-    }
-}
diff --git a/token/program-2022/src/onchain.rs b/token/program-2022/src/onchain.rs
deleted file mode 100644
index 255800d7877..00000000000
--- a/token/program-2022/src/onchain.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//! On-chain program invoke helper to perform on-chain `transfer_checked` with
-//! correct accounts
-
-use {
-    crate::{
-        extension::{transfer_hook, StateWithExtensions},
-        instruction,
-        state::Mint,
-    },
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, instruction::AccountMeta,
-        program::invoke_signed, pubkey::Pubkey,
-    },
-    spl_transfer_hook_interface::onchain::add_extra_accounts_for_execute_cpi,
-};
-
-/// Helper to CPI into token-2022 on-chain, looking through the additional
-/// account infos to create the proper instruction with the proper account infos
-#[allow(clippy::too_many_arguments)]
-pub fn invoke_transfer_checked<'a>(
-    token_program_id: &Pubkey,
-    source_info: AccountInfo<'a>,
-    mint_info: AccountInfo<'a>,
-    destination_info: AccountInfo<'a>,
-    authority_info: AccountInfo<'a>,
-    additional_accounts: &[AccountInfo<'a>],
-    amount: u64,
-    decimals: u8,
-    seeds: &[&[&[u8]]],
-) -> ProgramResult {
-    let mut cpi_instruction = instruction::transfer_checked(
-        token_program_id,
-        source_info.key,
-        mint_info.key,
-        destination_info.key,
-        authority_info.key,
-        &[], // add them later, to avoid unnecessary clones
-        amount,
-        decimals,
-    )?;
-
-    let mut cpi_account_infos = vec![
-        source_info.clone(),
-        mint_info.clone(),
-        destination_info.clone(),
-        authority_info.clone(),
-    ];
-
-    // if it's a signer, it might be a multisig signer, throw it in!
-    additional_accounts
-        .iter()
-        .filter(|ai| ai.is_signer)
-        .for_each(|ai| {
-            cpi_account_infos.push(ai.clone());
-            cpi_instruction
-                .accounts
-                .push(AccountMeta::new_readonly(*ai.key, ai.is_signer));
-        });
-
-    // scope the borrowing to avoid a double-borrow during CPI
-    {
-        let mint_data = mint_info.try_borrow_data()?;
-        let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-        if let Some(program_id) = transfer_hook::get_program_id(&mint) {
-            add_extra_accounts_for_execute_cpi(
-                &mut cpi_instruction,
-                &mut cpi_account_infos,
-                &program_id,
-                source_info,
-                mint_info.clone(),
-                destination_info,
-                authority_info,
-                amount,
-                additional_accounts,
-            )?;
-        }
-    }
-
-    invoke_signed(&cpi_instruction, &cpi_account_infos, seeds)
-}
diff --git a/token/program-2022/src/pod.rs b/token/program-2022/src/pod.rs
deleted file mode 100644
index 3bab7e297ea..00000000000
--- a/token/program-2022/src/pod.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-//! Rewrites of the base state types represented as Pods
-
-#[cfg(test)]
-use crate::state::{Account, Mint, Multisig};
-use {
-    crate::{
-        instruction::MAX_SIGNERS,
-        state::{AccountState, PackedSizeOf},
-    },
-    bytemuck::{Pod, Zeroable},
-    solana_program::{
-        program_error::ProgramError, program_option::COption, program_pack::IsInitialized,
-        pubkey::Pubkey,
-    },
-    spl_pod::{
-        bytemuck::pod_get_packed_len,
-        optional_keys::OptionalNonZeroPubkey,
-        primitives::{PodBool, PodU64},
-    },
-};
-
-/// [Mint] data stored as a Pod type
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct PodMint {
-    /// Optional authority used to mint new tokens. The mint authority may only
-    /// be provided during mint creation. If no mint authority is present
-    /// then the mint has a fixed supply and no further tokens may be
-    /// minted.
-    pub mint_authority: PodCOption<Pubkey>,
-    /// Total supply of tokens.
-    pub supply: PodU64,
-    /// Number of base 10 digits to the right of the decimal place.
-    pub decimals: u8,
-    /// If `true`, this structure has been initialized
-    pub is_initialized: PodBool,
-    /// Optional authority to freeze token accounts.
-    pub freeze_authority: PodCOption<Pubkey>,
-}
-impl IsInitialized for PodMint {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized.into()
-    }
-}
-impl PackedSizeOf for PodMint {
-    const SIZE_OF: usize = pod_get_packed_len::<Self>();
-}
-#[cfg(test)]
-impl From<Mint> for PodMint {
-    fn from(mint: Mint) -> Self {
-        Self {
-            mint_authority: mint.mint_authority.into(),
-            supply: mint.supply.into(),
-            decimals: mint.decimals,
-            is_initialized: mint.is_initialized.into(),
-            freeze_authority: mint.freeze_authority.into(),
-        }
-    }
-}
-
-/// [Account] data stored as a Pod type
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct PodAccount {
-    /// The mint associated with this account
-    pub mint: Pubkey,
-    /// The owner of this account.
-    pub owner: Pubkey,
-    /// The amount of tokens this account holds.
-    pub amount: PodU64,
-    /// If `delegate` is `Some` then `delegated_amount` represents
-    /// the amount authorized by the delegate
-    pub delegate: PodCOption<Pubkey>,
-    /// The account's [AccountState], stored as a u8
-    pub state: u8,
-    /// If is_some, this is a native token, and the value logs the rent-exempt
-    /// reserve. An Account is required to be rent-exempt, so the value is
-    /// used by the Processor to ensure that wrapped SOL accounts do not
-    /// drop below this threshold.
-    pub is_native: PodCOption<PodU64>,
-    /// The amount delegated
-    pub delegated_amount: PodU64,
-    /// Optional authority to close the account.
-    pub close_authority: PodCOption<Pubkey>,
-}
-impl PodAccount {
-    /// Checks if account is frozen
-    pub fn is_frozen(&self) -> bool {
-        self.state == AccountState::Frozen as u8
-    }
-    /// Checks if account is native
-    pub fn is_native(&self) -> bool {
-        self.is_native.is_some()
-    }
-    /// Checks if a token Account's owner is the system_program or the
-    /// incinerator
-    pub fn is_owned_by_system_program_or_incinerator(&self) -> bool {
-        solana_program::system_program::check_id(&self.owner)
-            || solana_program::incinerator::check_id(&self.owner)
-    }
-}
-impl IsInitialized for PodAccount {
-    fn is_initialized(&self) -> bool {
-        self.state != 0
-    }
-}
-impl PackedSizeOf for PodAccount {
-    const SIZE_OF: usize = pod_get_packed_len::<Self>();
-}
-#[cfg(test)]
-impl From<Account> for PodAccount {
-    fn from(account: Account) -> Self {
-        Self {
-            mint: account.mint,
-            owner: account.owner,
-            amount: account.amount.into(),
-            delegate: account.delegate.into(),
-            state: account.state.into(),
-            is_native: account.is_native.map(PodU64::from_primitive).into(),
-            delegated_amount: account.delegated_amount.into(),
-            close_authority: account.close_authority.into(),
-        }
-    }
-}
-
-/// [Multisig] data stored as a Pod type
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct PodMultisig {
-    /// Number of signers required
-    pub m: u8,
-    /// Number of valid signers
-    pub n: u8,
-    /// If `true`, this structure has been initialized
-    pub is_initialized: PodBool,
-    /// Signer public keys
-    pub signers: [Pubkey; MAX_SIGNERS],
-}
-impl IsInitialized for PodMultisig {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized.into()
-    }
-}
-impl PackedSizeOf for PodMultisig {
-    const SIZE_OF: usize = pod_get_packed_len::<Self>();
-}
-#[cfg(test)]
-impl From<Multisig> for PodMultisig {
-    fn from(multisig: Multisig) -> Self {
-        Self {
-            m: multisig.m,
-            n: multisig.n,
-            is_initialized: multisig.is_initialized.into(),
-            signers: multisig.signers,
-        }
-    }
-}
-
-/// COption<T> stored as a Pod type
-#[repr(C, packed)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub struct PodCOption<T: Pod + Default> {
-    pub(crate) option: [u8; 4],
-    pub(crate) value: T,
-}
-impl<T: Pod + Default> PodCOption<T> {
-    /// Represents that no value is stored in the option, like `Option::None`
-    pub const NONE: [u8; 4] = [0; 4];
-    /// Represents that some value is stored in the option, like
-    /// `Option::Some(v)`
-    pub const SOME: [u8; 4] = [1, 0, 0, 0];
-
-    /// Create a PodCOption equivalent of `Option::None`
-    ///
-    /// This could be made `const` by using `std::mem::zeroed`, but that would
-    /// require `unsafe` code, which is prohibited at the crate level.
-    pub fn none() -> Self {
-        Self {
-            option: Self::NONE,
-            value: T::default(),
-        }
-    }
-
-    /// Create a PodCOption equivalent of `Option::Some(value)`
-    pub const fn some(value: T) -> Self {
-        Self {
-            option: Self::SOME,
-            value,
-        }
-    }
-
-    /// Get the underlying value or another provided value if it isn't set,
-    /// equivalent of `Option::unwrap_or`
-    pub fn unwrap_or(self, default: T) -> T {
-        if self.option == Self::NONE {
-            default
-        } else {
-            self.value
-        }
-    }
-
-    /// Checks to see if a value is set, equivalent of `Option::is_some`
-    pub fn is_some(&self) -> bool {
-        self.option == Self::SOME
-    }
-
-    /// Checks to see if no value is set, equivalent of `Option::is_none`
-    pub fn is_none(&self) -> bool {
-        self.option == Self::NONE
-    }
-
-    /// Converts the option into a Result, similar to `Option::ok_or`
-    pub fn ok_or<E>(self, error: E) -> Result<T, E> {
-        match self {
-            Self {
-                option: Self::SOME,
-                value,
-            } => Ok(value),
-            _ => Err(error),
-        }
-    }
-}
-impl<T: Pod + Default> From<COption<T>> for PodCOption<T> {
-    fn from(opt: COption<T>) -> Self {
-        match opt {
-            COption::None => Self {
-                option: Self::NONE,
-                value: T::default(),
-            },
-            COption::Some(v) => Self {
-                option: Self::SOME,
-                value: v,
-            },
-        }
-    }
-}
-impl TryFrom<PodCOption<Pubkey>> for OptionalNonZeroPubkey {
-    type Error = ProgramError;
-    fn try_from(p: PodCOption<Pubkey>) -> Result<Self, Self::Error> {
-        match p {
-            PodCOption {
-                option: PodCOption::<Pubkey>::SOME,
-                value,
-            } if value == Pubkey::default() => Err(ProgramError::InvalidArgument),
-            PodCOption {
-                option: PodCOption::<Pubkey>::SOME,
-                value,
-            } => Ok(Self(value)),
-            PodCOption {
-                option: PodCOption::<Pubkey>::NONE,
-                value: _,
-            } => Ok(Self(Pubkey::default())),
-            _ => unreachable!(),
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod test {
-    use {
-        super::*,
-        crate::state::{
-            test::{
-                TEST_ACCOUNT, TEST_ACCOUNT_SLICE, TEST_MINT, TEST_MINT_SLICE, TEST_MULTISIG,
-                TEST_MULTISIG_SLICE,
-            },
-            AccountState,
-        },
-        spl_pod::bytemuck::pod_from_bytes,
-    };
-
-    pub const TEST_POD_MINT: PodMint = PodMint {
-        mint_authority: PodCOption::some(Pubkey::new_from_array([1; 32])),
-        supply: PodU64::from_primitive(42),
-        decimals: 7,
-        is_initialized: PodBool::from_bool(true),
-        freeze_authority: PodCOption::some(Pubkey::new_from_array([2; 32])),
-    };
-    pub const TEST_POD_ACCOUNT: PodAccount = PodAccount {
-        mint: Pubkey::new_from_array([1; 32]),
-        owner: Pubkey::new_from_array([2; 32]),
-        amount: PodU64::from_primitive(3),
-        delegate: PodCOption::some(Pubkey::new_from_array([4; 32])),
-        state: AccountState::Frozen as u8,
-        is_native: PodCOption::some(PodU64::from_primitive(5)),
-        delegated_amount: PodU64::from_primitive(6),
-        close_authority: PodCOption::some(Pubkey::new_from_array([7; 32])),
-    };
-
-    #[test]
-    fn pod_mint_to_mint_equality() {
-        let pod_mint = pod_from_bytes::<PodMint>(TEST_MINT_SLICE).unwrap();
-        assert_eq!(*pod_mint, PodMint::from(TEST_MINT));
-        assert_eq!(*pod_mint, TEST_POD_MINT);
-    }
-
-    #[test]
-    fn pod_account_to_account_equality() {
-        let pod_account = pod_from_bytes::<PodAccount>(TEST_ACCOUNT_SLICE).unwrap();
-        assert_eq!(*pod_account, PodAccount::from(TEST_ACCOUNT));
-        assert_eq!(*pod_account, TEST_POD_ACCOUNT);
-    }
-
-    #[test]
-    fn pod_multisig_to_multisig_equality() {
-        let pod_multisig = pod_from_bytes::<PodMultisig>(TEST_MULTISIG_SLICE).unwrap();
-        assert_eq!(*pod_multisig, PodMultisig::from(TEST_MULTISIG));
-    }
-}
diff --git a/token/program-2022/src/pod_instruction.rs b/token/program-2022/src/pod_instruction.rs
deleted file mode 100644
index dcf487c966d..00000000000
--- a/token/program-2022/src/pod_instruction.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-//! Rewrites of the instruction data types represented as Pods
-
-use {
-    crate::pod::PodCOption,
-    bytemuck::{Pod, Zeroable},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        program_error::ProgramError,
-        pubkey::{Pubkey, PUBKEY_BYTES},
-    },
-    spl_pod::{
-        bytemuck::{pod_from_bytes, pod_get_packed_len},
-        primitives::PodU64,
-    },
-};
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub(crate) struct InitializeMintData {
-    /// Number of base 10 digits to the right of the decimal place.
-    pub(crate) decimals: u8,
-    /// The authority/multisignature to mint tokens.
-    pub(crate) mint_authority: Pubkey,
-    // The freeze authority option comes later, but cannot be included as
-    // plain old data in this struct
-}
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub(crate) struct InitializeMultisigData {
-    /// The number of signers (M) required to validate this multisignature
-    /// account.
-    pub(crate) m: u8,
-}
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub(crate) struct AmountData {
-    /// The amount of tokens to transfer.
-    pub(crate) amount: PodU64,
-}
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub(crate) struct AmountCheckedData {
-    /// The amount of tokens to transfer.
-    pub(crate) amount: PodU64,
-    /// Decimals of the mint
-    pub(crate) decimals: u8,
-}
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
-pub(crate) struct SetAuthorityData {
-    /// The type of authority to update.
-    pub(crate) authority_type: u8,
-    // The new authority option comes later, but cannot be included as
-    // plain old data in this struct
-}
-
-/// All of the base instructions in Token-2022, reduced down to their one-byte
-/// discriminant.
-///
-/// All instructions that expect data afterwards include a comment with the data
-/// type expected. For example, `PodTokenInstruction::InitializeMint` expects
-/// `InitializeMintData`.
-#[derive(Clone, Copy, Debug, PartialEq, TryFromPrimitive, IntoPrimitive)]
-#[repr(u8)]
-pub(crate) enum PodTokenInstruction {
-    // 0
-    InitializeMint, // InitializeMintData
-    InitializeAccount,
-    InitializeMultisig, // InitializeMultisigData
-    Transfer,           // AmountData
-    Approve,            // AmountData
-    // 5
-    Revoke,
-    SetAuthority, // SetAuthorityData
-    MintTo,       // AmountData
-    Burn,         // AmountData
-    CloseAccount,
-    // 10
-    FreezeAccount,
-    ThawAccount,
-    TransferChecked, // AmountCheckedData
-    ApproveChecked,  // AmountCheckedData
-    MintToChecked,   // AmountCheckedData
-    // 15
-    BurnChecked,        // AmountCheckedData
-    InitializeAccount2, // Pubkey
-    SyncNative,
-    InitializeAccount3,  // Pubkey
-    InitializeMultisig2, // InitializeMultisigData
-    // 20
-    InitializeMint2,    // InitializeMintData
-    GetAccountDataSize, // &[ExtensionType]
-    InitializeImmutableOwner,
-    AmountToUiAmount, // AmountData
-    UiAmountToAmount, // &str
-    // 25
-    InitializeMintCloseAuthority, // COption<Pubkey>
-    TransferFeeExtension,
-    ConfidentialTransferExtension,
-    DefaultAccountStateExtension,
-    Reallocate, // &[ExtensionType]
-    // 30
-    MemoTransferExtension,
-    CreateNativeMint,
-    InitializeNonTransferableMint,
-    InterestBearingMintExtension,
-    CpiGuardExtension,
-    // 35
-    InitializePermanentDelegate, // Pubkey
-    TransferHookExtension,
-    ConfidentialTransferFeeExtension,
-    WithdrawExcessLamports,
-    MetadataPointerExtension,
-    // 40
-    GroupPointerExtension,
-    GroupMemberPointerExtension,
-}
-
-fn unpack_pubkey_option(input: &[u8]) -> Result<PodCOption<Pubkey>, ProgramError> {
-    match input.split_first() {
-        Option::Some((&0, _)) => Ok(PodCOption::none()),
-        Option::Some((&1, rest)) => {
-            let pk = rest
-                .get(..PUBKEY_BYTES)
-                .and_then(|x| Pubkey::try_from(x).ok())
-                .ok_or(ProgramError::InvalidInstructionData)?;
-            Ok(PodCOption::some(pk))
-        }
-        _ => Err(ProgramError::InvalidInstructionData),
-    }
-}
-
-/// Specialty function for deserializing `Pod` data and a `COption<Pubkey>`
-///
-/// `COption<T>` is not `Pod` compatible when serialized in an instruction, but
-/// since it is always at the end of an instruction, so we can do this safely
-pub(crate) fn decode_instruction_data_with_coption_pubkey<T: Pod>(
-    input_with_type: &[u8],
-) -> Result<(&T, PodCOption<Pubkey>), ProgramError> {
-    let end_of_t = pod_get_packed_len::<T>().saturating_add(1);
-    let value = input_with_type
-        .get(1..end_of_t)
-        .ok_or(ProgramError::InvalidInstructionData)
-        .and_then(pod_from_bytes)?;
-    let pubkey = unpack_pubkey_option(&input_with_type[end_of_t..])?;
-    Ok((value, pubkey))
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::{
-            extension::ExtensionType,
-            instruction::{decode_instruction_data, decode_instruction_type},
-        },
-        proptest::prelude::*,
-    };
-
-    // Test function that mimics the "unpacking" in `Processor::process` by
-    // trying to deserialize the relevant type data after the instruction type
-    fn check_pod_instruction(input: &[u8]) -> Result<(), ProgramError> {
-        if let Ok(instruction_type) = decode_instruction_type(input) {
-            match instruction_type {
-                PodTokenInstruction::InitializeMint | PodTokenInstruction::InitializeMint2 => {
-                    let _ =
-                        decode_instruction_data_with_coption_pubkey::<InitializeMintData>(input)?;
-                }
-                PodTokenInstruction::InitializeAccount2
-                | PodTokenInstruction::InitializeAccount3
-                | PodTokenInstruction::InitializePermanentDelegate => {
-                    let _ = decode_instruction_data::<Pubkey>(input)?;
-                }
-                PodTokenInstruction::InitializeMultisig
-                | PodTokenInstruction::InitializeMultisig2 => {
-                    let _ = decode_instruction_data::<InitializeMultisigData>(input)?;
-                }
-                PodTokenInstruction::SetAuthority => {
-                    let _ = decode_instruction_data_with_coption_pubkey::<SetAuthorityData>(input)?;
-                }
-                PodTokenInstruction::Transfer
-                | PodTokenInstruction::Approve
-                | PodTokenInstruction::MintTo
-                | PodTokenInstruction::Burn
-                | PodTokenInstruction::AmountToUiAmount => {
-                    let _ = decode_instruction_data::<AmountData>(input)?;
-                }
-                PodTokenInstruction::TransferChecked
-                | PodTokenInstruction::ApproveChecked
-                | PodTokenInstruction::MintToChecked
-                | PodTokenInstruction::BurnChecked => {
-                    let _ = decode_instruction_data::<AmountCheckedData>(input)?;
-                }
-                PodTokenInstruction::InitializeMintCloseAuthority => {
-                    let _ = decode_instruction_data_with_coption_pubkey::<()>(input)?;
-                }
-                PodTokenInstruction::UiAmountToAmount => {
-                    let _ = std::str::from_utf8(&input[1..])
-                        .map_err(|_| ProgramError::InvalidInstructionData)?;
-                }
-                PodTokenInstruction::GetAccountDataSize | PodTokenInstruction::Reallocate => {
-                    let _ = input[1..]
-                        .chunks(std::mem::size_of::<ExtensionType>())
-                        .map(ExtensionType::try_from)
-                        .collect::<Result<Vec<_>, _>>()?;
-                }
-                _ => {
-                    // no extra data to deserialize
-                }
-            }
-        }
-        Ok(())
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(1024))]
-        #[test]
-        fn test_instruction_unpack_proptest(
-            data in prop::collection::vec(any::<u8>(), 0..255)
-        ) {
-            let _no_panic = check_pod_instruction(&data);
-        }
-    }
-}
diff --git a/token/program-2022/src/processor.rs b/token/program-2022/src/processor.rs
deleted file mode 100644
index 469b29f7f6a..00000000000
--- a/token/program-2022/src/processor.rs
+++ /dev/null
@@ -1,8198 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{
-        check_program_account, cmp_pubkeys,
-        error::TokenError,
-        extension::{
-            confidential_transfer::{self, ConfidentialTransferAccount, ConfidentialTransferMint},
-            confidential_transfer_fee::{
-                self, ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig,
-            },
-            cpi_guard::{self, in_cpi, CpiGuard},
-            default_account_state::{self, DefaultAccountState},
-            group_member_pointer::{self, GroupMemberPointer},
-            group_pointer::{self, GroupPointer},
-            immutable_owner::ImmutableOwner,
-            interest_bearing_mint::{self, InterestBearingConfig},
-            memo_transfer::{self, check_previous_sibling_instruction_is_memo, memo_required},
-            metadata_pointer::{self, MetadataPointer},
-            mint_close_authority::MintCloseAuthority,
-            non_transferable::{NonTransferable, NonTransferableAccount},
-            permanent_delegate::{get_permanent_delegate, PermanentDelegate},
-            reallocate, token_group, token_metadata,
-            transfer_fee::{self, TransferFeeAmount, TransferFeeConfig},
-            transfer_hook::{self, TransferHook, TransferHookAccount},
-            AccountType, BaseStateWithExtensions, BaseStateWithExtensionsMut, ExtensionType,
-            PodStateWithExtensions, PodStateWithExtensionsMut,
-        },
-        instruction::{
-            decode_instruction_data, decode_instruction_type, is_valid_signer_index, AuthorityType,
-            MAX_SIGNERS,
-        },
-        native_mint,
-        pod::{PodAccount, PodCOption, PodMint, PodMultisig},
-        pod_instruction::{
-            decode_instruction_data_with_coption_pubkey, AmountCheckedData, AmountData,
-            InitializeMintData, InitializeMultisigData, PodTokenInstruction, SetAuthorityData,
-        },
-        state::{Account, AccountState, Mint, PackedSizeOf},
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        clock::Clock,
-        entrypoint::ProgramResult,
-        msg,
-        program::{invoke, invoke_signed, set_return_data},
-        program_error::ProgramError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        system_instruction, system_program,
-        sysvar::{rent::Rent, Sysvar},
-    },
-    spl_pod::{
-        bytemuck::{pod_from_bytes, pod_from_bytes_mut},
-        primitives::{PodBool, PodU64},
-    },
-    spl_token_group_interface::instruction::TokenGroupInstruction,
-    spl_token_metadata_interface::instruction::TokenMetadataInstruction,
-    std::convert::{TryFrom, TryInto},
-};
-
-/// Program state handler.
-pub struct Processor {}
-impl Processor {
-    fn _process_initialize_mint(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: &Pubkey,
-        freeze_authority: PodCOption<Pubkey>,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        let mint_data_len = mint_info.data_len();
-        let mut mint_data = mint_info.data.borrow_mut();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        if !rent.is_exempt(mint_info.lamports(), mint_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-        let extension_types = mint.get_extension_types()?;
-        if ExtensionType::try_calculate_account_len::<Mint>(&extension_types)? != mint_data_len {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        ExtensionType::check_for_invalid_mint_extension_combinations(&extension_types)?;
-
-        if let Ok(default_account_state) = mint.get_extension_mut::<DefaultAccountState>() {
-            let default_account_state = AccountState::try_from(default_account_state.state)
-                .or(Err(ProgramError::InvalidAccountData))?;
-            if default_account_state == AccountState::Frozen && freeze_authority.is_none() {
-                return Err(TokenError::MintCannotFreeze.into());
-            }
-        }
-
-        mint.base.mint_authority = PodCOption::some(*mint_authority);
-        mint.base.decimals = decimals;
-        mint.base.is_initialized = PodBool::from_bool(true);
-        mint.base.freeze_authority = freeze_authority;
-        mint.init_account_type()?;
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeMint](enum.TokenInstruction.html) instruction.
-    pub fn process_initialize_mint(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: &Pubkey,
-        freeze_authority: PodCOption<Pubkey>,
-    ) -> ProgramResult {
-        Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, true)
-    }
-
-    /// Processes an [InitializeMint2](enum.TokenInstruction.html) instruction.
-    pub fn process_initialize_mint2(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: &Pubkey,
-        freeze_authority: PodCOption<Pubkey>,
-    ) -> ProgramResult {
-        Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, false)
-    }
-
-    fn _process_initialize_account(
-        accounts: &[AccountInfo],
-        owner: Option<&Pubkey>,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let new_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let owner = if let Some(owner) = owner {
-            owner
-        } else {
-            next_account_info(account_info_iter)?.key
-        };
-        let new_account_info_data_len = new_account_info.data_len();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        let mut account_data = new_account_info.data.borrow_mut();
-        // unpack_uninitialized checks account.base.is_initialized() under the hood
-        let mut account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(&mut account_data)?;
-
-        if !rent.is_exempt(new_account_info.lamports(), new_account_info_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        // get_required_account_extensions checks mint validity
-        let mint_data = mint_info.data.borrow();
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        if mint
-            .get_extension::<PermanentDelegate>()
-            .map(|e| Option::<Pubkey>::from(e.delegate).is_some())
-            .unwrap_or(false)
-        {
-            msg!("Warning: Mint has a permanent delegate, so tokens in this account may be seized at any time");
-        }
-        let required_extensions =
-            Self::get_required_account_extensions_from_unpacked_mint(mint_info.owner, &mint)?;
-        if ExtensionType::try_calculate_account_len::<Account>(&required_extensions)?
-            > new_account_info_data_len
-        {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        for extension in required_extensions {
-            account.init_account_extension_from_type(extension)?;
-        }
-
-        let starting_state =
-            if let Ok(default_account_state) = mint.get_extension::<DefaultAccountState>() {
-                AccountState::try_from(default_account_state.state)
-                    .or(Err(ProgramError::InvalidAccountData))?
-            } else {
-                AccountState::Initialized
-            };
-
-        account.base.mint = *mint_info.key;
-        account.base.owner = *owner;
-        account.base.close_authority = PodCOption::none();
-        account.base.delegate = PodCOption::none();
-        account.base.delegated_amount = 0.into();
-        account.base.state = starting_state.into();
-        if cmp_pubkeys(mint_info.key, &native_mint::id()) {
-            let rent_exempt_reserve = rent.minimum_balance(new_account_info_data_len);
-            account.base.is_native = PodCOption::some(rent_exempt_reserve.into());
-            account.base.amount = new_account_info
-                .lamports()
-                .checked_sub(rent_exempt_reserve)
-                .ok_or(TokenError::Overflow)?
-                .into();
-        } else {
-            account.base.is_native = PodCOption::none();
-            account.base.amount = 0.into();
-        };
-
-        account.init_account_type()?;
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeAccount](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account(accounts: &[AccountInfo]) -> ProgramResult {
-        Self::_process_initialize_account(accounts, None, true)
-    }
-
-    /// Processes an [InitializeAccount2](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account2(accounts: &[AccountInfo], owner: &Pubkey) -> ProgramResult {
-        Self::_process_initialize_account(accounts, Some(owner), true)
-    }
-
-    /// Processes an [InitializeAccount3](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account3(accounts: &[AccountInfo], owner: &Pubkey) -> ProgramResult {
-        Self::_process_initialize_account(accounts, Some(owner), false)
-    }
-
-    fn _process_initialize_multisig(
-        accounts: &[AccountInfo],
-        m: u8,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let multisig_info = next_account_info(account_info_iter)?;
-        let multisig_info_data_len = multisig_info.data_len();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        let mut multisig_data = multisig_info.data.borrow_mut();
-        let multisig = pod_from_bytes_mut::<PodMultisig>(&mut multisig_data)?;
-        if bool::from(multisig.is_initialized) {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-
-        if !rent.is_exempt(multisig_info.lamports(), multisig_info_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        let signer_infos = account_info_iter.as_slice();
-        multisig.m = m;
-        multisig.n = signer_infos.len() as u8;
-        if !is_valid_signer_index(multisig.n as usize) {
-            return Err(TokenError::InvalidNumberOfProvidedSigners.into());
-        }
-        if !is_valid_signer_index(multisig.m as usize) {
-            return Err(TokenError::InvalidNumberOfRequiredSigners.into());
-        }
-        for (i, signer_info) in signer_infos.iter().enumerate() {
-            multisig.signers[i] = *signer_info.key;
-        }
-        multisig.is_initialized = true.into();
-
-        Ok(())
-    }
-
-    /// Processes a [InitializeMultisig](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_multisig(accounts: &[AccountInfo], m: u8) -> ProgramResult {
-        Self::_process_initialize_multisig(accounts, m, true)
-    }
-
-    /// Processes a [InitializeMultisig2](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_multisig2(accounts: &[AccountInfo], m: u8) -> ProgramResult {
-        Self::_process_initialize_multisig(accounts, m, false)
-    }
-
-    /// Processes a [Transfer](enum.TokenInstruction.html) instruction.
-    pub fn process_transfer(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-        expected_fee: Option<u64>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-
-        let expected_mint_info = if let Some(expected_decimals) = expected_decimals {
-            Some((next_account_info(account_info_iter)?, expected_decimals))
-        } else {
-            None
-        };
-
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        let mut source_account_data = source_account_info.data.borrow_mut();
-        let mut source_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-        if source_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-        let source_amount = u64::from(source_account.base.amount);
-        if source_amount < amount {
-            return Err(TokenError::InsufficientFunds.into());
-        }
-        if source_account
-            .get_extension::<NonTransferableAccount>()
-            .is_ok()
-        {
-            return Err(TokenError::NonTransferable.into());
-        }
-        let (fee, maybe_permanent_delegate, maybe_transfer_hook_program_id) =
-            if let Some((mint_info, expected_decimals)) = expected_mint_info {
-                if !cmp_pubkeys(&source_account.base.mint, mint_info.key) {
-                    return Err(TokenError::MintMismatch.into());
-                }
-
-                let mint_data = mint_info.try_borrow_data()?;
-                let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-
-                if expected_decimals != mint.base.decimals {
-                    return Err(TokenError::MintDecimalsMismatch.into());
-                }
-
-                let fee = if let Ok(transfer_fee_config) = mint.get_extension::<TransferFeeConfig>()
-                {
-                    transfer_fee_config
-                        .calculate_epoch_fee(Clock::get()?.epoch, amount)
-                        .ok_or(TokenError::Overflow)?
-                } else {
-                    0
-                };
-
-                let maybe_permanent_delegate = get_permanent_delegate(&mint);
-                let maybe_transfer_hook_program_id = transfer_hook::get_program_id(&mint);
-
-                (
-                    fee,
-                    maybe_permanent_delegate,
-                    maybe_transfer_hook_program_id,
-                )
-            } else {
-                // Transfer hook extension exists on the account, but no mint
-                // was provided to figure out required accounts, abort
-                if source_account
-                    .get_extension::<TransferHookAccount>()
-                    .is_ok()
-                {
-                    return Err(TokenError::MintRequiredForTransfer.into());
-                }
-
-                // Transfer fee amount extension exists on the account, but no mint
-                // was provided to calculate the fee, abort
-                if source_account
-                    .get_extension_mut::<TransferFeeAmount>()
-                    .is_ok()
-                {
-                    return Err(TokenError::MintRequiredForTransfer.into());
-                } else {
-                    (0, None, None)
-                }
-            };
-        if let Some(expected_fee) = expected_fee {
-            if expected_fee != fee {
-                msg!("Calculated fee {}, received {}", fee, expected_fee);
-                return Err(TokenError::FeeMismatch.into());
-            }
-        }
-
-        let self_transfer = cmp_pubkeys(source_account_info.key, destination_account_info.key);
-        match (source_account.base.delegate, maybe_permanent_delegate) {
-            (_, Some(ref delegate)) if cmp_pubkeys(authority_info.key, delegate) => {
-                Self::validate_owner(
-                    program_id,
-                    delegate,
-                    authority_info,
-                    authority_info_data_len,
-                    account_info_iter.as_slice(),
-                )?
-            }
-            (
-                PodCOption {
-                    option: PodCOption::<Pubkey>::SOME,
-                    value: delegate,
-                },
-                _,
-            ) if cmp_pubkeys(authority_info.key, &delegate) => {
-                Self::validate_owner(
-                    program_id,
-                    &delegate,
-                    authority_info,
-                    authority_info_data_len,
-                    account_info_iter.as_slice(),
-                )?;
-                if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
-                    // If delegated to self, don't allow a transfer with CPI Guard
-                    if delegate == source_account.base.owner
-                        && cpi_guard.lock_cpi.into()
-                        && in_cpi()
-                    {
-                        return Err(TokenError::CpiGuardTransferBlocked.into());
-                    }
-                }
-                let delegated_amount = u64::from(source_account.base.delegated_amount);
-                if delegated_amount < amount {
-                    return Err(TokenError::InsufficientFunds.into());
-                }
-                if !self_transfer {
-                    source_account.base.delegated_amount = delegated_amount
-                        .checked_sub(amount)
-                        .ok_or(TokenError::Overflow)?
-                        .into();
-                    if u64::from(source_account.base.delegated_amount) == 0 {
-                        source_account.base.delegate = PodCOption::none();
-                    }
-                }
-            }
-            _ => {
-                Self::validate_owner(
-                    program_id,
-                    &source_account.base.owner,
-                    authority_info,
-                    authority_info_data_len,
-                    account_info_iter.as_slice(),
-                )?;
-
-                if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
-                    if cpi_guard.lock_cpi.into() && in_cpi() {
-                        return Err(TokenError::CpiGuardTransferBlocked.into());
-                    }
-                }
-            }
-        }
-
-        // Revisit this later to see if it's worth adding a check to reduce
-        // compute costs, ie:
-        // if self_transfer || amount == 0
-        check_program_account(source_account_info.owner)?;
-        check_program_account(destination_account_info.owner)?;
-
-        // This check MUST occur just before the amounts are manipulated
-        // to ensure self-transfers are fully validated
-        if self_transfer {
-            return Ok(());
-        }
-
-        // self-transfer was dealt with earlier, so this *should* be safe
-        let mut destination_account_data = destination_account_info.data.borrow_mut();
-        let mut destination_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-
-        if destination_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-        if !cmp_pubkeys(&source_account.base.mint, &destination_account.base.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        if memo_required(&destination_account) {
-            check_previous_sibling_instruction_is_memo()?;
-        }
-
-        if let Ok(confidential_transfer_state) =
-            destination_account.get_extension::<ConfidentialTransferAccount>()
-        {
-            confidential_transfer_state.non_confidential_transfer_allowed()?
-        }
-
-        source_account.base.amount = source_amount
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-        let credited_amount = amount.checked_sub(fee).ok_or(TokenError::Overflow)?;
-        destination_account.base.amount = u64::from(destination_account.base.amount)
-            .checked_add(credited_amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-        if fee > 0 {
-            if let Ok(extension) = destination_account.get_extension_mut::<TransferFeeAmount>() {
-                let new_withheld_amount = u64::from(extension.withheld_amount)
-                    .checked_add(fee)
-                    .ok_or(TokenError::Overflow)?;
-                extension.withheld_amount = new_withheld_amount.into();
-            } else {
-                // Use the generic error since this should never happen. If there's
-                // a fee, then the mint has a fee configured, which means all accounts
-                // must have the withholding.
-                return Err(TokenError::InvalidState.into());
-            }
-        }
-
-        if source_account.base.is_native() {
-            let source_starting_lamports = source_account_info.lamports();
-            **source_account_info.lamports.borrow_mut() = source_starting_lamports
-                .checked_sub(amount)
-                .ok_or(TokenError::Overflow)?;
-
-            let destination_starting_lamports = destination_account_info.lamports();
-            **destination_account_info.lamports.borrow_mut() = destination_starting_lamports
-                .checked_add(amount)
-                .ok_or(TokenError::Overflow)?;
-        }
-
-        if let Some(program_id) = maybe_transfer_hook_program_id {
-            if let Some((mint_info, _)) = expected_mint_info {
-                // set transferring flags
-                transfer_hook::set_transferring(&mut source_account)?;
-                transfer_hook::set_transferring(&mut destination_account)?;
-
-                // must drop these to avoid the double-borrow during CPI
-                drop(source_account_data);
-                drop(destination_account_data);
-                spl_transfer_hook_interface::onchain::invoke_execute(
-                    &program_id,
-                    source_account_info.clone(),
-                    mint_info.clone(),
-                    destination_account_info.clone(),
-                    authority_info.clone(),
-                    account_info_iter.as_slice(),
-                    amount,
-                )?;
-
-                // unset transferring flag
-                transfer_hook::unset_transferring(source_account_info)?;
-                transfer_hook::unset_transferring(destination_account_info)?;
-            } else {
-                return Err(TokenError::MintRequiredForTransfer.into());
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Processes an [Approve](enum.TokenInstruction.html) instruction.
-    pub fn process_approve(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-
-        let expected_mint_info = if let Some(expected_decimals) = expected_decimals {
-            Some((next_account_info(account_info_iter)?, expected_decimals))
-        } else {
-            None
-        };
-        let delegate_info = next_account_info(account_info_iter)?;
-        let owner_info = next_account_info(account_info_iter)?;
-        let owner_info_data_len = owner_info.data_len();
-
-        let mut source_account_data = source_account_info.data.borrow_mut();
-        let source_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-
-        if source_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        if let Some((mint_info, expected_decimals)) = expected_mint_info {
-            if !cmp_pubkeys(&source_account.base.mint, mint_info.key) {
-                return Err(TokenError::MintMismatch.into());
-            }
-
-            let mint_data = mint_info.data.borrow();
-            let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-            if expected_decimals != mint.base.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        Self::validate_owner(
-            program_id,
-            &source_account.base.owner,
-            owner_info,
-            owner_info_data_len,
-            account_info_iter.as_slice(),
-        )?;
-
-        if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
-            if cpi_guard.lock_cpi.into() && in_cpi() {
-                return Err(TokenError::CpiGuardApproveBlocked.into());
-            }
-        }
-
-        source_account.base.delegate = PodCOption::some(*delegate_info.key);
-        source_account.base.delegated_amount = amount.into();
-
-        Ok(())
-    }
-
-    /// Processes an [Revoke](enum.TokenInstruction.html) instruction.
-    pub fn process_revoke(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        let mut source_account_data = source_account_info.data.borrow_mut();
-        let source_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-        if source_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        Self::validate_owner(
-            program_id,
-            match &source_account.base.delegate {
-                PodCOption {
-                    option: PodCOption::<Pubkey>::SOME,
-                    value: delegate,
-                } if cmp_pubkeys(authority_info.key, delegate) => delegate,
-                _ => &source_account.base.owner,
-            },
-            authority_info,
-            authority_info_data_len,
-            account_info_iter.as_slice(),
-        )?;
-
-        source_account.base.delegate = PodCOption::none();
-        source_account.base.delegated_amount = 0.into();
-
-        Ok(())
-    }
-
-    /// Processes a [SetAuthority](enum.TokenInstruction.html) instruction.
-    pub fn process_set_authority(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        authority_type: AuthorityType,
-        new_authority: PodCOption<Pubkey>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        let mut account_data = account_info.data.borrow_mut();
-        if let Ok(mut account) = PodStateWithExtensionsMut::<PodAccount>::unpack(&mut account_data)
-        {
-            if account.base.is_frozen() {
-                return Err(TokenError::AccountFrozen.into());
-            }
-
-            match authority_type {
-                AuthorityType::AccountOwner => {
-                    Self::validate_owner(
-                        program_id,
-                        &account.base.owner,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if account.get_extension_mut::<ImmutableOwner>().is_ok() {
-                        return Err(TokenError::ImmutableOwner.into());
-                    }
-
-                    if let Ok(cpi_guard) = account.get_extension::<CpiGuard>() {
-                        if cpi_guard.lock_cpi.into() && in_cpi() {
-                            return Err(TokenError::CpiGuardSetAuthorityBlocked.into());
-                        } else if cpi_guard.lock_cpi.into() {
-                            return Err(TokenError::CpiGuardOwnerChangeBlocked.into());
-                        }
-                    }
-
-                    if let PodCOption {
-                        option: PodCOption::<Pubkey>::SOME,
-                        value: authority,
-                    } = new_authority
-                    {
-                        account.base.owner = authority;
-                    } else {
-                        return Err(TokenError::InvalidInstruction.into());
-                    }
-
-                    account.base.delegate = PodCOption::none();
-                    account.base.delegated_amount = 0.into();
-
-                    if account.base.is_native() {
-                        account.base.close_authority = PodCOption::none();
-                    }
-                }
-                AuthorityType::CloseAccount => {
-                    let authority = account.base.close_authority.unwrap_or(account.base.owner);
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if let Ok(cpi_guard) = account.get_extension::<CpiGuard>() {
-                        if cpi_guard.lock_cpi.into() && in_cpi() && new_authority.is_some() {
-                            return Err(TokenError::CpiGuardSetAuthorityBlocked.into());
-                        }
-                    }
-
-                    account.base.close_authority = new_authority;
-                }
-                _ => {
-                    return Err(TokenError::AuthorityTypeNotSupported.into());
-                }
-            }
-        } else if let Ok(mut mint) = PodStateWithExtensionsMut::<PodMint>::unpack(&mut account_data)
-        {
-            match authority_type {
-                AuthorityType::MintTokens => {
-                    // Once a mint's supply is fixed, it cannot be undone by setting a new
-                    // mint_authority
-                    let mint_authority = mint
-                        .base
-                        .mint_authority
-                        .ok_or(Into::<ProgramError>::into(TokenError::FixedSupply))?;
-                    Self::validate_owner(
-                        program_id,
-                        &mint_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    mint.base.mint_authority = new_authority;
-                }
-                AuthorityType::FreezeAccount => {
-                    // Once a mint's freeze authority is disabled, it cannot be re-enabled by
-                    // setting a new freeze_authority
-                    let freeze_authority = mint
-                        .base
-                        .freeze_authority
-                        .ok_or(Into::<ProgramError>::into(TokenError::MintCannotFreeze))?;
-                    Self::validate_owner(
-                        program_id,
-                        &freeze_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    mint.base.freeze_authority = new_authority;
-                }
-                AuthorityType::CloseMint => {
-                    let extension = mint.get_extension_mut::<MintCloseAuthority>()?;
-                    let maybe_close_authority: Option<Pubkey> = extension.close_authority.into();
-                    let close_authority =
-                        maybe_close_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &close_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.close_authority = new_authority.try_into()?;
-                }
-                AuthorityType::TransferFeeConfig => {
-                    let extension = mint.get_extension_mut::<TransferFeeConfig>()?;
-                    let maybe_transfer_fee_config_authority: Option<Pubkey> =
-                        extension.transfer_fee_config_authority.into();
-                    let transfer_fee_config_authority = maybe_transfer_fee_config_authority
-                        .ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &transfer_fee_config_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.transfer_fee_config_authority = new_authority.try_into()?;
-                }
-                AuthorityType::WithheldWithdraw => {
-                    let extension = mint.get_extension_mut::<TransferFeeConfig>()?;
-                    let maybe_withdraw_withheld_authority: Option<Pubkey> =
-                        extension.withdraw_withheld_authority.into();
-                    let withdraw_withheld_authority = maybe_withdraw_withheld_authority
-                        .ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &withdraw_withheld_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.withdraw_withheld_authority = new_authority.try_into()?;
-                }
-                AuthorityType::InterestRate => {
-                    let extension = mint.get_extension_mut::<InterestBearingConfig>()?;
-                    let maybe_rate_authority: Option<Pubkey> = extension.rate_authority.into();
-                    let rate_authority =
-                        maybe_rate_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &rate_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.rate_authority = new_authority.try_into()?;
-                }
-                AuthorityType::PermanentDelegate => {
-                    let extension = mint.get_extension_mut::<PermanentDelegate>()?;
-                    let maybe_delegate: Option<Pubkey> = extension.delegate.into();
-                    let delegate = maybe_delegate.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &delegate,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.delegate = new_authority.try_into()?;
-                }
-                AuthorityType::ConfidentialTransferMint => {
-                    let extension = mint.get_extension_mut::<ConfidentialTransferMint>()?;
-                    let maybe_confidential_transfer_mint_authority: Option<Pubkey> =
-                        extension.authority.into();
-                    let confidential_transfer_mint_authority =
-                        maybe_confidential_transfer_mint_authority
-                            .ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &confidential_transfer_mint_authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                AuthorityType::TransferHookProgramId => {
-                    let extension = mint.get_extension_mut::<TransferHook>()?;
-                    let maybe_authority: Option<Pubkey> = extension.authority.into();
-                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                AuthorityType::ConfidentialTransferFeeConfig => {
-                    let extension = mint.get_extension_mut::<ConfidentialTransferFeeConfig>()?;
-                    let maybe_authority: Option<Pubkey> = extension.authority.into();
-                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                AuthorityType::MetadataPointer => {
-                    let extension = mint.get_extension_mut::<MetadataPointer>()?;
-                    let maybe_authority: Option<Pubkey> = extension.authority.into();
-                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                AuthorityType::GroupPointer => {
-                    let extension = mint.get_extension_mut::<GroupPointer>()?;
-                    let maybe_authority: Option<Pubkey> = extension.authority.into();
-                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                AuthorityType::GroupMemberPointer => {
-                    let extension = mint.get_extension_mut::<GroupMemberPointer>()?;
-                    let maybe_authority: Option<Pubkey> = extension.authority.into();
-                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-                    extension.authority = new_authority.try_into()?;
-                }
-                _ => {
-                    return Err(TokenError::AuthorityTypeNotSupported.into());
-                }
-            }
-        } else {
-            return Err(ProgramError::InvalidAccountData);
-        }
-
-        Ok(())
-    }
-
-    /// Processes a [MintTo](enum.TokenInstruction.html) instruction.
-    pub fn process_mint_to(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let owner_info = next_account_info(account_info_iter)?;
-        let owner_info_data_len = owner_info.data_len();
-
-        let mut destination_account_data = destination_account_info.data.borrow_mut();
-        let destination_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut destination_account_data)?;
-        if destination_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        if destination_account.base.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if !cmp_pubkeys(mint_info.key, &destination_account.base.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        let mut mint_data = mint_info.data.borrow_mut();
-        let mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-
-        // If the mint if non-transferable, only allow minting to accounts
-        // with immutable ownership.
-        if mint.get_extension::<NonTransferable>().is_ok()
-            && destination_account
-                .get_extension::<ImmutableOwner>()
-                .is_err()
-        {
-            return Err(TokenError::NonTransferableNeedsImmutableOwnership.into());
-        }
-
-        if let Some(expected_decimals) = expected_decimals {
-            if expected_decimals != mint.base.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        match &mint.base.mint_authority {
-            PodCOption {
-                option: PodCOption::<Pubkey>::SOME,
-                value: mint_authority,
-            } => Self::validate_owner(
-                program_id,
-                mint_authority,
-                owner_info,
-                owner_info_data_len,
-                account_info_iter.as_slice(),
-            )?,
-            _ => return Err(TokenError::FixedSupply.into()),
-        }
-
-        // Revisit this later to see if it's worth adding a check to reduce
-        // compute costs, ie:
-        // if amount == 0
-        check_program_account(mint_info.owner)?;
-        check_program_account(destination_account_info.owner)?;
-
-        destination_account.base.amount = u64::from(destination_account.base.amount)
-            .checked_add(amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-
-        mint.base.supply = u64::from(mint.base.supply)
-            .checked_add(amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-
-        Ok(())
-    }
-
-    /// Processes a [Burn](enum.TokenInstruction.html) instruction.
-    pub fn process_burn(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        let mut source_account_data = source_account_info.data.borrow_mut();
-        let source_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-        let mut mint_data = mint_info.data.borrow_mut();
-        let mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
-
-        if source_account.base.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-        if source_account.base.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if u64::from(source_account.base.amount) < amount {
-            return Err(TokenError::InsufficientFunds.into());
-        }
-        if mint_info.key != &source_account.base.mint {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        if let Some(expected_decimals) = expected_decimals {
-            if expected_decimals != mint.base.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-        let maybe_permanent_delegate = get_permanent_delegate(&mint);
-
-        if !source_account
-            .base
-            .is_owned_by_system_program_or_incinerator()
-        {
-            match (&source_account.base.delegate, maybe_permanent_delegate) {
-                (_, Some(ref delegate)) if cmp_pubkeys(authority_info.key, delegate) => {
-                    Self::validate_owner(
-                        program_id,
-                        delegate,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?
-                }
-                (
-                    PodCOption {
-                        option: PodCOption::<Pubkey>::SOME,
-                        value: delegate,
-                    },
-                    _,
-                ) if cmp_pubkeys(authority_info.key, delegate) => {
-                    Self::validate_owner(
-                        program_id,
-                        delegate,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if u64::from(source_account.base.delegated_amount) < amount {
-                        return Err(TokenError::InsufficientFunds.into());
-                    }
-                    source_account.base.delegated_amount =
-                        u64::from(source_account.base.delegated_amount)
-                            .checked_sub(amount)
-                            .ok_or(TokenError::Overflow)?
-                            .into();
-                    if u64::from(source_account.base.delegated_amount) == 0 {
-                        source_account.base.delegate = PodCOption::none();
-                    }
-                }
-                _ => {
-                    Self::validate_owner(
-                        program_id,
-                        &source_account.base.owner,
-                        authority_info,
-                        authority_info_data_len,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
-                        if cpi_guard.lock_cpi.into() && in_cpi() {
-                            return Err(TokenError::CpiGuardBurnBlocked.into());
-                        }
-                    }
-                }
-            }
-        }
-
-        // Revisit this later to see if it's worth adding a check to reduce
-        // compute costs, ie:
-        // if amount == 0
-        check_program_account(source_account_info.owner)?;
-        check_program_account(mint_info.owner)?;
-
-        source_account.base.amount = u64::from(source_account.base.amount)
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-        mint.base.supply = u64::from(mint.base.supply)
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?
-            .into();
-
-        Ok(())
-    }
-
-    /// Processes a [CloseAccount](enum.TokenInstruction.html) instruction.
-    pub fn process_close_account(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        if cmp_pubkeys(source_account_info.key, destination_account_info.key) {
-            return Err(ProgramError::InvalidAccountData);
-        }
-
-        let source_account_data = source_account_info.data.borrow();
-        if let Ok(source_account) =
-            PodStateWithExtensions::<PodAccount>::unpack(&source_account_data)
-        {
-            if !source_account.base.is_native() && u64::from(source_account.base.amount) != 0 {
-                return Err(TokenError::NonNativeHasBalance.into());
-            }
-
-            let authority = source_account
-                .base
-                .close_authority
-                .unwrap_or(source_account.base.owner);
-
-            if !source_account
-                .base
-                .is_owned_by_system_program_or_incinerator()
-            {
-                if let Ok(cpi_guard) = source_account.get_extension::<CpiGuard>() {
-                    if cpi_guard.lock_cpi.into()
-                        && in_cpi()
-                        && !cmp_pubkeys(destination_account_info.key, &source_account.base.owner)
-                    {
-                        return Err(TokenError::CpiGuardCloseAccountBlocked.into());
-                    }
-                }
-
-                Self::validate_owner(
-                    program_id,
-                    &authority,
-                    authority_info,
-                    authority_info_data_len,
-                    account_info_iter.as_slice(),
-                )?;
-            } else if !solana_program::incinerator::check_id(destination_account_info.key) {
-                return Err(ProgramError::InvalidAccountData);
-            }
-
-            if let Ok(confidential_transfer_state) =
-                source_account.get_extension::<ConfidentialTransferAccount>()
-            {
-                confidential_transfer_state.closable()?
-            }
-
-            if let Ok(confidential_transfer_fee_state) =
-                source_account.get_extension::<ConfidentialTransferFeeAmount>()
-            {
-                confidential_transfer_fee_state.closable()?
-            }
-
-            if let Ok(transfer_fee_state) = source_account.get_extension::<TransferFeeAmount>() {
-                transfer_fee_state.closable()?
-            }
-        } else if let Ok(mint) = PodStateWithExtensions::<PodMint>::unpack(&source_account_data) {
-            let extension = mint.get_extension::<MintCloseAuthority>()?;
-            let maybe_authority: Option<Pubkey> = extension.close_authority.into();
-            let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
-            Self::validate_owner(
-                program_id,
-                &authority,
-                authority_info,
-                authority_info_data_len,
-                account_info_iter.as_slice(),
-            )?;
-
-            if u64::from(mint.base.supply) != 0 {
-                return Err(TokenError::MintHasSupply.into());
-            }
-        } else {
-            return Err(ProgramError::UninitializedAccount);
-        }
-
-        let destination_starting_lamports = destination_account_info.lamports();
-        **destination_account_info.lamports.borrow_mut() = destination_starting_lamports
-            .checked_add(source_account_info.lamports())
-            .ok_or(TokenError::Overflow)?;
-
-        **source_account_info.lamports.borrow_mut() = 0;
-        drop(source_account_data);
-        delete_account(source_account_info)?;
-
-        Ok(())
-    }
-
-    /// Processes a [FreezeAccount](enum.TokenInstruction.html) or a
-    /// [ThawAccount](enum.TokenInstruction.html) instruction.
-    pub fn process_toggle_freeze_account(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        freeze: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-        let authority_info_data_len = authority_info.data_len();
-
-        let mut source_account_data = source_account_info.data.borrow_mut();
-        let source_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut source_account_data)?;
-        if freeze && source_account.base.is_frozen() || !freeze && !source_account.base.is_frozen()
-        {
-            return Err(TokenError::InvalidState.into());
-        }
-        if source_account.base.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if !cmp_pubkeys(mint_info.key, &source_account.base.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        let mint_data = mint_info.data.borrow();
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)?;
-        match &mint.base.freeze_authority {
-            PodCOption {
-                option: PodCOption::<Pubkey>::SOME,
-                value: authority,
-            } => Self::validate_owner(
-                program_id,
-                authority,
-                authority_info,
-                authority_info_data_len,
-                account_info_iter.as_slice(),
-            ),
-            _ => Err(TokenError::MintCannotFreeze.into()),
-        }?;
-
-        source_account.base.state = if freeze {
-            AccountState::Frozen.into()
-        } else {
-            AccountState::Initialized.into()
-        };
-
-        Ok(())
-    }
-
-    /// Processes a [SyncNative](enum.TokenInstruction.html) instruction
-    pub fn process_sync_native(accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let native_account_info = next_account_info(account_info_iter)?;
-
-        check_program_account(native_account_info.owner)?;
-        let mut native_account_data = native_account_info.data.borrow_mut();
-        let native_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack(&mut native_account_data)?;
-
-        match native_account.base.is_native {
-            PodCOption {
-                option: PodCOption::<PodU64>::SOME,
-                value: amount,
-            } => {
-                let new_amount = native_account_info
-                    .lamports()
-                    .checked_sub(u64::from(amount))
-                    .ok_or(TokenError::Overflow)?;
-                if new_amount < u64::from(native_account.base.amount) {
-                    return Err(TokenError::InvalidState.into());
-                }
-                native_account.base.amount = new_amount.into();
-            }
-            _ => return Err(TokenError::NonNativeNotSupported.into()),
-        }
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeMintCloseAuthority](enum.TokenInstruction.html)
-    /// instruction
-    pub fn process_initialize_mint_close_authority(
-        accounts: &[AccountInfo],
-        close_authority: PodCOption<Pubkey>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_account_info = next_account_info(account_info_iter)?;
-
-        let mut mint_data = mint_account_info.data.borrow_mut();
-        let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-        let extension = mint.init_extension::<MintCloseAuthority>(true)?;
-        extension.close_authority = close_authority.try_into()?;
-
-        Ok(())
-    }
-
-    /// Processes a [GetAccountDataSize](enum.TokenInstruction.html) instruction
-    pub fn process_get_account_data_size(
-        accounts: &[AccountInfo],
-        new_extension_types: &[ExtensionType],
-    ) -> ProgramResult {
-        if new_extension_types
-            .iter()
-            .any(|&t| t.get_account_type() != AccountType::Account)
-        {
-            return Err(TokenError::ExtensionTypeMismatch.into());
-        }
-
-        let account_info_iter = &mut accounts.iter();
-        let mint_account_info = next_account_info(account_info_iter)?;
-
-        let mut account_extensions = Self::get_required_account_extensions(mint_account_info)?;
-        // ExtensionType::try_calculate_account_len() dedupes types, so just a dumb
-        // concatenation is fine here
-        account_extensions.extend_from_slice(new_extension_types);
-
-        let account_len = ExtensionType::try_calculate_account_len::<Account>(&account_extensions)?;
-        set_return_data(&account_len.to_le_bytes());
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeImmutableOwner](enum.TokenInstruction.html)
-    /// instruction
-    pub fn process_initialize_immutable_owner(accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let token_account_info = next_account_info(account_info_iter)?;
-        let token_account_data = &mut token_account_info.data.borrow_mut();
-        let mut token_account =
-            PodStateWithExtensionsMut::<PodAccount>::unpack_uninitialized(token_account_data)?;
-        token_account
-            .init_extension::<ImmutableOwner>(true)
-            .map(|_| ())
-    }
-
-    /// Processes an [AmountToUiAmount](enum.TokenInstruction.html) instruction
-    pub fn process_amount_to_ui_amount(accounts: &[AccountInfo], amount: u64) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        check_program_account(mint_info.owner)?;
-
-        let mint_data = mint_info.data.borrow();
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        let ui_amount = if let Ok(extension) = mint.get_extension::<InterestBearingConfig>() {
-            let unix_timestamp = Clock::get()?.unix_timestamp;
-            extension
-                .amount_to_ui_amount(amount, mint.base.decimals, unix_timestamp)
-                .ok_or(ProgramError::InvalidArgument)?
-        } else {
-            crate::amount_to_ui_amount_string_trimmed(amount, mint.base.decimals)
-        };
-
-        set_return_data(&ui_amount.into_bytes());
-        Ok(())
-    }
-
-    /// Processes an [AmountToUiAmount](enum.TokenInstruction.html) instruction
-    pub fn process_ui_amount_to_amount(accounts: &[AccountInfo], ui_amount: &str) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        check_program_account(mint_info.owner)?;
-
-        let mint_data = mint_info.data.borrow();
-        let mint = PodStateWithExtensions::<PodMint>::unpack(&mint_data)
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        let amount = if let Ok(extension) = mint.get_extension::<InterestBearingConfig>() {
-            let unix_timestamp = Clock::get()?.unix_timestamp;
-            extension.try_ui_amount_into_amount(ui_amount, mint.base.decimals, unix_timestamp)?
-        } else {
-            crate::try_ui_amount_into_amount(ui_amount.to_string(), mint.base.decimals)?
-        };
-
-        set_return_data(&amount.to_le_bytes());
-        Ok(())
-    }
-
-    /// Processes a [CreateNativeMint](enum.TokenInstruction.html) instruction
-    pub fn process_create_native_mint(accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let payer_info = next_account_info(account_info_iter)?;
-        let native_mint_info = next_account_info(account_info_iter)?;
-        let system_program_info = next_account_info(account_info_iter)?;
-
-        if *native_mint_info.key != native_mint::id() {
-            return Err(TokenError::InvalidMint.into());
-        }
-
-        let rent = Rent::get()?;
-        let new_minimum_balance = rent.minimum_balance(Mint::get_packed_len());
-        let lamports_diff = new_minimum_balance.saturating_sub(native_mint_info.lamports());
-        invoke(
-            &system_instruction::transfer(payer_info.key, native_mint_info.key, lamports_diff),
-            &[
-                payer_info.clone(),
-                native_mint_info.clone(),
-                system_program_info.clone(),
-            ],
-        )?;
-
-        invoke_signed(
-            &system_instruction::allocate(native_mint_info.key, Mint::get_packed_len() as u64),
-            &[native_mint_info.clone(), system_program_info.clone()],
-            &[native_mint::PROGRAM_ADDRESS_SEEDS],
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(native_mint_info.key, &crate::id()),
-            &[native_mint_info.clone(), system_program_info.clone()],
-            &[native_mint::PROGRAM_ADDRESS_SEEDS],
-        )?;
-
-        Mint::pack(
-            Mint {
-                decimals: native_mint::DECIMALS,
-                is_initialized: true,
-                ..Mint::default()
-            },
-            &mut native_mint_info.data.borrow_mut(),
-        )
-    }
-
-    /// Processes an [InitializeNonTransferableMint](enum.TokenInstruction.html)
-    /// instruction
-    pub fn process_initialize_non_transferable_mint(accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_account_info = next_account_info(account_info_iter)?;
-
-        let mut mint_data = mint_account_info.data.borrow_mut();
-        let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-        mint.init_extension::<NonTransferable>(true)?;
-
-        Ok(())
-    }
-
-    /// Processes an [InitializePermanentDelegate](enum.TokenInstruction.html)
-    /// instruction
-    pub fn process_initialize_permanent_delegate(
-        accounts: &[AccountInfo],
-        delegate: &Pubkey,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_account_info = next_account_info(account_info_iter)?;
-
-        let mut mint_data = mint_account_info.data.borrow_mut();
-        let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
-        let extension = mint.init_extension::<PermanentDelegate>(true)?;
-        extension.delegate = Some(*delegate).try_into()?;
-
-        Ok(())
-    }
-
-    /// Withdraw Excess Lamports is used to recover Lamports transferred to any
-    /// TokenProgram owned account by moving them to another account
-    /// of the source account.
-    pub fn process_withdraw_excess_lamports(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_info = next_account_info(account_info_iter)?;
-        let destination_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        let source_data = source_info.data.borrow();
-
-        if let Ok(account) = PodStateWithExtensions::<PodAccount>::unpack(&source_data) {
-            if account.base.is_native() {
-                return Err(TokenError::NativeNotSupported.into());
-            }
-            Self::validate_owner(
-                program_id,
-                &account.base.owner,
-                authority_info,
-                authority_info.data_len(),
-                account_info_iter.as_slice(),
-            )?;
-        } else if let Ok(mint) = PodStateWithExtensions::<PodMint>::unpack(&source_data) {
-            match &mint.base.mint_authority {
-                PodCOption {
-                    option: PodCOption::<Pubkey>::SOME,
-                    value: mint_authority,
-                } => {
-                    Self::validate_owner(
-                        program_id,
-                        mint_authority,
-                        authority_info,
-                        authority_info.data_len(),
-                        account_info_iter.as_slice(),
-                    )?;
-                }
-                _ => return Err(TokenError::AuthorityTypeNotSupported.into()),
-            }
-        } else if source_data.len() == PodMultisig::SIZE_OF {
-            Self::validate_owner(
-                program_id,
-                source_info.key,
-                authority_info,
-                authority_info.data_len(),
-                account_info_iter.as_slice(),
-            )?;
-        } else {
-            return Err(TokenError::InvalidState.into());
-        }
-
-        let source_rent_exempt_reserve = Rent::get()?.minimum_balance(source_info.data_len());
-
-        let transfer_amount = source_info
-            .lamports()
-            .checked_sub(source_rent_exempt_reserve)
-            .ok_or(TokenError::NotRentExempt)?;
-
-        let source_starting_lamports = source_info.lamports();
-        **source_info.lamports.borrow_mut() = source_starting_lamports
-            .checked_sub(transfer_amount)
-            .ok_or(TokenError::Overflow)?;
-
-        let destination_starting_lamports = destination_info.lamports();
-        **destination_info.lamports.borrow_mut() = destination_starting_lamports
-            .checked_add(transfer_amount)
-            .ok_or(TokenError::Overflow)?;
-
-        Ok(())
-    }
-
-    /// Processes an [Instruction](enum.Instruction.html).
-    pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-        if let Ok(instruction_type) = decode_instruction_type(input) {
-            match instruction_type {
-                PodTokenInstruction::InitializeMint => {
-                    msg!("Instruction: InitializeMint");
-                    let (data, freeze_authority) =
-                        decode_instruction_data_with_coption_pubkey::<InitializeMintData>(input)?;
-                    Self::process_initialize_mint(
-                        accounts,
-                        data.decimals,
-                        &data.mint_authority,
-                        freeze_authority,
-                    )
-                }
-                PodTokenInstruction::InitializeMint2 => {
-                    msg!("Instruction: InitializeMint2");
-                    let (data, freeze_authority) =
-                        decode_instruction_data_with_coption_pubkey::<InitializeMintData>(input)?;
-                    Self::process_initialize_mint2(
-                        accounts,
-                        data.decimals,
-                        &data.mint_authority,
-                        freeze_authority,
-                    )
-                }
-                PodTokenInstruction::InitializeAccount => {
-                    msg!("Instruction: InitializeAccount");
-                    Self::process_initialize_account(accounts)
-                }
-                PodTokenInstruction::InitializeAccount2 => {
-                    msg!("Instruction: InitializeAccount2");
-                    let owner = decode_instruction_data::<Pubkey>(input)?;
-                    Self::process_initialize_account2(accounts, owner)
-                }
-                PodTokenInstruction::InitializeAccount3 => {
-                    msg!("Instruction: InitializeAccount3");
-                    let owner = decode_instruction_data::<Pubkey>(input)?;
-                    Self::process_initialize_account3(accounts, owner)
-                }
-                PodTokenInstruction::InitializeMultisig => {
-                    msg!("Instruction: InitializeMultisig");
-                    let data = decode_instruction_data::<InitializeMultisigData>(input)?;
-                    Self::process_initialize_multisig(accounts, data.m)
-                }
-                PodTokenInstruction::InitializeMultisig2 => {
-                    msg!("Instruction: InitializeMultisig2");
-                    let data = decode_instruction_data::<InitializeMultisigData>(input)?;
-                    Self::process_initialize_multisig2(accounts, data.m)
-                }
-                #[allow(deprecated)]
-                PodTokenInstruction::Transfer => {
-                    msg!("Instruction: Transfer");
-                    let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_transfer(program_id, accounts, data.amount.into(), None, None)
-                }
-                PodTokenInstruction::Approve => {
-                    msg!("Instruction: Approve");
-                    let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_approve(program_id, accounts, data.amount.into(), None)
-                }
-                PodTokenInstruction::Revoke => {
-                    msg!("Instruction: Revoke");
-                    Self::process_revoke(program_id, accounts)
-                }
-                PodTokenInstruction::SetAuthority => {
-                    msg!("Instruction: SetAuthority");
-                    let (data, new_authority) =
-                        decode_instruction_data_with_coption_pubkey::<SetAuthorityData>(input)?;
-                    Self::process_set_authority(
-                        program_id,
-                        accounts,
-                        AuthorityType::from(data.authority_type)?,
-                        new_authority,
-                    )
-                }
-                PodTokenInstruction::MintTo => {
-                    msg!("Instruction: MintTo");
-                    let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_mint_to(program_id, accounts, data.amount.into(), None)
-                }
-                PodTokenInstruction::Burn => {
-                    msg!("Instruction: Burn");
-                    let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_burn(program_id, accounts, data.amount.into(), None)
-                }
-                PodTokenInstruction::CloseAccount => {
-                    msg!("Instruction: CloseAccount");
-                    Self::process_close_account(program_id, accounts)
-                }
-                PodTokenInstruction::FreezeAccount => {
-                    msg!("Instruction: FreezeAccount");
-                    Self::process_toggle_freeze_account(program_id, accounts, true)
-                }
-                PodTokenInstruction::ThawAccount => {
-                    msg!("Instruction: ThawAccount");
-                    Self::process_toggle_freeze_account(program_id, accounts, false)
-                }
-                PodTokenInstruction::TransferChecked => {
-                    msg!("Instruction: TransferChecked");
-                    let data = decode_instruction_data::<AmountCheckedData>(input)?;
-                    Self::process_transfer(
-                        program_id,
-                        accounts,
-                        data.amount.into(),
-                        Some(data.decimals),
-                        None,
-                    )
-                }
-                PodTokenInstruction::ApproveChecked => {
-                    msg!("Instruction: ApproveChecked");
-                    let data = decode_instruction_data::<AmountCheckedData>(input)?;
-                    Self::process_approve(
-                        program_id,
-                        accounts,
-                        data.amount.into(),
-                        Some(data.decimals),
-                    )
-                }
-                PodTokenInstruction::MintToChecked => {
-                    msg!("Instruction: MintToChecked");
-                    let data = decode_instruction_data::<AmountCheckedData>(input)?;
-                    Self::process_mint_to(
-                        program_id,
-                        accounts,
-                        data.amount.into(),
-                        Some(data.decimals),
-                    )
-                }
-                PodTokenInstruction::BurnChecked => {
-                    msg!("Instruction: BurnChecked");
-                    let data = decode_instruction_data::<AmountCheckedData>(input)?;
-                    Self::process_burn(
-                        program_id,
-                        accounts,
-                        data.amount.into(),
-                        Some(data.decimals),
-                    )
-                }
-                PodTokenInstruction::SyncNative => {
-                    msg!("Instruction: SyncNative");
-                    Self::process_sync_native(accounts)
-                }
-                PodTokenInstruction::GetAccountDataSize => {
-                    msg!("Instruction: GetAccountDataSize");
-                    let extension_types = input[1..]
-                        .chunks(std::mem::size_of::<ExtensionType>())
-                        .map(ExtensionType::try_from)
-                        .collect::<Result<Vec<_>, _>>()?;
-                    Self::process_get_account_data_size(accounts, &extension_types)
-                }
-                PodTokenInstruction::InitializeMintCloseAuthority => {
-                    msg!("Instruction: InitializeMintCloseAuthority");
-                    let (_, close_authority) =
-                        decode_instruction_data_with_coption_pubkey::<()>(input)?;
-                    Self::process_initialize_mint_close_authority(accounts, close_authority)
-                }
-                PodTokenInstruction::TransferFeeExtension => {
-                    transfer_fee::processor::process_instruction(program_id, accounts, &input[1..])
-                }
-                PodTokenInstruction::ConfidentialTransferExtension => {
-                    confidential_transfer::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-                PodTokenInstruction::DefaultAccountStateExtension => {
-                    default_account_state::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-                PodTokenInstruction::InitializeImmutableOwner => {
-                    msg!("Instruction: InitializeImmutableOwner");
-                    Self::process_initialize_immutable_owner(accounts)
-                }
-                PodTokenInstruction::AmountToUiAmount => {
-                    msg!("Instruction: AmountToUiAmount");
-                    let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_amount_to_ui_amount(accounts, data.amount.into())
-                }
-                PodTokenInstruction::UiAmountToAmount => {
-                    msg!("Instruction: UiAmountToAmount");
-                    let ui_amount = std::str::from_utf8(&input[1..])
-                        .map_err(|_| TokenError::InvalidInstruction)?;
-                    Self::process_ui_amount_to_amount(accounts, ui_amount)
-                }
-                PodTokenInstruction::Reallocate => {
-                    msg!("Instruction: Reallocate");
-                    let extension_types = input[1..]
-                        .chunks(std::mem::size_of::<ExtensionType>())
-                        .map(ExtensionType::try_from)
-                        .collect::<Result<Vec<_>, _>>()?;
-                    reallocate::process_reallocate(program_id, accounts, extension_types)
-                }
-                PodTokenInstruction::MemoTransferExtension => {
-                    memo_transfer::processor::process_instruction(program_id, accounts, &input[1..])
-                }
-                PodTokenInstruction::CreateNativeMint => {
-                    msg!("Instruction: CreateNativeMint");
-                    Self::process_create_native_mint(accounts)
-                }
-                PodTokenInstruction::InitializeNonTransferableMint => {
-                    msg!("Instruction: InitializeNonTransferableMint");
-                    Self::process_initialize_non_transferable_mint(accounts)
-                }
-                PodTokenInstruction::InterestBearingMintExtension => {
-                    interest_bearing_mint::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-                PodTokenInstruction::CpiGuardExtension => {
-                    cpi_guard::processor::process_instruction(program_id, accounts, &input[1..])
-                }
-                PodTokenInstruction::InitializePermanentDelegate => {
-                    msg!("Instruction: InitializePermanentDelegate");
-                    let delegate = decode_instruction_data::<Pubkey>(input)?;
-                    Self::process_initialize_permanent_delegate(accounts, delegate)
-                }
-                PodTokenInstruction::TransferHookExtension => {
-                    transfer_hook::processor::process_instruction(program_id, accounts, &input[1..])
-                }
-                PodTokenInstruction::ConfidentialTransferFeeExtension => {
-                    confidential_transfer_fee::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-                PodTokenInstruction::WithdrawExcessLamports => {
-                    msg!("Instruction: WithdrawExcessLamports");
-                    Self::process_withdraw_excess_lamports(program_id, accounts)
-                }
-                PodTokenInstruction::MetadataPointerExtension => {
-                    metadata_pointer::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-                PodTokenInstruction::GroupPointerExtension => {
-                    group_pointer::processor::process_instruction(program_id, accounts, &input[1..])
-                }
-                PodTokenInstruction::GroupMemberPointerExtension => {
-                    group_member_pointer::processor::process_instruction(
-                        program_id,
-                        accounts,
-                        &input[1..],
-                    )
-                }
-            }
-        } else if let Ok(instruction) = TokenMetadataInstruction::unpack(input) {
-            token_metadata::processor::process_instruction(program_id, accounts, instruction)
-        } else if let Ok(instruction) = TokenGroupInstruction::unpack(input) {
-            token_group::processor::process_instruction(program_id, accounts, instruction)
-        } else {
-            Err(TokenError::InvalidInstruction.into())
-        }
-    }
-
-    /// Validates owner(s) are present. Used for Mints and Accounts only.
-    pub fn validate_owner(
-        program_id: &Pubkey,
-        expected_owner: &Pubkey,
-        owner_account_info: &AccountInfo,
-        owner_account_data_len: usize,
-        signers: &[AccountInfo],
-    ) -> ProgramResult {
-        if !cmp_pubkeys(expected_owner, owner_account_info.key) {
-            return Err(TokenError::OwnerMismatch.into());
-        }
-
-        if cmp_pubkeys(program_id, owner_account_info.owner)
-            && owner_account_data_len == PodMultisig::SIZE_OF
-        {
-            let multisig_data = &owner_account_info.data.borrow();
-            let multisig = pod_from_bytes::<PodMultisig>(multisig_data)?;
-            let mut num_signers = 0;
-            let mut matched = [false; MAX_SIGNERS];
-            for signer in signers.iter() {
-                for (position, key) in multisig.signers[0..multisig.n as usize].iter().enumerate() {
-                    if cmp_pubkeys(key, signer.key) && !matched[position] {
-                        if !signer.is_signer {
-                            return Err(ProgramError::MissingRequiredSignature);
-                        }
-                        matched[position] = true;
-                        num_signers += 1;
-                    }
-                }
-            }
-            if num_signers < multisig.m {
-                return Err(ProgramError::MissingRequiredSignature);
-            }
-            return Ok(());
-        } else if !owner_account_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        Ok(())
-    }
-
-    fn get_required_account_extensions(
-        mint_account_info: &AccountInfo,
-    ) -> Result<Vec<ExtensionType>, ProgramError> {
-        let mint_data = mint_account_info.data.borrow();
-        let state = PodStateWithExtensions::<PodMint>::unpack(&mint_data)
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        Self::get_required_account_extensions_from_unpacked_mint(mint_account_info.owner, &state)
-    }
-
-    fn get_required_account_extensions_from_unpacked_mint(
-        token_program_id: &Pubkey,
-        state: &PodStateWithExtensions<PodMint>,
-    ) -> Result<Vec<ExtensionType>, ProgramError> {
-        check_program_account(token_program_id)?;
-        let mint_extensions = state.get_extension_types()?;
-        Ok(ExtensionType::get_required_init_account_extensions(
-            &mint_extensions,
-        ))
-    }
-}
-
-/// Helper function to mostly delete an account in a test environment.  We could
-/// potentially muck around the bytes assuming that a vec is passed in, but that
-/// would be more trouble than it's worth.
-#[cfg(not(target_os = "solana"))]
-fn delete_account(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    account_info.assign(&system_program::id());
-    let mut account_data = account_info.data.borrow_mut();
-    let data_len = account_data.len();
-    solana_program::program_memory::sol_memset(*account_data, 0, data_len);
-    Ok(())
-}
-
-/// Helper function to totally delete an account on-chain
-#[cfg(target_os = "solana")]
-fn delete_account(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    account_info.assign(&system_program::id());
-    account_info.realloc(0, false)
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::{
-            extension::transfer_fee::instruction::initialize_transfer_fee_config, instruction::*,
-            state::Multisig,
-        },
-        serial_test::serial,
-        solana_program::{
-            account_info::IntoAccountInfo,
-            clock::Epoch,
-            instruction::Instruction,
-            program_error::{self, PrintProgramError},
-            program_option::COption,
-            sysvar::{clock::Clock, rent},
-        },
-        solana_sdk::account::{
-            create_account_for_test, create_is_signer_account_infos, Account as SolanaAccount,
-        },
-        std::sync::{Arc, RwLock},
-    };
-
-    lazy_static::lazy_static! {
-        static ref EXPECTED_DATA: Arc<RwLock<Vec<u8>>> = Arc::new(RwLock::new(Vec::new()));
-    }
-
-    fn set_expected_data(expected_data: Vec<u8>) {
-        *EXPECTED_DATA.write().unwrap() = expected_data;
-    }
-
-    struct SyscallStubs {}
-    impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
-        fn sol_log(&self, _message: &str) {}
-
-        fn sol_invoke_signed(
-            &self,
-            _instruction: &Instruction,
-            _account_infos: &[AccountInfo],
-            _signers_seeds: &[&[&[u8]]],
-        ) -> ProgramResult {
-            Err(ProgramError::Custom(42)) // Not supported
-        }
-
-        fn sol_get_clock_sysvar(&self, var_addr: *mut u8) -> u64 {
-            unsafe {
-                *(var_addr as *mut _ as *mut Clock) = Clock::default();
-            }
-            solana_program::entrypoint::SUCCESS
-        }
-
-        fn sol_get_epoch_schedule_sysvar(&self, _var_addr: *mut u8) -> u64 {
-            program_error::UNSUPPORTED_SYSVAR
-        }
-
-        #[allow(deprecated)]
-        fn sol_get_fees_sysvar(&self, _var_addr: *mut u8) -> u64 {
-            program_error::UNSUPPORTED_SYSVAR
-        }
-
-        fn sol_get_rent_sysvar(&self, var_addr: *mut u8) -> u64 {
-            unsafe {
-                *(var_addr as *mut _ as *mut Rent) = Rent::default();
-            }
-            solana_program::entrypoint::SUCCESS
-        }
-
-        fn sol_set_return_data(&self, data: &[u8]) {
-            assert_eq!(&*EXPECTED_DATA.read().unwrap(), data)
-        }
-    }
-
-    fn do_process_instruction(
-        instruction: Instruction,
-        accounts: Vec<&mut SolanaAccount>,
-    ) -> ProgramResult {
-        {
-            use std::sync::Once;
-            static ONCE: Once = Once::new();
-
-            ONCE.call_once(|| {
-                solana_sdk::program_stubs::set_syscall_stubs(Box::new(SyscallStubs {}));
-            });
-        }
-
-        let mut meta = instruction
-            .accounts
-            .iter()
-            .zip(accounts)
-            .map(|(account_meta, account)| (&account_meta.pubkey, account_meta.is_signer, account))
-            .collect::<Vec<_>>();
-
-        let account_infos = create_is_signer_account_infos(&mut meta);
-        Processor::process(&instruction.program_id, &account_infos, &instruction.data)
-    }
-
-    fn do_process_instruction_dups(
-        instruction: Instruction,
-        account_infos: Vec<AccountInfo>,
-    ) -> ProgramResult {
-        Processor::process(&instruction.program_id, &account_infos, &instruction.data)
-    }
-
-    fn return_token_error_as_program_error() -> ProgramError {
-        TokenError::MintMismatch.into()
-    }
-
-    fn rent_sysvar() -> SolanaAccount {
-        create_account_for_test(&Rent::default())
-    }
-
-    fn mint_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Mint::get_packed_len())
-    }
-
-    fn account_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Account::get_packed_len())
-    }
-
-    fn multisig_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Multisig::get_packed_len())
-    }
-
-    fn native_mint() -> SolanaAccount {
-        let mut rent_sysvar = rent_sysvar();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &crate::id());
-        do_process_instruction(
-            initialize_mint(
-                &crate::id(),
-                &crate::native_mint::id(),
-                &Pubkey::default(),
-                None,
-                crate::native_mint::DECIMALS,
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        mint_account
-    }
-
-    #[test]
-    fn test_print_error() {
-        let error = return_token_error_as_program_error();
-        error.print::<TokenError>();
-    }
-
-    #[test]
-    fn test_error_as_custom() {
-        assert_eq!(
-            return_token_error_as_program_error(),
-            ProgramError::Custom(3)
-        );
-    }
-
-    #[test]
-    fn test_unique_account_sizes() {
-        assert_ne!(Mint::get_packed_len(), 0);
-        assert_ne!(Mint::get_packed_len(), Account::get_packed_len());
-        assert_ne!(Mint::get_packed_len(), Multisig::get_packed_len());
-        assert_ne!(Account::get_packed_len(), 0);
-        assert_ne!(Account::get_packed_len(), Multisig::get_packed_len());
-        assert_ne!(Multisig::get_packed_len(), 0);
-    }
-
-    #[test]
-    fn test_initialize_mint() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // mint is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar]
-            )
-        );
-
-        mint_account.lamports = mint_minimum_balance();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2,).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar]
-            )
-        );
-
-        // create another mint that can freeze
-        do_process_instruction(
-            initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap();
-        assert_eq!(mint.freeze_authority, COption::Some(owner_key));
-    }
-
-    #[test]
-    fn test_initialize_mint2() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-
-        // mint is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account]
-            )
-        );
-
-        mint_account.lamports = mint_minimum_balance();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_mint2(&program_id, &mint_key, &owner_key, None, 2,).unwrap(),
-                vec![&mut mint_account]
-            )
-        );
-
-        // create another mint that can freeze
-        do_process_instruction(
-            initialize_mint2(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap();
-        assert_eq!(mint.freeze_authority, COption::Some(owner_key));
-    }
-
-    #[test]
-    fn test_initialize_mint_account() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(42, Account::get_packed_len(), &program_id);
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // account is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-
-        account_account.lamports = account_minimum_balance();
-
-        // mint is not valid (not initialized)
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_transfer_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into();
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_info: AccountInfo = (&account3_key, false, &mut account3_account).into();
-        let account4_key = Pubkey::new_unique();
-        let mut account4_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account4_info: AccountInfo = (&account4_key, true, &mut account4_account).into();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account2_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner transfer
-        do_process_instruction_dups(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate transfer
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.amount = 1000;
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(account1_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-
-        do_process_instruction_dups(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // test destination-owner transfer
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account3_key, &mint_key, &account2_key).unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account3_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        account1_info.is_signer = false;
-        account2_info.is_signer = true;
-        do_process_instruction_dups(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account3_key,
-                &account2_key,
-                &account2_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                account2_info.clone(),
-                account2_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // destination-owner TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account3_key,
-                &mint_key,
-                &account2_key,
-                &account2_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account2_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // test source-multisig signer
-        do_process_instruction_dups(
-            initialize_multisig(&program_id, &multisig_key, &[&account4_key], 1).unwrap(),
-            vec![
-                multisig_info.clone(),
-                rent_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account4_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                account4_info.clone(),
-                mint_info.clone(),
-                multisig_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account4_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account4_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-multisig-signer transfer
-        do_process_instruction_dups(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account4_key,
-                &account2_key,
-                &multisig_key,
-                &[&account4_key],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account4_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-multisig-signer TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account4_key,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&account4_key],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account4_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_transfer() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // missing signer
-        #[allow(deprecated)]
-        let mut instruction = transfer(
-            &program_id,
-            &account_key,
-            &account2_key,
-            &owner_key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // mismatch mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &mismatch_key,
-                    &owner_key,
-                    &[],
-                    1000
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mismatch_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner2_key,
-                    &[],
-                    1000
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0,).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-        account_account.owner = program_id;
-
-        // account 2 not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account2_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0,).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-        account2_account.owner = program_id;
-
-        // transfer
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 1).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // transfer half back
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account2_key,
-                &account_key,
-                &owner_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut account_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                transfer_checked(
-                    &program_id,
-                    &account2_key,
-                    &mint_key,
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    1,
-                    10 // <-- incorrect decimals
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut mint_account,
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // incorrect mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                transfer_checked(
-                    &program_id,
-                    &account2_key,
-                    &account3_key, // <-- incorrect mint
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    1,
-                    2
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account3_account, // <-- incorrect mint
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        // transfer rest with explicit decimals
-        do_process_instruction(
-            transfer_checked(
-                &program_id,
-                &account2_key,
-                &mint_key,
-                &account_key,
-                &owner_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut account_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(&program_id, &account2_key, &account_key, &owner_key, &[], 1).unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // not a delegate of source account
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner2_key, // <-- incorrect owner or delegate
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    101
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-
-        // transfer via delegate
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &delegate_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut delegate_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    1
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-
-        // transfer rest
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                900,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds in source account via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_self_transfer() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let account_info = (&account_key, false, &mut account_account).into_account_info();
-        let account3_info = (&account3_key, false, &mut account3_account).into_account_info();
-        let delegate_info = (&delegate_key, true, &mut delegate_account).into_account_info();
-        let owner_info = (&owner_key, true, &mut owner_account).into_account_info();
-        let owner2_info = (&owner2_key, true, &mut owner2_account).into_account_info();
-        let mint_info = (&mint_key, false, &mut mint_account).into_account_info();
-
-        // transfer
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // transfer checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // missing signer
-        let mut owner_no_sign_info = owner_info.clone();
-        #[allow(deprecated)]
-        let mut instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_no_sign_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        owner_no_sign_info.is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_no_sign_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing signer checked
-        let mut instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_no_sign_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        instruction.accounts[3].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_no_sign_info,
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing owner
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner2_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner2_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing owner checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner2_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner2_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // insufficient funds
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1001,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // insufficient funds checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1001,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // incorrect decimals
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1,
-            10, // <-- incorrect decimals
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // incorrect mint
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            account3_info.key, // <-- incorrect mint
-            account_info.key,
-            owner_info.key,
-            &[],
-            1,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account3_info.clone(), // <-- incorrect mint
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // approve delegate
-        let instruction = approve(
-            &program_id,
-            account_info.key,
-            delegate_info.key,
-            owner_info.key,
-            &[],
-            100,
-        )
-        .unwrap();
-        Processor::process(
-            &instruction.program_id,
-            &[
-                account_info.clone(),
-                delegate_info.clone(),
-                owner_info.clone(),
-            ],
-            &instruction.data,
-        )
-        .unwrap();
-
-        // delegate transfer
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            100,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-        assert_eq!(account.delegated_amount, 100);
-
-        // delegate transfer checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            100,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-        assert_eq!(account.delegated_amount, 100);
-
-        // delegate insufficient funds
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            101,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // delegate insufficient funds checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            101,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // owner transfer with delegate assigned
-        #[allow(deprecated)]
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // owner transfer with delegate assigned checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-    }
-
-    #[test]
-    fn test_mintable_token_with_zero_supply() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint-able token with zero supply
-        let decimals = 2;
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, decimals).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(
-            mint,
-            Mint {
-                mint_authority: COption::Some(owner_key),
-                supply: 0,
-                decimals,
-                is_initialized: true,
-                freeze_authority: COption::None,
-            }
-        );
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to 2, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                mint_to_checked(
-                    &program_id,
-                    &mint_key,
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    42,
-                    decimals + 1
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to 2
-        do_process_instruction(
-            mint_to_checked(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &owner_key,
-                &[],
-                42,
-                decimals,
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 84);
-    }
-
-    #[test]
-    fn test_approve_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into();
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_info: AccountInfo = (&account3_key, true, &mut account3_account).into();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account2_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner approve
-        do_process_instruction_dups(
-            approve(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner approve_checked
-        do_process_instruction_dups(
-            approve_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner revoke
-        do_process_instruction_dups(
-            revoke(&program_id, &account1_key, &account1_key, &[]).unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-
-        // test source-multisig signer
-        do_process_instruction_dups(
-            initialize_multisig(&program_id, &multisig_key, &[&account3_key], 1).unwrap(),
-            vec![
-                multisig_info.clone(),
-                rent_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account3_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                multisig_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account3_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-multisig-signer approve
-        do_process_instruction_dups(
-            approve(
-                &program_id,
-                &account3_key,
-                &account2_key,
-                &multisig_key,
-                &[&account3_key],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-multisig-signer approve_checked
-        do_process_instruction_dups(
-            approve_checked(
-                &program_id,
-                &account3_key,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&account3_key],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner multisig-signer
-        do_process_instruction_dups(
-            revoke(&program_id, &account3_key, &multisig_key, &[&account3_key]).unwrap(),
-            vec![
-                account3_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // approve to source
-        do_process_instruction_dups(
-            approve_checked(
-                &program_id,
-                &account2_key,
-                &mint_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account2_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                owner_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate revoke, force account2 to be a signer
-        let account2_info: AccountInfo = (&account2_key, true, &mut account2_account).into();
-        do_process_instruction_dups(
-            revoke(&program_id, &account2_key, &account2_key, &[]).unwrap(),
-            vec![account2_info.clone(), account2_info.clone()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_approve() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // missing signer
-        let mut instruction = approve(
-            &program_id,
-            &account_key,
-            &delegate_key,
-            &owner_key,
-            &[],
-            100,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                approve(
-                    &program_id,
-                    &account_key,
-                    &delegate_key,
-                    &owner2_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // approve delegate 2, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                approve_checked(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100,
-                    0 // <-- incorrect decimals
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate 2, with incorrect mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                approve_checked(
-                    &program_id,
-                    &account_key,
-                    &account2_key, // <-- bad mint
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100,
-                    0
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account, // <-- bad mint
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate 2
-        do_process_instruction(
-            approve_checked(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-                2,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // revoke delegate
-        do_process_instruction(
-            revoke(&program_id, &account_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // approve delegate 3
-        do_process_instruction(
-            approve_checked(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-                2,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // revoke by delegate
-        do_process_instruction(
-            revoke(&program_id, &account_key, &delegate_key, &[]).unwrap(),
-            vec![&mut account_account, &mut delegate_account],
-        )
-        .unwrap();
-
-        // fails the second time
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                revoke(&program_id, &account_key, &delegate_key, &[]).unwrap(),
-                vec![&mut account_account, &mut delegate_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_set_authority_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &mint_key, Some(&mint_key), 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // set mint_authority when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::MintTokens,
-                &mint_key,
-                &[],
-            )
-            .unwrap(),
-            vec![mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // set freeze_authority when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::FreezeAccount,
-                &mint_key,
-                &[],
-            )
-            .unwrap(),
-            vec![mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // set account owner when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &account1_key,
-                Some(&owner_key),
-                AuthorityType::AccountOwner,
-                &account1_key,
-                &[],
-            )
-            .unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-
-        // set close_authority when currently self
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.close_authority = COption::Some(account1_key);
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &account1_key,
-                Some(&owner_key),
-                AuthorityType::CloseAccount,
-                &account1_key,
-                &[],
-            )
-            .unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_set_authority() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let owner3_key = Pubkey::new_unique();
-        let mut owner3_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create mint with owner and freeze_authority
-        do_process_instruction(
-            initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // invalid account
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner2_key),
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint2_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint2_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner_key),
-                    AuthorityType::AccountOwner,
-                    &owner2_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner2_account],
-            )
-        );
-
-        // owner did not sign
-        let mut instruction = set_authority(
-            &program_id,
-            &account_key,
-            Some(&owner2_key),
-            AuthorityType::AccountOwner,
-            &owner_key,
-            &[],
-        )
-        .unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(instruction, vec![&mut account_account, &mut owner_account,],)
-        );
-
-        // wrong authority type
-        assert_eq!(
-            Err(TokenError::AuthorityTypeNotSupported.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // account owner may not be set to None
-        assert_eq!(
-            Err(TokenError::InvalidInstruction.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    None,
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // set delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &owner2_key,
-                &owner_key,
-                &[],
-                u64::MAX,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut owner2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.delegate, COption::Some(owner2_key));
-        assert_eq!(account.delegated_amount, u64::MAX);
-
-        // set owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner3_key),
-                AuthorityType::AccountOwner,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // check delegate cleared
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.delegate, COption::None);
-        assert_eq!(account.delegated_amount, 0);
-
-        // set owner without existing delegate
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::AccountOwner,
-                &owner3_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner3_account],
-        )
-        .unwrap();
-
-        // set close_authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::CloseAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // close_authority may be set to None
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                None,
-                AuthorityType::CloseAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // wrong owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint_key,
-                    Some(&owner3_key),
-                    AuthorityType::MintTokens,
-                    &owner2_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // owner did not sign
-        let mut instruction = set_authority(
-            &program_id,
-            &mint_key,
-            Some(&owner2_key),
-            AuthorityType::MintTokens,
-            &owner_key,
-            &[],
-        )
-        .unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(instruction, vec![&mut mint_account, &mut owner_account],)
-        );
-
-        // cannot freeze
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner_account],
-            )
-        );
-
-        // set owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner2_key),
-                AuthorityType::MintTokens,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // set owner to None
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                None,
-                AuthorityType::MintTokens,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // test unsetting mint_authority is one-way operation
-        assert_eq!(
-            Err(TokenError::FixedSupply.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint2_key,
-                    Some(&owner2_key),
-                    AuthorityType::MintTokens,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner_account],
-            )
-        );
-
-        // set freeze_authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint2_key,
-                Some(&owner2_key),
-                AuthorityType::FreezeAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // test unsetting freeze_authority is one-way operation
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint2_key,
-                None,
-                AuthorityType::FreezeAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint2_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut mint2_account, &mut owner2_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_set_authority_with_immutable_owner_extension() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-
-        let account_len =
-            ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::ImmutableOwner])
-                .unwrap();
-        let mut account_account = SolanaAccount::new(
-            Rent::default().minimum_balance(account_len),
-            account_len,
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar],
-            )
-        );
-
-        // create account
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_immutable_owner(&program_id, &account_key).unwrap(),
-                vec![&mut account_account],
-            )
-        );
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar,
-                ],
-            )
-        );
-
-        // Immutable Owner extension blocks account owner authority changes
-        assert_eq!(
-            Err(TokenError::ImmutableOwner.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner2_key),
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_mint_to_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &mint_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint_to when mint_authority is self
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &mint_key, &[], 42).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint_to_checked when mint_authority is self
-        do_process_instruction_dups(
-            mint_to_checked(&program_id, &mint_key, &account1_key, &mint_key, &[], 42, 2).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint_to when mint_authority is account owner
-        let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow()).unwrap();
-        mint.mint_authority = COption::Some(account1_key);
-        Mint::pack(mint, &mut mint_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                42,
-            )
-            .unwrap(),
-            vec![
-                mint_info.clone(),
-                account1_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint_to_checked when mint_authority is account owner
-        do_process_instruction_dups(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                42,
-            )
-            .unwrap(),
-            vec![
-                mint_info.clone(),
-                account1_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_mint_to() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let uninitialized_key = Pubkey::new_unique();
-        let mut uninitialized_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // mint to
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 42);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to another account to test supply accumulation
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account2_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 84);
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // missing signer
-        let mut instruction =
-            mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![&mut mint_account, &mut account2_account, &mut owner_account],
-            )
-        );
-
-        // mismatch account
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mint_account, &mut mismatch_account, &mut owner_account],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account2_key, &owner2_key, &[], 42).unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-        account_account.owner = program_id;
-
-        // uninitialized destination account
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &uninitialized_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut uninitialized_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // unset mint_authority and test minting fails
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                None,
-                AuthorityType::MintTokens,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::FixedSupply.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mint_account, &mut account2_account, &mut owner_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_burn_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner burn
-        do_process_instruction_dups(
-            burn(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint-owner burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.owner = mint_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint-owner burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &mint_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // source-delegate burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(account1_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint-delegate burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(mint_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint-delegate burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &mint_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_burn() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // mint to mismatch account and change mint key
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut mismatch_account, &mut owner_account],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // missing signer
-        let mut instruction =
-            burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 42).unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner2_key, &[], 42).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-        account_account.owner = program_id;
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // mint mismatch
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &mismatch_key, &mint_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mismatch_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // burn
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 21).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // burn_checked, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 3).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // burn_checked
-        do_process_instruction(
-            burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 2).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 2000 - 42);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 1000 - 42);
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &owner_key,
-                    &[],
-                    100_000_000
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                84,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // not a delegate of source account
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &owner2_key, // <-- incorrect owner or delegate
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 85).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-
-        // burn via delegate
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 84).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut delegate_account,
-            ],
-        )
-        .unwrap();
-
-        // match
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 2000 - 42 - 84);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 1000 - 42 - 84);
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 1).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_multisig() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let account_key = Pubkey::new_unique();
-        let mut account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(42, Multisig::get_packed_len(), &program_id);
-        let multisig_delegate_key = Pubkey::new_unique();
-        let mut multisig_delegate_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let signer_keys = vec![Pubkey::new_unique(); MAX_SIGNERS];
-        let signer_key_refs: Vec<&Pubkey> = signer_keys.iter().collect();
-        let mut signer_accounts = vec![SolanaAccount::new(0, 0, &program_id); MAX_SIGNERS];
-        let mut rent_sysvar = rent_sysvar();
-
-        // multisig is not rent exempt
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-                vec![
-                    &mut multisig_account,
-                    &mut rent_sysvar,
-                    account_info_iter.next().unwrap(),
-                ],
-            )
-        );
-
-        multisig_account.lamports = multisig_minimum_balance();
-        let mut multisig_account2 = multisig_account.clone();
-
-        // single signer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-            vec![
-                &mut multisig_account,
-                &mut rent_sysvar,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // single signer using `initialize_multisig2`
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig2(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-            vec![&mut multisig_account2, account_info_iter.next().unwrap()],
-        )
-        .unwrap();
-
-        // multiple signer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig(
-                &program_id,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                MAX_SIGNERS as u8,
-            )
-            .unwrap(),
-            vec![
-                &mut multisig_delegate_account,
-                &mut rent_sysvar,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // create new mint with multisig owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &multisig_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account with multisig owner
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account with multisig owner
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &mint_key,
-                &multisig_delegate_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut multisig_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // approve
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &multisig_delegate_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut multisig_delegate_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // transfer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut account2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // transfer via delegate
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut account2_account,
-                &mut multisig_delegate_account,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // mint to
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // burn
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            burn(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // burn via delegate
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            burn(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_delegate_account,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // freeze account
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        do_process_instruction(
-            initialize_mint(
-                &program_id,
-                &mint2_key,
-                &multisig_key,
-                Some(&multisig_key),
-                2,
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint2_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint2_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint2_key,
-                &account3_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut mint2_account,
-                &mut account3_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            freeze_account(
-                &program_id,
-                &account3_key,
-                &mint2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // do SetAuthority on mint
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::MintTokens,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // do SetAuthority on account
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner_key),
-                AuthorityType::AccountOwner,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_validate_owner() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let account_to_validate = Pubkey::new_unique();
-        let mut signer_keys = [Pubkey::default(); MAX_SIGNERS];
-        for signer_key in signer_keys.iter_mut().take(MAX_SIGNERS) {
-            *signer_key = Pubkey::new_unique();
-        }
-        let mut signer_lamports = 0;
-        let mut signer_data = vec![];
-        let mut signers = vec![
-            AccountInfo::new(
-                &owner_key,
-                true,
-                false,
-                &mut signer_lamports,
-                &mut signer_data,
-                &program_id,
-                false,
-                Epoch::default(),
-            );
-            MAX_SIGNERS + 1
-        ];
-        for (signer, key) in signers.iter_mut().zip(&signer_keys) {
-            signer.key = key;
-        }
-        let mut lamports = 0;
-        let mut data = vec![0; Multisig::get_packed_len()];
-        let mut multisig = Multisig::unpack_unchecked(&data).unwrap();
-        multisig.m = MAX_SIGNERS as u8;
-        multisig.n = MAX_SIGNERS as u8;
-        multisig.signers = signer_keys;
-        multisig.is_initialized = true;
-        Multisig::pack(multisig, &mut data).unwrap();
-        let owner_account_info = AccountInfo::new(
-            &owner_key,
-            false,
-            false,
-            &mut lamports,
-            &mut data,
-            &program_id,
-            false,
-            Epoch::default(),
-        );
-
-        // no multisig, but the account is its own authority, and data is mutably
-        // borrowed
-        {
-            let mut lamports = 0;
-            let mut data = vec![0; Account::get_packed_len()];
-            let mut account = Account::unpack_unchecked(&data).unwrap();
-            account.owner = account_to_validate;
-            Account::pack(account, &mut data).unwrap();
-            let account_info = AccountInfo::new(
-                &account_to_validate,
-                true,
-                false,
-                &mut lamports,
-                &mut data,
-                &program_id,
-                false,
-                Epoch::default(),
-            );
-            let account_info_data_len = account_info.data_len();
-            let mut borrowed_data = account_info.try_borrow_mut_data().unwrap();
-            Processor::validate_owner(
-                &program_id,
-                &account_to_validate,
-                &account_info,
-                account_info_data_len,
-                &[],
-            )
-            .unwrap();
-            // modify the data to be sure that it wasn't silently dropped by the compiler
-            borrowed_data[0] = 1;
-        }
-
-        // full 11 of 11
-        Processor::validate_owner(
-            &program_id,
-            &owner_key,
-            &owner_account_info,
-            owner_account_info.data_len(),
-            &signers,
-        )
-        .unwrap();
-
-        // 1 of 11
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 1;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(
-            &program_id,
-            &owner_key,
-            &owner_account_info,
-            owner_account_info.data_len(),
-            &signers,
-        )
-        .unwrap();
-
-        // 2:1
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 1;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(
-                &program_id,
-                &owner_key,
-                &owner_account_info,
-                owner_account_info.data_len(),
-                &signers
-            )
-        );
-
-        // 0:11
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 0;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(
-            &program_id,
-            &owner_key,
-            &owner_account_info,
-            owner_account_info.data_len(),
-            &signers,
-        )
-        .unwrap();
-
-        // 2:11 but 0 provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(
-                &program_id,
-                &owner_key,
-                &owner_account_info,
-                owner_account_info.data_len(),
-                &[]
-            )
-        );
-        // 2:11 but 1 provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(
-                &program_id,
-                &owner_key,
-                &owner_account_info,
-                owner_account_info.data_len(),
-                &signers[0..1]
-            )
-        );
-
-        // 2:11, 2 from middle provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(
-            &program_id,
-            &owner_key,
-            &owner_account_info,
-            owner_account_info.data_len(),
-            &signers[5..7],
-        )
-        .unwrap();
-
-        // 11:11, one is not a signer
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 11;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        signers[5].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(
-                &program_id,
-                &owner_key,
-                &owner_account_info,
-                owner_account_info.data_len(),
-                &signers
-            )
-        );
-        signers[5].is_signer = true;
-
-        // 11:11, single signer signs multiple times
-        {
-            let mut signer_lamports = 0;
-            let mut signer_data = vec![];
-            let signers = vec![
-                AccountInfo::new(
-                    &signer_keys[5],
-                    true,
-                    false,
-                    &mut signer_lamports,
-                    &mut signer_data,
-                    &program_id,
-                    false,
-                    Epoch::default(),
-                );
-                MAX_SIGNERS + 1
-            ];
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 11;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-            assert_eq!(
-                Err(ProgramError::MissingRequiredSignature),
-                Processor::validate_owner(
-                    &program_id,
-                    &owner_key,
-                    &owner_account_info,
-                    owner_account_info.data_len(),
-                    &signers
-                )
-            );
-        }
-    }
-
-    #[test]
-    fn test_owner_close_account_dups() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        let to_close_key = Pubkey::new_unique();
-        let mut to_close_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let to_close_account_info: AccountInfo =
-            (&to_close_key, true, &mut to_close_account).into();
-        let destination_account_key = Pubkey::new_unique();
-        let mut destination_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let destination_account_info: AccountInfo =
-            (&destination_account_key, true, &mut destination_account).into();
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                mint_info.clone(),
-                to_close_account_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner close
-        do_process_instruction_dups(
-            close_account(
-                &program_id,
-                &to_close_key,
-                &destination_account_key,
-                &to_close_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                destination_account_info.clone(),
-                to_close_account_info.clone(),
-            ],
-        )
-        .unwrap();
-        assert_eq!(*to_close_account_info.data.borrow(), &[0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_close_authority_close_account_dups() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        let to_close_key = Pubkey::new_unique();
-        let mut to_close_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let to_close_account_info: AccountInfo =
-            (&to_close_key, true, &mut to_close_account).into();
-        let destination_account_key = Pubkey::new_unique();
-        let mut destination_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let destination_account_info: AccountInfo =
-            (&destination_account_key, true, &mut destination_account).into();
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                mint_info.clone(),
-                to_close_account_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&to_close_account_info.data.borrow()).unwrap();
-        account.close_authority = COption::Some(to_close_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut to_close_account_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            close_account(
-                &program_id,
-                &to_close_key,
-                &destination_account_key,
-                &to_close_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                destination_account_info.clone(),
-                to_close_account_info.clone(),
-            ],
-        )
-        .unwrap();
-        assert_eq!(*to_close_account_info.data.borrow(), &[0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_close_account() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance() + 42,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mut rent_sysvar = rent_sysvar();
-
-        // uninitialized
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // initialize and mint to non-native account
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 42);
-
-        // close non-native account with balance
-        assert_eq!(
-            Err(TokenError::NonNativeHasBalance.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        assert_eq!(account_account.lamports, account_minimum_balance());
-
-        // empty account
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // wrong owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // close account
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance());
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 0);
-
-        // fund and initialize new non-native account to test close authority
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        account_account.lamports = 2;
-
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::CloseAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // account owner cannot authorize close if close_authority is set
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // close non-native account with close_authority
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner2_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance() + 2);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 0);
-
-        // close native account
-        do_process_instruction(
-            close_account(&program_id, &account2_key, &account3_key, &owner_key, &[]).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut account3_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account2_account.data, [0u8; Account::LEN]);
-        assert_eq!(
-            account3_account.lamports,
-            3 * account_minimum_balance() + 2 + 42
-        );
-    }
-
-    #[test]
-    fn test_native_token() {
-        let program_id = crate::id();
-        let mut mint_account = native_mint();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance() + 40,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(account_minimum_balance(), 0, &program_id);
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let owner3_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 40);
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 0);
-
-        // mint_to unsupported
-        assert_eq!(
-            Err(TokenError::NativeNotSupported.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &crate::native_mint::id(),
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-
-        // burn unsupported
-        let bogus_mint_key = Pubkey::new_unique();
-        let mut bogus_mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        do_process_instruction(
-            initialize_mint(&program_id, &bogus_mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut bogus_mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        assert_eq!(
-            Err(TokenError::NativeNotSupported.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &bogus_mint_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut bogus_mint_account,
-                    &mut owner_account
-                ],
-            )
-        );
-
-        // ensure can't transfer below rent-exempt reserve
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    50,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // transfer between native accounts
-        do_process_instruction(
-            #[allow(deprecated)]
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                40,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, account_minimum_balance());
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 0);
-        assert_eq!(account2_account.lamports, account_minimum_balance() + 40);
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 40);
-
-        // set close authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner3_key),
-                AuthorityType::CloseAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.close_authority, COption::Some(owner3_key));
-
-        // set new account owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::AccountOwner,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // close authority cleared
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.close_authority, COption::None);
-
-        // close native account
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner2_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance());
-        assert_eq!(account_account.data, [0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_overflow() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_owner_key = Pubkey::new_unique();
-        let mut mint_owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &mint_owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create an account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner2_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner2_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint the max to an account
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &mint_owner_key,
-                &[],
-                u64::MAX,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut mint_owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // attempt to mint one more to account
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &account_key,
-                    &mint_owner_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account_account,
-                    &mut mint_owner_account,
-                ],
-            )
-        );
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // attempt to mint one more to the other account
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &account2_key,
-                    &mint_owner_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account2_account,
-                    &mut mint_owner_account,
-                ],
-            )
-        );
-
-        // burn some of the supply
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX - 100);
-
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &mint_owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut mint_owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // manipulate account balance to attempt overflow transfer
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.amount = 1;
-        Account::pack(account, &mut account2_account.data).unwrap();
-
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account2_key,
-                    &account_key,
-                    &owner2_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_frozen() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint and fund first account
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // fund first account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // no transfer if either account is frozen
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account2_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    500,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.state = AccountState::Initialized;
-        Account::pack(account, &mut account_account.data).unwrap();
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account2_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                #[allow(deprecated)]
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    500,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no approve if account is frozen
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account_account.data).unwrap();
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                approve(
-                    &program_id,
-                    &account_key,
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no revoke if account is frozen
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.delegate = COption::Some(delegate_key);
-        account.delegated_amount = 100;
-        Account::pack(account, &mut account_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                revoke(&program_id, &account_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // no set authority if account is frozen
-        let new_owner_key = Pubkey::new_unique();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&new_owner_key),
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account,],
-            )
-        );
-
-        // no mint_to if destination account is frozen
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 100).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account,],
-            )
-        );
-
-        // no burn if account is frozen
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_freeze_thaw_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, Some(&account1_key), 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // freeze where mint freeze_authority is account
-        do_process_instruction_dups(
-            freeze_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // thaw where mint freeze_authority is account
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            thaw_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_freeze_account() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account_owner_key = Pubkey::new_unique();
-        let mut account_owner_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner different from account owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &account_owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut account_owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // mint cannot freeze
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // missing freeze_authority
-        let mut mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        mint.freeze_authority = COption::Some(owner_key);
-        Mint::pack(mint, &mut mint_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // check explicit thaw
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // freeze
-        do_process_instruction(
-            freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.state, AccountState::Frozen);
-
-        // check explicit freeze
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // check thaw authority
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // thaw
-        do_process_instruction(
-            thaw_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.state, AccountState::Initialized);
-    }
-
-    #[test]
-    fn test_initialize_account2_and_3() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            initialize_account2(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![&mut account2_account, &mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        assert_eq!(account_account, account2_account);
-
-        do_process_instruction(
-            initialize_account3(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![&mut account3_account, &mut mint_account],
-        )
-        .unwrap();
-
-        assert_eq!(account_account, account3_account);
-    }
-
-    #[test]
-    fn initialize_account_on_non_transferable_mint() {
-        let program_id = crate::id();
-        let account = Pubkey::new_unique();
-        let account_len = ExtensionType::try_calculate_account_len::<Mint>(&[
-            ExtensionType::NonTransferableAccount,
-        ])
-        .unwrap();
-        let mut account_without_enough_length = SolanaAccount::new(
-            Rent::default().minimum_balance(account_len),
-            account_len,
-            &program_id,
-        );
-
-        let account2 = Pubkey::new_unique();
-        let account2_len = ExtensionType::try_calculate_account_len::<Mint>(&[
-            ExtensionType::NonTransferableAccount,
-            ExtensionType::ImmutableOwner,
-        ])
-        .unwrap();
-        let mut account_with_enough_length = SolanaAccount::new(
-            Rent::default().minimum_balance(account2_len),
-            account2_len,
-            &program_id,
-        );
-
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mint_len =
-            ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::NonTransferable])
-                .unwrap();
-        let mut mint_account = SolanaAccount::new(
-            Rent::default().minimum_balance(mint_len),
-            mint_len,
-            &program_id,
-        );
-        let mut rent_sysvar = rent_sysvar();
-
-        // create a non-transferable mint
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_non_transferable_mint(&program_id, &mint_key).unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar]
-            )
-        );
-
-        //fail when account space is not enough for adding the immutable ownership
-        // extension
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            do_process_instruction(
-                initialize_account(&program_id, &account, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_without_enough_length,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar,
-                ]
-            )
-        );
-
-        //success to initialize an account with enough data space
-        assert_eq!(
-            Ok(()),
-            do_process_instruction(
-                initialize_account(&program_id, &account2, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_with_enough_length,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar,
-                ]
-            )
-        );
-    }
-
-    #[test]
-    fn test_sync_native() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let native_account_key = Pubkey::new_unique();
-        let lamports = 40;
-        let mut native_account = SolanaAccount::new(
-            account_minimum_balance() + lamports,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let non_native_account_key = Pubkey::new_unique();
-        let mut non_native_account = SolanaAccount::new(
-            account_minimum_balance() + 50,
-            Account::get_packed_len(),
-            &program_id,
-        );
-
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mut rent_sysvar = rent_sysvar();
-
-        // initialize non-native mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // initialize non-native account
-        do_process_instruction(
-            initialize_account(&program_id, &non_native_account_key, &mint_key, &owner_key)
-                .unwrap(),
-            vec![
-                &mut non_native_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        let account = Account::unpack_unchecked(&non_native_account.data).unwrap();
-        assert!(!account.is_native());
-        assert_eq!(account.amount, 0);
-
-        // fail sync non-native
-        assert_eq!(
-            Err(TokenError::NonNativeNotSupported.into()),
-            do_process_instruction(
-                sync_native(&program_id, &non_native_account_key,).unwrap(),
-                vec![&mut non_native_account],
-            )
-        );
-
-        // fail sync uninitialized
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-
-        // wrap native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &native_account_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut native_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // fail sync, not owned by program
-        let not_program_id = Pubkey::new_unique();
-        native_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-        native_account.owner = program_id;
-
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, lamports);
-
-        // sync, no change
-        do_process_instruction(
-            sync_native(&program_id, &native_account_key).unwrap(),
-            vec![&mut native_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert_eq!(account.amount, lamports);
-
-        // transfer sol
-        let new_lamports = lamports + 50;
-        native_account.lamports = account_minimum_balance() + new_lamports;
-
-        // success sync
-        do_process_instruction(
-            sync_native(&program_id, &native_account_key).unwrap(),
-            vec![&mut native_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert_eq!(account.amount, new_lamports);
-
-        // reduce sol
-        native_account.lamports -= 1;
-
-        // fail sync
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn test_get_account_data_size() {
-        // see integration tests for return-data validity
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mut rent_sysvar = rent_sysvar();
-
-        // Base mint
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_key = Pubkey::new_unique();
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data(
-            ExtensionType::try_calculate_account_len::<Account>(&[])
-                .unwrap()
-                .to_le_bytes()
-                .to_vec(),
-        );
-        do_process_instruction(
-            get_account_data_size(&program_id, &mint_key, &[]).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(
-            ExtensionType::try_calculate_account_len::<Account>(&[
-                ExtensionType::TransferFeeAmount,
-            ])
-            .unwrap()
-            .to_le_bytes()
-            .to_vec(),
-        );
-        do_process_instruction(
-            get_account_data_size(
-                &program_id,
-                &mint_key,
-                &[
-                    ExtensionType::TransferFeeAmount,
-                    ExtensionType::TransferFeeAmount, // Duplicate user input ignored...
-                ],
-            )
-            .unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // Native mint
-        let mut mint_account = native_mint();
-        set_expected_data(
-            ExtensionType::try_calculate_account_len::<Account>(&[])
-                .unwrap()
-                .to_le_bytes()
-                .to_vec(),
-        );
-        do_process_instruction(
-            get_account_data_size(&program_id, &mint_key, &[]).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // Extended mint
-        let mint_len =
-            ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::TransferFeeConfig])
-                .unwrap();
-        let mut extended_mint_account = SolanaAccount::new(
-            Rent::default().minimum_balance(mint_len),
-            mint_len,
-            &program_id,
-        );
-        let extended_mint_key = Pubkey::new_unique();
-        do_process_instruction(
-            initialize_transfer_fee_config(&program_id, &extended_mint_key, None, None, 10, 4242)
-                .unwrap(),
-            vec![&mut extended_mint_account],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_mint(&program_id, &extended_mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut extended_mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data(
-            ExtensionType::try_calculate_account_len::<Account>(&[
-                ExtensionType::TransferFeeAmount,
-            ])
-            .unwrap()
-            .to_le_bytes()
-            .to_vec(),
-        );
-        do_process_instruction(
-            get_account_data_size(&program_id, &mint_key, &[]).unwrap(),
-            vec![&mut extended_mint_account],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            get_account_data_size(
-                &program_id,
-                &mint_key,
-                // User extension that's also added by the mint ignored...
-                &[ExtensionType::TransferFeeAmount],
-            )
-            .unwrap(),
-            vec![&mut extended_mint_account],
-        )
-        .unwrap();
-
-        // Invalid mint
-        let mut invalid_mint_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let invalid_mint_key = Pubkey::new_unique();
-        do_process_instruction(
-            initialize_account(&program_id, &invalid_mint_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut invalid_mint_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(
-            do_process_instruction(
-                get_account_data_size(&program_id, &invalid_mint_key, &[]).unwrap(),
-                vec![&mut invalid_mint_account],
-            ),
-            Err(TokenError::InvalidMint.into())
-        );
-
-        // Invalid mint owner
-        let invalid_program_id = Pubkey::new_unique();
-        let mut invalid_mint_account = SolanaAccount::new(
-            mint_minimum_balance(),
-            Mint::get_packed_len(),
-            &invalid_program_id,
-        );
-        let invalid_mint_key = Pubkey::new_unique();
-        let mut instruction =
-            initialize_mint(&program_id, &invalid_mint_key, &owner_key, None, 2).unwrap();
-        instruction.program_id = invalid_program_id;
-        do_process_instruction(
-            instruction,
-            vec![&mut invalid_mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        assert_eq!(
-            do_process_instruction(
-                get_account_data_size(&program_id, &invalid_mint_key, &[]).unwrap(),
-                vec![&mut invalid_mint_account],
-            ),
-            Err(ProgramError::IncorrectProgramId)
-        );
-
-        // Invalid Extension Type for mint and uninitialized account
-        assert_eq!(
-            do_process_instruction(
-                get_account_data_size(&program_id, &mint_key, &[ExtensionType::Uninitialized])
-                    .unwrap(),
-                vec![&mut mint_account],
-            ),
-            Err(TokenError::ExtensionTypeMismatch.into())
-        );
-        assert_eq!(
-            do_process_instruction(
-                get_account_data_size(
-                    &program_id,
-                    &mint_key,
-                    &[
-                        ExtensionType::MemoTransfer,
-                        ExtensionType::MintCloseAuthority
-                    ]
-                )
-                .unwrap(),
-                vec![&mut mint_account],
-            ),
-            Err(TokenError::ExtensionTypeMismatch.into())
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn test_amount_to_ui_amount() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // fail if an invalid mint is passed in
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data("0.23".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 23).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("1.1".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("42".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 4200).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("0".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 0).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[serial]
-    fn test_ui_amount_to_amount() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // fail if an invalid mint is passed in
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data(23u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.23").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.20").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.2000").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, ".20").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(110u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(110u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "1.10").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(4200u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "42").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(4200u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "42.").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(0u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // fail if invalid ui_amount passed in
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, ".").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "0.111").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "0.t").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn test_withdraw_excess_lamports_from_multisig() {
-        {
-            use std::sync::Once;
-            static ONCE: Once = Once::new();
-
-            ONCE.call_once(|| {
-                solana_sdk::program_stubs::set_syscall_stubs(Box::new(SyscallStubs {}));
-            });
-        }
-        let program_id = crate::id();
-
-        let mut lamports = 0;
-        let mut destination_data = vec![];
-        let system_program_id = system_program::id();
-        let destination_key = Pubkey::new_unique();
-        let destination_info = AccountInfo::new(
-            &destination_key,
-            true,
-            false,
-            &mut lamports,
-            &mut destination_data,
-            &system_program_id,
-            false,
-            Epoch::default(),
-        );
-
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(0, Multisig::get_packed_len(), &program_id);
-        let excess_lamports = 4_000_000_000_000;
-        multisig_account.lamports = excess_lamports + multisig_minimum_balance();
-        let mut signer_keys = [Pubkey::default(); MAX_SIGNERS];
-
-        for signer_key in signer_keys.iter_mut().take(MAX_SIGNERS) {
-            *signer_key = Pubkey::new_unique();
-        }
-        let signer_refs: Vec<&Pubkey> = signer_keys.iter().collect();
-        let mut signer_lamports = 0;
-        let mut signer_data = vec![];
-        let mut signers: Vec<AccountInfo<'_>> = vec![
-            AccountInfo::new(
-                &destination_key,
-                true,
-                false,
-                &mut signer_lamports,
-                &mut signer_data,
-                &program_id,
-                false,
-                Epoch::default(),
-            );
-            MAX_SIGNERS + 1
-        ];
-        for (signer, key) in signers.iter_mut().zip(&signer_keys) {
-            signer.key = key;
-        }
-
-        let mut multisig =
-            Multisig::unpack_unchecked(&vec![0; Multisig::get_packed_len()]).unwrap();
-        multisig.m = MAX_SIGNERS as u8;
-        multisig.n = MAX_SIGNERS as u8;
-        multisig.signers = signer_keys;
-        multisig.is_initialized = true;
-        Multisig::pack(multisig, &mut multisig_account.data).unwrap();
-
-        let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into();
-
-        let mut signers_infos = vec![
-            multisig_info.clone(),
-            destination_info.clone(),
-            multisig_info.clone(),
-        ];
-        signers_infos.extend(signers);
-        do_process_instruction_dups(
-            withdraw_excess_lamports(
-                &program_id,
-                &multisig_key,
-                &destination_key,
-                &multisig_key,
-                &signer_refs,
-            )
-            .unwrap(),
-            signers_infos,
-        )
-        .unwrap();
-
-        assert_eq!(destination_info.lamports(), excess_lamports);
-    }
-
-    #[test]
-    #[serial]
-    fn test_withdraw_excess_lamports_from_account() {
-        let excess_lamports = 4_000_000_000_000;
-
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            excess_lamports + account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-
-        let system_program_id = system_program::id();
-        let owner_key = Pubkey::new_unique();
-
-        let mut destination_lamports = 0;
-        let mut destination_data = vec![];
-        let destination_key = Pubkey::new_unique();
-        let destination_info = AccountInfo::new(
-            &destination_key,
-            true,
-            false,
-            &mut destination_lamports,
-            &mut destination_data,
-            &system_program_id,
-            false,
-            Epoch::default(),
-        );
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-
-        let mut rent_sysvar = rent_sysvar();
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        let mint_info = AccountInfo::new(
-            &mint_key,
-            true,
-            false,
-            &mut mint_account.lamports,
-            &mut mint_account.data,
-            &program_id,
-            false,
-            Epoch::default(),
-        );
-
-        let account_info: AccountInfo = (&account_key, true, &mut account_account).into();
-
-        do_process_instruction_dups(
-            initialize_account3(&program_id, &account_key, &mint_key, &account_key).unwrap(),
-            vec![account_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            withdraw_excess_lamports(
-                &program_id,
-                &account_key,
-                &destination_key,
-                &account_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                account_info.clone(),
-                destination_info.clone(),
-                account_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(destination_info.lamports(), excess_lamports);
-    }
-
-    #[test]
-    #[serial]
-    fn test_withdraw_excess_lamports_from_mint() {
-        let excess_lamports = 4_000_000_000_000;
-
-        let program_id = crate::id();
-        let system_program_id = system_program::id();
-
-        let mut destination_lamports = 0;
-        let mut destination_data = vec![];
-        let destination_key = Pubkey::new_unique();
-        let destination_info = AccountInfo::new(
-            &destination_key,
-            true,
-            false,
-            &mut destination_lamports,
-            &mut destination_data,
-            &system_program_id,
-            false,
-            Epoch::default(),
-        );
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account = SolanaAccount::new(
-            excess_lamports + mint_minimum_balance(),
-            Mint::get_packed_len(),
-            &program_id,
-        );
-        let mut rent_sysvar = rent_sysvar();
-
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &mint_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-
-        do_process_instruction_dups(
-            withdraw_excess_lamports(&program_id, &mint_key, &destination_key, &mint_key, &[])
-                .unwrap(),
-            vec![
-                mint_info.clone(),
-                destination_info.clone(),
-                mint_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(destination_info.lamports(), excess_lamports);
-    }
-}
diff --git a/token/program-2022/src/proof.rs b/token/program-2022/src/proof.rs
deleted file mode 100644
index fbb9b525a10..00000000000
--- a/token/program-2022/src/proof.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//! Helper for processing instruction data from ZK Token proof program
-
-use {
-    bytemuck::Pod,
-    solana_program::{instruction::Instruction, msg, program_error::ProgramError, pubkey::Pubkey},
-    solana_zk_token_sdk::{
-        instruction::ZkProofData, zk_token_proof_instruction::ProofInstruction,
-        zk_token_proof_program,
-    },
-    std::num::NonZeroI8,
-};
-
-/// Decodes the proof context data associated with a zero-knowledge proof
-/// instruction.
-pub fn decode_proof_instruction_context<T: Pod + ZkProofData<U>, U: Pod>(
-    expected: ProofInstruction,
-    instruction: &Instruction,
-) -> Result<&U, ProgramError> {
-    if instruction.program_id != zk_token_proof_program::id()
-        || ProofInstruction::instruction_type(&instruction.data) != Some(expected)
-    {
-        msg!("Unexpected proof instruction");
-        return Err(ProgramError::InvalidInstructionData);
-    }
-
-    ProofInstruction::proof_data::<T, U>(&instruction.data)
-        .map(ZkProofData::context_data)
-        .ok_or(ProgramError::InvalidInstructionData)
-}
-
-/// A proof location type meant to be used for arguments to instruction
-/// constructors.
-#[derive(Clone, Copy)]
-pub enum ProofLocation<'a, T> {
-    /// The proof is included in the same transaction of a corresponding
-    /// token-2022 instruction.
-    InstructionOffset(NonZeroI8, &'a T),
-    /// The proof is pre-verified into a context state account.
-    ContextStateAccount(&'a Pubkey),
-}
-
-/// Instruction options for when using split context state accounts
-#[derive(Clone, Copy)]
-pub struct SplitContextStateAccountsConfig {
-    /// If true, execute no op when an associated split proof context state
-    /// account is not initialized. Otherwise, fail on an uninitialized
-    /// context state account.
-    pub no_op_on_uninitialized_split_context_state: bool,
-    /// Close associated context states after a complete execution of the
-    /// transfer instruction.
-    pub close_split_context_state_on_execution: bool,
-}
diff --git a/token/program-2022/src/serialization.rs b/token/program-2022/src/serialization.rs
deleted file mode 100644
index 9287caacab8..00000000000
--- a/token/program-2022/src/serialization.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-//! serialization module - contains helpers for serde types from other crates,
-//! deserialization visitors
-
-use {
-    base64::{prelude::BASE64_STANDARD, Engine},
-    serde::de::Error,
-};
-
-/// helper function to convert base64 encoded string into a bytes array
-fn base64_to_bytes<const N: usize, E: Error>(v: &str) -> Result<[u8; N], E> {
-    let bytes = BASE64_STANDARD.decode(v).map_err(Error::custom)?;
-
-    if bytes.len() != N {
-        return Err(Error::custom(format!(
-            "Length of base64 decoded bytes is not {}",
-            N
-        )));
-    }
-
-    let mut array = [0; N];
-    array.copy_from_slice(&bytes[0..N]);
-    Ok(array)
-}
-
-/// helper function to ser/deser COption wrapped values
-pub mod coption_fromstr {
-    use {
-        serde::{
-            de::{Error, Unexpected, Visitor},
-            Deserializer, Serializer,
-        },
-        solana_program::program_option::COption,
-        std::{
-            fmt::{self, Display},
-            marker::PhantomData,
-            str::FromStr,
-        },
-    };
-
-    /// serialize values supporting Display trait wrapped in COption
-    pub fn serialize<S, T>(x: &COption<T>, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-        T: Display,
-    {
-        match *x {
-            COption::Some(ref value) => s.serialize_some(&value.to_string()),
-            COption::None => s.serialize_none(),
-        }
-    }
-
-    struct COptionVisitor<T> {
-        s: PhantomData<T>,
-    }
-
-    impl<'de, T> Visitor<'de> for COptionVisitor<T>
-    where
-        T: FromStr,
-    {
-        type Value = COption<T>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a FromStr type")
-        }
-
-        fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            d.deserialize_str(self)
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            T::from_str(v)
-                .map(|r| COption::Some(r))
-                .map_err(|_| E::invalid_value(Unexpected::Str(v), &"value string"))
-        }
-
-        fn visit_none<E>(self) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(COption::None)
-        }
-    }
-
-    /// deserialize values supporting Display trait wrapped in COption
-    pub fn deserialize<'de, D, T>(d: D) -> Result<COption<T>, D::Error>
-    where
-        D: Deserializer<'de>,
-        T: FromStr,
-    {
-        d.deserialize_option(COptionVisitor {
-            s: PhantomData::default(),
-        })
-    }
-}
-
-/// helper to ser/deser AeCiphertext values
-pub mod aeciphertext_fromstr {
-    use {
-        serde::{
-            de::{Error, Visitor},
-            Deserializer, Serializer,
-        },
-        solana_zk_token_sdk::zk_token_elgamal::pod::AeCiphertext,
-        std::fmt,
-    };
-
-    const AE_CIPHERTEXT_LEN: usize = 36;
-
-    /// serialize AeCiphertext values supporting Display trait
-    pub fn serialize<S>(x: &AeCiphertext, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        s.serialize_str(&x.to_string())
-    }
-
-    struct AeCiphertextVisitor;
-
-    impl<'de> Visitor<'de> for AeCiphertextVisitor {
-        type Value = AeCiphertext;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a FromStr type")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let array = super::base64_to_bytes::<AE_CIPHERTEXT_LEN, E>(v)?;
-            Ok(AeCiphertext(array))
-        }
-    }
-
-    /// deserialize AeCiphertext values from str
-    pub fn deserialize<'de, D>(d: D) -> Result<AeCiphertext, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        d.deserialize_str(AeCiphertextVisitor)
-    }
-}
-
-/// helper to ser/deser pod::ElGamalPubkey values
-pub mod elgamalpubkey_fromstr {
-    use {
-        serde::{
-            de::{Error, Visitor},
-            Deserializer, Serializer,
-        },
-        solana_zk_token_sdk::zk_token_elgamal::pod::ElGamalPubkey,
-        std::fmt,
-    };
-
-    const ELGAMAL_PUBKEY_LEN: usize = 32;
-
-    /// serialize ElGamalPubkey values supporting Display trait
-    pub fn serialize<S>(x: &ElGamalPubkey, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        s.serialize_str(&x.to_string())
-    }
-
-    struct ElGamalPubkeyVisitor;
-
-    impl<'de> Visitor<'de> for ElGamalPubkeyVisitor {
-        type Value = ElGamalPubkey;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a FromStr type")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let array = super::base64_to_bytes::<ELGAMAL_PUBKEY_LEN, E>(v)?;
-            Ok(ElGamalPubkey(array))
-        }
-    }
-
-    /// deserialize ElGamalPubkey values from str
-    pub fn deserialize<'de, D>(d: D) -> Result<ElGamalPubkey, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        d.deserialize_str(ElGamalPubkeyVisitor)
-    }
-}
-
-/// helper to ser/deser pod::DecryptHandle values
-pub mod decrypthandle_fromstr {
-    use {
-        base64::{prelude::BASE64_STANDARD, Engine},
-        serde::{
-            de::{Error, Visitor},
-            Deserializer, Serializer,
-        },
-        solana_zk_token_sdk::zk_token_elgamal::pod::DecryptHandle,
-        std::fmt,
-    };
-
-    const DECRYPT_HANDLE_LEN: usize = 32;
-
-    /// Serialize a decrypt handle as a base64 string
-    pub fn serialize<S>(x: &DecryptHandle, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        s.serialize_str(&BASE64_STANDARD.encode(x.0))
-    }
-
-    struct DecryptHandleVisitor;
-
-    impl<'de> Visitor<'de> for DecryptHandleVisitor {
-        type Value = DecryptHandle;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a FromStr type")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let array = super::base64_to_bytes::<DECRYPT_HANDLE_LEN, E>(v)?;
-            Ok(DecryptHandle(array))
-        }
-    }
-
-    /// Deserialize a DecryptHandle from a base64 string
-    pub fn deserialize<'de, D>(d: D) -> Result<DecryptHandle, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        d.deserialize_str(DecryptHandleVisitor)
-    }
-}
diff --git a/token/program-2022/src/state.rs b/token/program-2022/src/state.rs
deleted file mode 100644
index 40e9f76a64e..00000000000
--- a/token/program-2022/src/state.rs
+++ /dev/null
@@ -1,553 +0,0 @@
-//! State transition types
-
-use {
-    crate::{
-        extension::AccountType,
-        generic_token_account::{is_initialized_account, GenericTokenAccount},
-        instruction::MAX_SIGNERS,
-    },
-    arrayref::{array_mut_ref, array_ref, array_refs, mut_array_refs},
-    num_enum::{IntoPrimitive, TryFromPrimitive},
-    solana_program::{
-        program_error::ProgramError,
-        program_option::COption,
-        program_pack::{IsInitialized, Pack, Sealed},
-        pubkey::Pubkey,
-    },
-};
-
-/// Simplified version of the `Pack` trait which only gives the size of the
-/// packed struct. Useful when a function doesn't need a type to implement all
-/// of `Pack`, but a size is still needed.
-pub trait PackedSizeOf {
-    /// The packed size of the struct
-    const SIZE_OF: usize;
-}
-
-/// Mint data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Mint {
-    /// Optional authority used to mint new tokens. The mint authority may only
-    /// be provided during mint creation. If no mint authority is present
-    /// then the mint has a fixed supply and no further tokens may be
-    /// minted.
-    pub mint_authority: COption<Pubkey>,
-    /// Total supply of tokens.
-    pub supply: u64,
-    /// Number of base 10 digits to the right of the decimal place.
-    pub decimals: u8,
-    /// Is `true` if this structure has been initialized
-    pub is_initialized: bool,
-    /// Optional authority to freeze token accounts.
-    pub freeze_authority: COption<Pubkey>,
-}
-impl Sealed for Mint {}
-impl IsInitialized for Mint {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized
-    }
-}
-impl Pack for Mint {
-    const LEN: usize = 82;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 82];
-        let (mint_authority, supply, decimals, is_initialized, freeze_authority) =
-            array_refs![src, 36, 8, 1, 1, 36];
-        let mint_authority = unpack_coption_key(mint_authority)?;
-        let supply = u64::from_le_bytes(*supply);
-        let decimals = decimals[0];
-        let is_initialized = match is_initialized {
-            [0] => false,
-            [1] => true,
-            _ => return Err(ProgramError::InvalidAccountData),
-        };
-        let freeze_authority = unpack_coption_key(freeze_authority)?;
-        Ok(Mint {
-            mint_authority,
-            supply,
-            decimals,
-            is_initialized,
-            freeze_authority,
-        })
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 82];
-        let (
-            mint_authority_dst,
-            supply_dst,
-            decimals_dst,
-            is_initialized_dst,
-            freeze_authority_dst,
-        ) = mut_array_refs![dst, 36, 8, 1, 1, 36];
-        let &Mint {
-            ref mint_authority,
-            supply,
-            decimals,
-            is_initialized,
-            ref freeze_authority,
-        } = self;
-        pack_coption_key(mint_authority, mint_authority_dst);
-        *supply_dst = supply.to_le_bytes();
-        decimals_dst[0] = decimals;
-        is_initialized_dst[0] = is_initialized as u8;
-        pack_coption_key(freeze_authority, freeze_authority_dst);
-    }
-}
-impl PackedSizeOf for Mint {
-    const SIZE_OF: usize = Self::LEN;
-}
-
-/// Account data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Account {
-    /// The mint associated with this account
-    pub mint: Pubkey,
-    /// The owner of this account.
-    pub owner: Pubkey,
-    /// The amount of tokens this account holds.
-    pub amount: u64,
-    /// If `delegate` is `Some` then `delegated_amount` represents
-    /// the amount authorized by the delegate
-    pub delegate: COption<Pubkey>,
-    /// The account's state
-    pub state: AccountState,
-    /// If is_some, this is a native token, and the value logs the rent-exempt
-    /// reserve. An Account is required to be rent-exempt, so the value is
-    /// used by the Processor to ensure that wrapped SOL accounts do not
-    /// drop below this threshold.
-    pub is_native: COption<u64>,
-    /// The amount delegated
-    pub delegated_amount: u64,
-    /// Optional authority to close the account.
-    pub close_authority: COption<Pubkey>,
-}
-impl Account {
-    /// Checks if account is frozen
-    pub fn is_frozen(&self) -> bool {
-        self.state == AccountState::Frozen
-    }
-    /// Checks if account is native
-    pub fn is_native(&self) -> bool {
-        self.is_native.is_some()
-    }
-    /// Checks if a token Account's owner is the system_program or the
-    /// incinerator
-    pub fn is_owned_by_system_program_or_incinerator(&self) -> bool {
-        solana_program::system_program::check_id(&self.owner)
-            || solana_program::incinerator::check_id(&self.owner)
-    }
-}
-impl Sealed for Account {}
-impl IsInitialized for Account {
-    fn is_initialized(&self) -> bool {
-        self.state != AccountState::Uninitialized
-    }
-}
-impl Pack for Account {
-    const LEN: usize = 165;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 165];
-        let (mint, owner, amount, delegate, state, is_native, delegated_amount, close_authority) =
-            array_refs![src, 32, 32, 8, 36, 1, 12, 8, 36];
-        Ok(Account {
-            mint: Pubkey::new_from_array(*mint),
-            owner: Pubkey::new_from_array(*owner),
-            amount: u64::from_le_bytes(*amount),
-            delegate: unpack_coption_key(delegate)?,
-            state: AccountState::try_from_primitive(state[0])
-                .or(Err(ProgramError::InvalidAccountData))?,
-            is_native: unpack_coption_u64(is_native)?,
-            delegated_amount: u64::from_le_bytes(*delegated_amount),
-            close_authority: unpack_coption_key(close_authority)?,
-        })
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 165];
-        let (
-            mint_dst,
-            owner_dst,
-            amount_dst,
-            delegate_dst,
-            state_dst,
-            is_native_dst,
-            delegated_amount_dst,
-            close_authority_dst,
-        ) = mut_array_refs![dst, 32, 32, 8, 36, 1, 12, 8, 36];
-        let &Account {
-            ref mint,
-            ref owner,
-            amount,
-            ref delegate,
-            state,
-            ref is_native,
-            delegated_amount,
-            ref close_authority,
-        } = self;
-        mint_dst.copy_from_slice(mint.as_ref());
-        owner_dst.copy_from_slice(owner.as_ref());
-        *amount_dst = amount.to_le_bytes();
-        pack_coption_key(delegate, delegate_dst);
-        state_dst[0] = state as u8;
-        pack_coption_u64(is_native, is_native_dst);
-        *delegated_amount_dst = delegated_amount.to_le_bytes();
-        pack_coption_key(close_authority, close_authority_dst);
-    }
-}
-impl PackedSizeOf for Account {
-    const SIZE_OF: usize = Self::LEN;
-}
-
-/// Account state.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, IntoPrimitive, TryFromPrimitive)]
-pub enum AccountState {
-    /// Account is not yet initialized
-    #[default]
-    Uninitialized,
-    /// Account is initialized; the account owner and/or delegate may perform
-    /// permitted operations on this account
-    Initialized,
-    /// Account has been frozen by the mint freeze authority. Neither the
-    /// account owner nor the delegate are able to perform operations on
-    /// this account.
-    Frozen,
-}
-
-/// Multisignature data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Multisig {
-    /// Number of signers required
-    pub m: u8,
-    /// Number of valid signers
-    pub n: u8,
-    /// Is `true` if this structure has been initialized
-    pub is_initialized: bool,
-    /// Signer public keys
-    pub signers: [Pubkey; MAX_SIGNERS],
-}
-impl Sealed for Multisig {}
-impl IsInitialized for Multisig {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized
-    }
-}
-impl Pack for Multisig {
-    const LEN: usize = 355;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 355];
-        #[allow(clippy::ptr_offset_with_cast)]
-        let (m, n, is_initialized, signers_flat) = array_refs![src, 1, 1, 1, 32 * MAX_SIGNERS];
-        let mut result = Multisig {
-            m: m[0],
-            n: n[0],
-            is_initialized: match is_initialized {
-                [0] => false,
-                [1] => true,
-                _ => return Err(ProgramError::InvalidAccountData),
-            },
-            signers: [Pubkey::new_from_array([0u8; 32]); MAX_SIGNERS],
-        };
-        for (src, dst) in signers_flat.chunks(32).zip(result.signers.iter_mut()) {
-            *dst = Pubkey::try_from(src).map_err(|_| ProgramError::InvalidAccountData)?;
-        }
-        Ok(result)
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 355];
-        #[allow(clippy::ptr_offset_with_cast)]
-        let (m, n, is_initialized, signers_flat) = mut_array_refs![dst, 1, 1, 1, 32 * MAX_SIGNERS];
-        *m = [self.m];
-        *n = [self.n];
-        *is_initialized = [self.is_initialized as u8];
-        for (i, src) in self.signers.iter().enumerate() {
-            let dst_array = array_mut_ref![signers_flat, 32 * i, 32];
-            dst_array.copy_from_slice(src.as_ref());
-        }
-    }
-}
-impl PackedSizeOf for Multisig {
-    const SIZE_OF: usize = Self::LEN;
-}
-
-// Helpers
-pub(crate) fn pack_coption_key(src: &COption<Pubkey>, dst: &mut [u8; 36]) {
-    let (tag, body) = mut_array_refs![dst, 4, 32];
-    match src {
-        COption::Some(key) => {
-            *tag = [1, 0, 0, 0];
-            body.copy_from_slice(key.as_ref());
-        }
-        COption::None => {
-            *tag = [0; 4];
-        }
-    }
-}
-pub(crate) fn unpack_coption_key(src: &[u8; 36]) -> Result<COption<Pubkey>, ProgramError> {
-    let (tag, body) = array_refs![src, 4, 32];
-    match *tag {
-        [0, 0, 0, 0] => Ok(COption::None),
-        [1, 0, 0, 0] => Ok(COption::Some(Pubkey::new_from_array(*body))),
-        _ => Err(ProgramError::InvalidAccountData),
-    }
-}
-fn pack_coption_u64(src: &COption<u64>, dst: &mut [u8; 12]) {
-    let (tag, body) = mut_array_refs![dst, 4, 8];
-    match src {
-        COption::Some(amount) => {
-            *tag = [1, 0, 0, 0];
-            *body = amount.to_le_bytes();
-        }
-        COption::None => {
-            *tag = [0; 4];
-        }
-    }
-}
-fn unpack_coption_u64(src: &[u8; 12]) -> Result<COption<u64>, ProgramError> {
-    let (tag, body) = array_refs![src, 4, 8];
-    match *tag {
-        [0, 0, 0, 0] => Ok(COption::None),
-        [1, 0, 0, 0] => Ok(COption::Some(u64::from_le_bytes(*body))),
-        _ => Err(ProgramError::InvalidAccountData),
-    }
-}
-
-// `spl_token_program_2022::extension::AccountType::Account` ordinal value
-const ACCOUNTTYPE_ACCOUNT: u8 = AccountType::Account as u8;
-impl GenericTokenAccount for Account {
-    fn valid_account_data(account_data: &[u8]) -> bool {
-        // Use spl_token::state::Account::valid_account_data once possible
-        account_data.len() == Account::LEN && is_initialized_account(account_data)
-            || (account_data.len() > Account::LEN
-                && account_data.len() != Multisig::LEN
-                && ACCOUNTTYPE_ACCOUNT == account_data[Account::LEN]
-                && is_initialized_account(account_data))
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-    use {super::*, crate::generic_token_account::ACCOUNT_INITIALIZED_INDEX};
-
-    pub const TEST_MINT: Mint = Mint {
-        mint_authority: COption::Some(Pubkey::new_from_array([1; 32])),
-        supply: 42,
-        decimals: 7,
-        is_initialized: true,
-        freeze_authority: COption::Some(Pubkey::new_from_array([2; 32])),
-    };
-    pub const TEST_MINT_SLICE: &[u8] = &[
-        1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    ];
-
-    pub const TEST_ACCOUNT: Account = Account {
-        mint: Pubkey::new_from_array([1; 32]),
-        owner: Pubkey::new_from_array([2; 32]),
-        amount: 3,
-        delegate: COption::Some(Pubkey::new_from_array([4; 32])),
-        state: AccountState::Frozen,
-        is_native: COption::Some(5),
-        delegated_amount: 6,
-        close_authority: COption::Some(Pubkey::new_from_array([7; 32])),
-    };
-    pub const TEST_ACCOUNT_SLICE: &[u8] = &[
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0,
-        0, 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    ];
-    pub const TEST_MULTISIG: Multisig = Multisig {
-        m: 1,
-        n: 11,
-        is_initialized: true,
-        signers: [
-            Pubkey::new_from_array([1; 32]),
-            Pubkey::new_from_array([2; 32]),
-            Pubkey::new_from_array([3; 32]),
-            Pubkey::new_from_array([4; 32]),
-            Pubkey::new_from_array([5; 32]),
-            Pubkey::new_from_array([6; 32]),
-            Pubkey::new_from_array([7; 32]),
-            Pubkey::new_from_array([8; 32]),
-            Pubkey::new_from_array([9; 32]),
-            Pubkey::new_from_array([10; 32]),
-            Pubkey::new_from_array([11; 32]),
-        ],
-    };
-    pub const TEST_MULTISIG_SLICE: &[u8] = &[
-        1, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-        3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
-        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
-        9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10,
-        10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-        10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-        11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-    ];
-
-    #[test]
-    fn test_pack_unpack() {
-        // Mint
-        let check = TEST_MINT;
-        let mut packed = vec![0; Mint::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Mint::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Mint::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Mint::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Mint::get_packed_len()];
-        Mint::pack(check, &mut packed).unwrap();
-        assert_eq!(packed, TEST_MINT_SLICE);
-        let unpacked = Mint::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-
-        // Account
-        let check = TEST_ACCOUNT;
-        let mut packed = vec![0; Account::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Account::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Account::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Account::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Account::get_packed_len()];
-        Account::pack(check, &mut packed).unwrap();
-        let expect = TEST_ACCOUNT_SLICE;
-        assert_eq!(packed, expect);
-        let unpacked = Account::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-
-        // Multisig
-        let check = TEST_MULTISIG;
-        let mut packed = vec![0; Multisig::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Multisig::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Multisig::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Multisig::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Multisig::get_packed_len()];
-        Multisig::pack(check, &mut packed).unwrap();
-        let expect = TEST_MULTISIG_SLICE;
-        assert_eq!(packed, expect);
-        let unpacked = Multisig::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-    }
-
-    #[test]
-    fn test_unpack_token_owner() {
-        // Account data length < Account::LEN, unpack will not return a key
-        let src: [u8; 12] = [0; 12];
-        let result = Account::unpack_account_owner(&src);
-        assert_eq!(result, Option::None);
-
-        // The right account data size and initialized, unpack will return some key
-        let mut src: [u8; Account::LEN] = [0; Account::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_some());
-
-        // The right account data size and frozen, unpack will return some key
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Frozen as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_some());
-
-        // Account data length > account data size, but not a valid extension,
-        // unpack will not return a key
-        let mut src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert_eq!(result, Option::None);
-
-        // Account data length > account data size with a valid extension and
-        // initialized, expect some key returned
-        let mut src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        src[Account::LEN] = AccountType::Account as u8;
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_some());
-
-        // Account data length > account data size with a valid extension but
-        // uninitialized, expect None
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Uninitialized as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_none());
-
-        // Account data length is multi-sig data size with a valid extension and
-        // initialized, expect none
-        let mut src: [u8; Multisig::LEN] = [0; Multisig::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        src[Account::LEN] = AccountType::Account as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn test_unpack_token_mint() {
-        // Account data length < Account::LEN, unpack will not return a key
-        let src: [u8; 12] = [0; 12];
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-
-        // The right account data size and initialized, unpack will return some key
-        let mut src: [u8; Account::LEN] = [0; Account::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_some());
-
-        // The right account data size and frozen, unpack will return some key
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Frozen as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_some());
-
-        // Account data length > account data size, but not a valid extension,
-        // unpack will not return a key
-        let mut src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-
-        // Account data length > account data size with a valid extension and
-        // initialized, expect some key returned
-        let mut src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        src[Account::LEN] = AccountType::Account as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_some());
-
-        // Account data length > account data size with a valid extension but
-        // uninitialized, expect none
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Uninitialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_none());
-
-        // Account data length is multi-sig data size with a valid extension and
-        // initialized, expect none
-        let mut src: [u8; Multisig::LEN] = [0; Multisig::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        src[Account::LEN] = AccountType::Account as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_none());
-    }
-}
diff --git a/token/program-2022/tests/action.rs b/token/program-2022/tests/action.rs
deleted file mode 100644
index 9eec4563f4f..00000000000
--- a/token/program-2022/tests/action.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-use {
-    solana_program_test::BanksClient,
-    solana_sdk::{
-        hash::Hash,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-        transport::TransportError,
-    },
-    spl_token_2022::{
-        id, instruction,
-        state::{Account, Mint},
-    },
-};
-
-pub async fn create_mint(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    pool_mint: &Keypair,
-    manager: &Pubkey,
-    decimals: u8,
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let mint_rent = rent.minimum_balance(Mint::LEN);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &pool_mint.pubkey(),
-                mint_rent,
-                Mint::LEN as u64,
-                &id(),
-            ),
-            instruction::initialize_mint(&id(), &pool_mint.pubkey(), manager, None, decimals)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, pool_mint],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn create_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    account: &Keypair,
-    pool_mint: &Pubkey,
-    owner: &Pubkey,
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let account_rent = rent.minimum_balance(Account::LEN);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &account.pubkey(),
-                account_rent,
-                Account::LEN as u64,
-                &id(),
-            ),
-            instruction::initialize_account(&id(), &account.pubkey(), pool_mint, owner).unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn mint_to(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    mint: &Pubkey,
-    account: &Pubkey,
-    mint_authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::mint_to(&id(), mint, account, &mint_authority.pubkey(), &[], amount)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, mint_authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-#[allow(deprecated)]
-pub async fn transfer(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    source: &Pubkey,
-    destination: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::transfer(&id(), source, destination, &authority.pubkey(), &[], amount)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub async fn transfer_checked(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    source: &Pubkey,
-    mint: &Pubkey,
-    destination: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-    decimals: u8,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::transfer_checked(
-            &id(),
-            source,
-            mint,
-            destination,
-            &authority.pubkey(),
-            &[],
-            amount,
-            decimals,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn burn(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    mint: &Pubkey,
-    account: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::burn(&id(), account, mint, &authority.pubkey(), &[], amount).unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
diff --git a/token/program-2022/tests/assert_instruction_count.rs b/token/program-2022/tests/assert_instruction_count.rs
deleted file mode 100644
index a6f03699bac..00000000000
--- a/token/program-2022/tests/assert_instruction_count.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod action;
-use {
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
-    spl_token_2022::{
-        id, instruction,
-        processor::Processor,
-        state::{Account, Mint},
-    },
-};
-
-const TRANSFER_AMOUNT: u64 = 1_000_000_000_000_000;
-
-#[tokio::test]
-async fn initialize_mint() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(5_000); // last known 1378
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner_key = Pubkey::new_unique();
-    let mint = Keypair::new();
-    let decimals = 9;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let mint_rent = rent.minimum_balance(Mint::LEN);
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &mint.pubkey(),
-            mint_rent,
-            Mint::LEN as u64,
-            &id(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &mint],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::initialize_mint(&id(), &mint.pubkey(), &owner_key, None, decimals)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn initialize_account() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1783
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    let rent = banks_client.get_rent().await.unwrap();
-    let account_rent = rent.minimum_balance(Account::LEN);
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &account.pubkey(),
-            account_rent,
-            Account::LEN as u64,
-            &id(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::initialize_account(
-            &id(),
-            &account.pubkey(),
-            &mint.pubkey(),
-            &owner.pubkey(),
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn mint_to() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1115
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::mint_to(
-            &id(),
-            &mint.pubkey(),
-            &account.pubkey(),
-            &owner.pubkey(),
-            &[],
-            TRANSFER_AMOUNT,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer, &owner],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn transfer() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1502
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let source = Keypair::new();
-    let destination = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &destination,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    action::mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &source.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    action::transfer(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source.pubkey(),
-        &destination.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn transfer_checked() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1849
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let source = Keypair::new();
-    let destination = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &destination,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    action::mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &source.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    action::transfer_checked(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source.pubkey(),
-        &mint.pubkey(),
-        &destination.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-        decimals,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn burn() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1226
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    action::mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &account.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    action::burn(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &account.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn close_account() {
-    let mut pt = ProgramTest::new("spl_token_2022", id(), processor!(Processor::process));
-    pt.set_compute_max_units(8_000); // last known 1315
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::close_account(
-            &id(),
-            &account.pubkey(),
-            &owner.pubkey(),
-            &owner.pubkey(),
-            &[],
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer, &owner],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
diff --git a/token/program-2022/tests/serialization.rs b/token/program-2022/tests/serialization.rs
deleted file mode 100644
index 9645daadb83..00000000000
--- a/token/program-2022/tests/serialization.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-#![cfg(feature = "serde-traits")]
-
-use {
-    solana_program::program_option::COption,
-    solana_sdk::pubkey::Pubkey,
-    spl_pod::optional_keys::{OptionalNonZeroElGamalPubkey, OptionalNonZeroPubkey},
-    spl_token_2022::{
-        extension::confidential_transfer,
-        instruction,
-        solana_zk_token_sdk::zk_token_elgamal::pod::{AeCiphertext, ElGamalPubkey},
-    },
-    std::str::FromStr,
-};
-
-#[test]
-fn serde_instruction_coption_pubkey() {
-    let inst = instruction::TokenInstruction::InitializeMint2 {
-        decimals: 0,
-        mint_authority: Pubkey::from_str("4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM").unwrap(),
-        freeze_authority: COption::Some(
-            Pubkey::from_str("8opHzTAnfzRpPEx21XtnrVTX28YQuCpAjcn1PczScKh").unwrap(),
-        ),
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    assert_eq!(&serialized, "{\"initializeMint2\":{\"decimals\":0,\"mintAuthority\":\"4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM\",\"freezeAuthority\":\"8opHzTAnfzRpPEx21XtnrVTX28YQuCpAjcn1PczScKh\"}}");
-
-    serde_json::from_str::<instruction::TokenInstruction>(&serialized).unwrap();
-}
-
-#[test]
-fn serde_instruction_coption_pubkey_with_none() {
-    let inst = instruction::TokenInstruction::InitializeMintCloseAuthority {
-        close_authority: COption::None,
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    assert_eq!(
-        &serialized,
-        "{\"initializeMintCloseAuthority\":{\"closeAuthority\":null}}"
-    );
-
-    serde_json::from_str::<instruction::TokenInstruction>(&serialized).unwrap();
-}
-
-#[test]
-fn serde_instruction_optional_nonzero_pubkeys_podbool() {
-    // tests serde of ix containing OptionalNonZeroPubkey, PodBool and
-    // OptionalNonZeroElGamalPubkey
-    let authority_option: Option<Pubkey> =
-        Some(Pubkey::from_str("4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM").unwrap());
-    let authority: OptionalNonZeroPubkey = authority_option.try_into().unwrap();
-
-    let elgamal_pubkey_pod_option: Option<ElGamalPubkey> = Some(ElGamalPubkey([
-        162, 23, 108, 36, 130, 143, 18, 219, 196, 134, 242, 145, 179, 49, 229, 193, 74, 64, 3, 158,
-        68, 235, 124, 88, 247, 144, 164, 254, 228, 12, 173, 85,
-    ]));
-    let auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey =
-        elgamal_pubkey_pod_option.try_into().unwrap();
-
-    let inst = confidential_transfer::instruction::InitializeMintData {
-        authority,
-        auto_approve_new_accounts: false.into(),
-        auditor_elgamal_pubkey,
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    let serialized_expected = &format!("{{\"authority\":\"4uQeVj5tqViQh7yWWGStvkEG1Zmhx6uasJtWCJziofM\",\"autoApproveNewAccounts\":false,\"auditorElgamalPubkey\":\"ohdsJIKPEtvEhvKRszHlwUpAA55E63xY95Ck/uQMrVU=\"}}");
-    assert_eq!(&serialized, serialized_expected);
-
-    let deserialized =
-        serde_json::from_str::<confidential_transfer::instruction::InitializeMintData>(&serialized)
-            .unwrap();
-    assert_eq!(inst, deserialized);
-}
-
-#[test]
-fn serde_instruction_optional_nonzero_pubkeys_podbool_with_none() {
-    // tests serde of ix containing OptionalNonZeroPubkey, PodBool and
-    // OptionalNonZeroElGamalPubkey with null values
-    let authority: OptionalNonZeroPubkey = None.try_into().unwrap();
-
-    let auditor_elgamal_pubkey: OptionalNonZeroElGamalPubkey =
-        OptionalNonZeroElGamalPubkey::default();
-
-    let inst = confidential_transfer::instruction::InitializeMintData {
-        authority,
-        auto_approve_new_accounts: false.into(),
-        auditor_elgamal_pubkey,
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    let serialized_expected = &format!(
-        "{{\"authority\":null,\"autoApproveNewAccounts\":false,\"auditorElgamalPubkey\":null}}"
-    );
-    assert_eq!(&serialized, serialized_expected);
-
-    let deserialized =
-        serde_json::from_str::<confidential_transfer::instruction::InitializeMintData>(
-            &serialized_expected,
-        )
-        .unwrap();
-    assert_eq!(inst, deserialized);
-}
-
-#[test]
-fn serde_instruction_decryptable_balance_podu64() {
-    let decryptable_zero_balance = AeCiphertext([
-        56, 22, 102, 48, 112, 106, 58, 25, 25, 244, 194, 217, 73, 137, 73, 38, 24, 26, 36, 25, 235,
-        234, 68, 181, 11, 82, 170, 163, 89, 205, 113, 160, 55, 16, 35, 151,
-    ]);
-
-    let inst = confidential_transfer::instruction::ConfigureAccountInstructionData {
-        decryptable_zero_balance,
-        maximum_pending_balance_credit_counter: 1099.into(),
-        proof_instruction_offset: 100,
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    let serialized_expected = &format!("{{\"decryptableZeroBalance\":\"OBZmMHBqOhkZ9MLZSYlJJhgaJBnr6kS1C1Kqo1nNcaA3ECOX\",\"maximumPendingBalanceCreditCounter\":1099,\"proofInstructionOffset\":100}}");
-    assert_eq!(&serialized, serialized_expected);
-
-    let deserialized = serde_json::from_str::<
-        confidential_transfer::instruction::ConfigureAccountInstructionData,
-    >(&serialized_expected)
-    .unwrap();
-    assert_eq!(inst, deserialized);
-}
-
-#[test]
-fn serde_instruction_elgamal_pubkey() {
-    use spl_token_2022::extension::confidential_transfer_fee::instruction::InitializeConfidentialTransferFeeConfigData;
-
-    let withdraw_withheld_authority_elgamal_pubkey = ElGamalPubkey([
-        162, 23, 108, 36, 130, 143, 18, 219, 196, 134, 242, 145, 179, 49, 229, 193, 74, 64, 3, 158,
-        68, 235, 124, 88, 247, 144, 164, 254, 228, 12, 173, 85,
-    ]);
-
-    let inst = InitializeConfidentialTransferFeeConfigData {
-        authority: OptionalNonZeroPubkey::default(),
-        withdraw_withheld_authority_elgamal_pubkey,
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    let serialized_expected = "{\"authority\":null,\"withdrawWithheldAuthorityElgamalPubkey\":\"ohdsJIKPEtvEhvKRszHlwUpAA55E63xY95Ck/uQMrVU=\"}";
-    assert_eq!(&serialized, serialized_expected);
-
-    let deserialized =
-        serde_json::from_str::<InitializeConfidentialTransferFeeConfigData>(&serialized_expected)
-            .unwrap();
-    assert_eq!(inst, deserialized);
-}
-
-#[test]
-fn serde_instruction_basis_points() {
-    use spl_token_2022::extension::interest_bearing_mint::instruction::InitializeInstructionData;
-
-    let inst = InitializeInstructionData {
-        rate_authority: OptionalNonZeroPubkey::default(),
-        rate: 127.into(),
-    };
-
-    let serialized = serde_json::to_string(&inst).unwrap();
-    let serialized_expected = "{\"rateAuthority\":null,\"rate\":127}";
-    assert_eq!(&serialized, serialized_expected);
-
-    serde_json::from_str::<InitializeInstructionData>(&serialized_expected).unwrap();
-}
diff --git a/token/program/Cargo.toml b/token/program/Cargo.toml
deleted file mode 100644
index 1ff5b084308..00000000000
--- a/token/program/Cargo.toml
+++ /dev/null
@@ -1,35 +0,0 @@
-[package]
-name = "spl-token"
-version = "4.0.1"
-description = "Solana Program Library Token"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-exclude = ["js/**"]
-
-[features]
-no-entrypoint = []
-test-sbf = []
-
-[dependencies]
-arrayref = "0.3.7"
-bytemuck = "1.16.0"
-num-derive = "0.4"
-num-traits = "0.2"
-num_enum = "0.7.2"
-solana-program = ">=1.18.11,<=2"
-thiserror = "1.0"
-
-[dev-dependencies]
-lazy_static = "1.4.0"
-proptest = "1.4"
-serial_test = "3.1.1"
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token/program/README.md b/token/program/README.md
deleted file mode 100644
index 02cbb7c6726..00000000000
--- a/token/program/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Token program
-
-A token program on the Solana blockchain, usable for fungible and non-fungible tokens.
-
-This program provides an interface and implementation that third parties can
-utilize to create and use their tokens.
-
-Full documentation is available at https://spl.solana.com/token
-
-## Audit
-
-The repository [README](https://github.com/solana-labs/solana-program-library#audits)
-contains information about program audits.
diff --git a/token/program/Xargo.toml b/token/program/Xargo.toml
deleted file mode 100644
index 1744f098ae1..00000000000
--- a/token/program/Xargo.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[target.bpfel-unknown-unknown.dependencies.std]
-features = []
\ No newline at end of file
diff --git a/token/program/inc/token.h b/token/program/inc/token.h
deleted file mode 100644
index 145c0c5e07b..00000000000
--- a/token/program/inc/token.h
+++ /dev/null
@@ -1,687 +0,0 @@
-/* Autogenerated SPL Token program C Bindings */
-
-#pragma once
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-/**
- * Minimum number of multisignature signers (min N)
- */
-#define Token_MIN_SIGNERS 1
-
-/**
- * Maximum number of multisignature signers (max N)
- */
-#define Token_MAX_SIGNERS 11
-
-/**
- * Account state.
- */
-enum Token_AccountState
-#ifdef __cplusplus
-  : uint8_t
-#endif // __cplusplus
- {
-    /**
-     * Account is not yet initialized
-     */
-    Token_AccountState_Uninitialized,
-    /**
-     * Account is initialized; the account owner and/or delegate may perform permitted operations
-     * on this account
-     */
-    Token_AccountState_Initialized,
-    /**
-     * Account has been frozen by the mint freeze authority. Neither the account owner nor
-     * the delegate are able to perform operations on this account.
-     */
-    Token_AccountState_Frozen,
-};
-#ifndef __cplusplus
-typedef uint8_t Token_AccountState;
-#endif // __cplusplus
-
-/**
- * Specifies the authority type for SetAuthority instructions
- */
-enum Token_AuthorityType
-#ifdef __cplusplus
-  : uint8_t
-#endif // __cplusplus
- {
-    /**
-     * Authority to mint new tokens
-     */
-    Token_AuthorityType_MintTokens,
-    /**
-     * Authority to freeze any account associated with the Mint
-     */
-    Token_AuthorityType_FreezeAccount,
-    /**
-     * Owner of a given token account
-     */
-    Token_AuthorityType_AccountOwner,
-    /**
-     * Authority to close a token account
-     */
-    Token_AuthorityType_CloseAccount,
-};
-#ifndef __cplusplus
-typedef uint8_t Token_AuthorityType;
-#endif // __cplusplus
-
-typedef uint8_t Token_Pubkey[32];
-
-/**
- * A C representation of Rust's `std::option::Option`
- */
-typedef enum Token_COption_Pubkey_Tag {
-    /**
-     * No value
-     */
-    Token_COption_Pubkey_None_Pubkey,
-    /**
-     * Some value `T`
-     */
-    Token_COption_Pubkey_Some_Pubkey,
-} Token_COption_Pubkey_Tag;
-
-typedef struct Token_COption_Pubkey {
-    Token_COption_Pubkey_Tag tag;
-    union {
-        struct {
-            Token_Pubkey some;
-        };
-    };
-} Token_COption_Pubkey;
-
-/**
- * Instructions supported by the token program.
- */
-typedef enum Token_TokenInstruction_Tag {
-    /**
-     * Initializes a new mint and optionally deposits all the newly minted
-     * tokens in an account.
-     *
-     * The `InitializeMint` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]` The mint to initialize.
-     *   1. `[]` Rent sysvar
-     *
-     */
-    Token_TokenInstruction_InitializeMint,
-    /**
-     * Initializes a new account to hold tokens.  If this account is associated
-     * with the native mint then the token balance of the initialized account
-     * will be equal to the amount of SOL in the account. If this account is
-     * associated with another mint, that mint must be initialized before this
-     * command can succeed.
-     *
-     * The `InitializeAccount` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The account to initialize.
-     *   1. `[]` The mint this account will be associated with.
-     *   2. `[]` The new account's owner/multisignature.
-     *   3. `[]` Rent sysvar
-     */
-    Token_TokenInstruction_InitializeAccount,
-    /**
-     * Initializes a multisignature account with N provided signers.
-     *
-     * Multisignature accounts can used in place of any single owner/delegate
-     * accounts in any token instruction that require an owner/delegate to be
-     * present.  The variant field represents the number of signers (M)
-     * required to validate this multisignature account.
-     *
-     * The `InitializeMultisig` instruction requires no signers and MUST be
-     * included within the same Transaction as the system program's
-     * `CreateAccount` instruction that creates the account being initialized.
-     * Otherwise another party can acquire ownership of the uninitialized
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]` The multisignature account to initialize.
-     *   1. `[]` Rent sysvar
-     *   2. ..2+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-     *      11.
-     */
-    Token_TokenInstruction_InitializeMultisig,
-    /**
-     * Transfers tokens from one account to another either directly or via a
-     * delegate.  If this account is associated with the native mint then equal
-     * amounts of SOL and Tokens will be transferred to the destination
-     * account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[writable]` The destination account.
-     *   2. `[signer]` The source account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[writable]` The destination account.
-     *   2. `[]` The source account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_Transfer,
-    /**
-     * Approves a delegate.  A delegate is given the authority over tokens on
-     * behalf of the source account's owner.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The delegate.
-     *   2. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The delegate.
-     *   2. `[]` The source account's multisignature owner.
-     *   3. ..3+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_Approve,
-    /**
-     * Revokes the delegate's authority.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The source account's multisignature owner.
-     *   2. ..2+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_Revoke,
-    /**
-     * Sets a new authority of a mint or account.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint or account to change the authority of.
-     *   1. `[signer]` The current authority of the mint or account.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint or account to change the authority of.
-     *   1. `[]` The mint's or account's current multisignature authority.
-     *   2. ..2+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_SetAuthority,
-    /**
-     * Mints new tokens to an account.  The native mint does not support
-     * minting.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[signer]` The mint's minting authority.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[]` The mint's multisignature mint-tokens authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_MintTo,
-    /**
-     * Burns tokens by removing them from an account.  `Burn` does not support
-     * accounts associated with the native mint, use `CloseAccount` instead.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[signer]` The account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[]` The account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_Burn,
-    /**
-     * Close an account by transferring all its SOL to the destination account.
-     * Non-native accounts may only be closed if its token amount is zero.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to close.
-     *   1. `[writable]` The destination account.
-     *   2. `[signer]` The account's owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to close.
-     *   1. `[writable]` The destination account.
-     *   2. `[]` The account's multisignature owner.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_CloseAccount,
-    /**
-     * Freeze an Initialized account using the Mint's freeze_authority (if
-     * set).
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[signer]` The mint freeze authority.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[]` The mint's multisignature freeze authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_FreezeAccount,
-    /**
-     * Thaw a Frozen account using the Mint's freeze_authority (if set).
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[signer]` The mint freeze authority.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The account to freeze.
-     *   1. `[]` The token mint.
-     *   2. `[]` The mint's multisignature freeze authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_ThawAccount,
-    /**
-     * Transfers tokens from one account to another either directly or via a
-     * delegate.  If this account is associated with the native mint then equal
-     * amounts of SOL and Tokens will be transferred to the destination
-     * account.
-     *
-     * This instruction differs from Transfer in that the token mint and
-     * decimals value is checked by the caller.  This may be useful when
-     * creating transactions offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[writable]` The destination account.
-     *   3. `[signer]` The source account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[writable]` The destination account.
-     *   3. `[]` The source account's multisignature owner/delegate.
-     *   4. ..4+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_TransferChecked,
-    /**
-     * Approves a delegate.  A delegate is given the authority over tokens on
-     * behalf of the source account's owner.
-     *
-     * This instruction differs from Approve in that the token mint and
-     * decimals value is checked by the caller.  This may be useful when
-     * creating transactions offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[]` The delegate.
-     *   3. `[signer]` The source account owner.
-     *
-     *   * Multisignature owner
-     *   0. `[writable]` The source account.
-     *   1. `[]` The token mint.
-     *   2. `[]` The delegate.
-     *   3. `[]` The source account's multisignature owner.
-     *   4. ..4+M `[signer]` M signer accounts
-     */
-    Token_TokenInstruction_ApproveChecked,
-    /**
-     * Mints new tokens to an account.  The native mint does not support
-     * minting.
-     *
-     * This instruction differs from MintTo in that the decimals value is
-     * checked by the caller.  This may be useful when creating transactions
-     * offline or within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[signer]` The mint's minting authority.
-     *
-     *   * Multisignature authority
-     *   0. `[writable]` The mint.
-     *   1. `[writable]` The account to mint tokens to.
-     *   2. `[]` The mint's multisignature mint-tokens authority.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_MintToChecked,
-    /**
-     * Burns tokens by removing them from an account.  `BurnChecked` does not
-     * support accounts associated with the native mint, use `CloseAccount`
-     * instead.
-     *
-     * This instruction differs from Burn in that the decimals value is checked
-     * by the caller. This may be useful when creating transactions offline or
-     * within a hardware wallet.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   * Single owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[signer]` The account's owner/delegate.
-     *
-     *   * Multisignature owner/delegate
-     *   0. `[writable]` The account to burn from.
-     *   1. `[writable]` The token mint.
-     *   2. `[]` The account's multisignature owner/delegate.
-     *   3. ..3+M `[signer]` M signer accounts.
-     */
-    Token_TokenInstruction_BurnChecked,
-    /**
-     * Like InitializeAccount, but the owner pubkey is passed via instruction data
-     * rather than the accounts list. This variant may be preferable when using
-     * Cross Program Invocation from an instruction that does not need the owner's
-     * `AccountInfo` otherwise.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The account to initialize.
-     *   1. `[]` The mint this account will be associated with.
-     *   3. `[]` Rent sysvar
-     */
-    Token_TokenInstruction_InitializeAccount2,
-    /**
-     * Given a wrapped / native token account (a token account containing SOL)
-     * updates its amount field based on the account's underlying `lamports`.
-     * This is useful if a non-wrapped SOL account uses `system_instruction::transfer`
-     * to move lamports to a wrapped token account, and needs to have its token
-     * `amount` field updated.
-     *
-     * Accounts expected by this instruction:
-     *
-     *   0. `[writable]`  The native token account to sync with its underlying lamports.
-     */
-    Token_TokenInstruction_SyncNative,
-} Token_TokenInstruction_Tag;
-
-typedef struct Token_TokenInstruction_Token_InitializeMint_Body {
-    /**
-     * Number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-    /**
-     * The authority/multisignature to mint tokens.
-     */
-    Token_Pubkey mint_authority;
-    /**
-     * The freeze authority/multisignature of the mint.
-     */
-    struct Token_COption_Pubkey freeze_authority;
-} Token_TokenInstruction_Token_InitializeMint_Body;
-
-typedef struct Token_TokenInstruction_Token_InitializeMultisig_Body {
-    /**
-     * The number of signers (M) required to validate this multisignature
-     * account.
-     */
-    uint8_t m;
-} Token_TokenInstruction_Token_InitializeMultisig_Body;
-
-typedef struct Token_TokenInstruction_Token_Transfer_Body {
-    /**
-     * The amount of tokens to transfer.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Transfer_Body;
-
-typedef struct Token_TokenInstruction_Token_Approve_Body {
-    /**
-     * The amount of tokens the delegate is approved for.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Approve_Body;
-
-typedef struct Token_TokenInstruction_Token_SetAuthority_Body {
-    /**
-     * The type of authority to update.
-     */
-    Token_AuthorityType authority_type;
-    /**
-     * The new authority
-     */
-    struct Token_COption_Pubkey new_authority;
-} Token_TokenInstruction_Token_SetAuthority_Body;
-
-typedef struct Token_TokenInstruction_Token_MintTo_Body {
-    /**
-     * The amount of new tokens to mint.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_MintTo_Body;
-
-typedef struct Token_TokenInstruction_Token_Burn_Body {
-    /**
-     * The amount of tokens to burn.
-     */
-    uint64_t amount;
-} Token_TokenInstruction_Token_Burn_Body;
-
-typedef struct Token_TokenInstruction_Token_TransferChecked_Body {
-    /**
-     * The amount of tokens to transfer.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_TransferChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_ApproveChecked_Body {
-    /**
-     * The amount of tokens the delegate is approved for.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_ApproveChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_MintToChecked_Body {
-    /**
-     * The amount of new tokens to mint.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_MintToChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_BurnChecked_Body {
-    /**
-     * The amount of tokens to burn.
-     */
-    uint64_t amount;
-    /**
-     * Expected number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-} Token_TokenInstruction_Token_BurnChecked_Body;
-
-typedef struct Token_TokenInstruction_Token_InitializeAccount2_Body {
-    /**
-     * The new account's owner/multisignature.
-     */
-    Token_Pubkey owner;
-} Token_TokenInstruction_Token_InitializeAccount2_Body;
-
-typedef struct Token_TokenInstruction {
-    Token_TokenInstruction_Tag tag;
-    union {
-        Token_TokenInstruction_Token_InitializeMint_Body initialize_mint;
-        Token_TokenInstruction_Token_InitializeMultisig_Body initialize_multisig;
-        Token_TokenInstruction_Token_Transfer_Body transfer;
-        Token_TokenInstruction_Token_Approve_Body approve;
-        Token_TokenInstruction_Token_SetAuthority_Body set_authority;
-        Token_TokenInstruction_Token_MintTo_Body mint_to;
-        Token_TokenInstruction_Token_Burn_Body burn;
-        Token_TokenInstruction_Token_TransferChecked_Body transfer_checked;
-        Token_TokenInstruction_Token_ApproveChecked_Body approve_checked;
-        Token_TokenInstruction_Token_MintToChecked_Body mint_to_checked;
-        Token_TokenInstruction_Token_BurnChecked_Body burn_checked;
-        Token_TokenInstruction_Token_InitializeAccount2_Body initialize_account2;
-    };
-} Token_TokenInstruction;
-
-/**
- * Mint data.
- */
-typedef struct Token_Mint {
-    /**
-     * Optional authority used to mint new tokens. The mint authority may only be provided during
-     * mint creation. If no mint authority is present then the mint has a fixed supply and no
-     * further tokens may be minted.
-     */
-    struct Token_COption_Pubkey mint_authority;
-    /**
-     * Total supply of tokens.
-     */
-    uint64_t supply;
-    /**
-     * Number of base 10 digits to the right of the decimal place.
-     */
-    uint8_t decimals;
-    /**
-     * Is `true` if this structure has been initialized
-     */
-    bool is_initialized;
-    /**
-     * Optional authority to freeze token accounts.
-     */
-    struct Token_COption_Pubkey freeze_authority;
-} Token_Mint;
-
-/**
- * A C representation of Rust's `std::option::Option`
- */
-typedef enum Token_COption_u64_Tag {
-    /**
-     * No value
-     */
-    Token_COption_u64_None_u64,
-    /**
-     * Some value `T`
-     */
-    Token_COption_u64_Some_u64,
-} Token_COption_u64_Tag;
-
-typedef struct Token_COption_u64 {
-    Token_COption_u64_Tag tag;
-    union {
-        struct {
-            uint64_t some;
-        };
-    };
-} Token_COption_u64;
-
-/**
- * Account data.
- */
-typedef struct Token_Account {
-    /**
-     * The mint associated with this account
-     */
-    Token_Pubkey mint;
-    /**
-     * The owner of this account.
-     */
-    Token_Pubkey owner;
-    /**
-     * The amount of tokens this account holds.
-     */
-    uint64_t amount;
-    /**
-     * If `delegate` is `Some` then `delegated_amount` represents
-     * the amount authorized by the delegate
-     */
-    struct Token_COption_Pubkey delegate;
-    /**
-     * The account's state
-     */
-    Token_AccountState state;
-    /**
-     * If is_some, this is a native token, and the value logs the rent-exempt reserve. An Account
-     * is required to be rent-exempt, so the value is used by the Processor to ensure that wrapped
-     * SOL accounts do not drop below this threshold.
-     */
-    struct Token_COption_u64 is_native;
-    /**
-     * The amount delegated
-     */
-    uint64_t delegated_amount;
-    /**
-     * Optional authority to close the account.
-     */
-    struct Token_COption_Pubkey close_authority;
-} Token_Account;
-
-/**
- * Multisignature data.
- */
-typedef struct Token_Multisig {
-    /**
-     * Number of signers required
-     */
-    uint8_t m;
-    /**
-     * Number of valid signers
-     */
-    uint8_t n;
-    /**
-     * Is `true` if this structure has been initialized
-     */
-    bool is_initialized;
-    /**
-     * Signer public keys
-     */
-    Token_Pubkey signers[Token_MAX_SIGNERS];
-} Token_Multisig;
diff --git a/token/program/program-id.md b/token/program/program-id.md
deleted file mode 100644
index f397edf07a1..00000000000
--- a/token/program/program-id.md
+++ /dev/null
@@ -1 +0,0 @@
-TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
diff --git a/token/program/src/entrypoint.rs b/token/program/src/entrypoint.rs
deleted file mode 100644
index 366ee78d012..00000000000
--- a/token/program/src/entrypoint.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! Program entrypoint
-
-use {
-    crate::{error::TokenError, processor::Processor},
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<TokenError>();
-        return Err(error);
-    }
-    Ok(())
-}
diff --git a/token/program/src/error.rs b/token/program/src/error.rs
deleted file mode 100644
index a758d2c9ba7..00000000000
--- a/token/program/src/error.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-//! Error types
-
-use {
-    num_derive::FromPrimitive,
-    solana_program::{
-        decode_error::DecodeError,
-        msg,
-        program_error::{PrintProgramError, ProgramError},
-    },
-    thiserror::Error,
-};
-
-/// Errors that may be returned by the Token program.
-#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
-pub enum TokenError {
-    // 0
-    /// Lamport balance below rent-exempt threshold.
-    #[error("Lamport balance below rent-exempt threshold")]
-    NotRentExempt,
-    /// Insufficient funds for the operation requested.
-    #[error("Insufficient funds")]
-    InsufficientFunds,
-    /// Invalid Mint.
-    #[error("Invalid Mint")]
-    InvalidMint,
-    /// Account not associated with this Mint.
-    #[error("Account not associated with this Mint")]
-    MintMismatch,
-    /// Owner does not match.
-    #[error("Owner does not match")]
-    OwnerMismatch,
-
-    // 5
-    /// This token's supply is fixed and new tokens cannot be minted.
-    #[error("Fixed supply")]
-    FixedSupply,
-    /// The account cannot be initialized because it is already being used.
-    #[error("Already in use")]
-    AlreadyInUse,
-    /// Invalid number of provided signers.
-    #[error("Invalid number of provided signers")]
-    InvalidNumberOfProvidedSigners,
-    /// Invalid number of required signers.
-    #[error("Invalid number of required signers")]
-    InvalidNumberOfRequiredSigners,
-    /// State is uninitialized.
-    #[error("State is uninitialized")]
-    UninitializedState,
-
-    // 10
-    /// Instruction does not support native tokens
-    #[error("Instruction does not support native tokens")]
-    NativeNotSupported,
-    /// Non-native account can only be closed if its balance is zero
-    #[error("Non-native account can only be closed if its balance is zero")]
-    NonNativeHasBalance,
-    /// Invalid instruction
-    #[error("Invalid instruction")]
-    InvalidInstruction,
-    /// State is invalid for requested operation.
-    #[error("State is invalid for requested operation")]
-    InvalidState,
-    /// Operation overflowed
-    #[error("Operation overflowed")]
-    Overflow,
-
-    // 15
-    /// Account does not support specified authority type.
-    #[error("Account does not support specified authority type")]
-    AuthorityTypeNotSupported,
-    /// This token mint cannot freeze accounts.
-    #[error("This token mint cannot freeze accounts")]
-    MintCannotFreeze,
-    /// Account is frozen; all account operations will fail
-    #[error("Account is frozen")]
-    AccountFrozen,
-    /// Mint decimals mismatch between the client and mint
-    #[error("The provided decimals value different from the Mint decimals")]
-    MintDecimalsMismatch,
-    /// Instruction does not support non-native tokens
-    #[error("Instruction does not support non-native tokens")]
-    NonNativeNotSupported,
-}
-impl From<TokenError> for ProgramError {
-    fn from(e: TokenError) -> Self {
-        ProgramError::Custom(e as u32)
-    }
-}
-impl<T> DecodeError<T> for TokenError {
-    fn type_of() -> &'static str {
-        "TokenError"
-    }
-}
-
-impl PrintProgramError for TokenError {
-    fn print<E>(&self)
-    where
-        E: 'static
-            + std::error::Error
-            + DecodeError<E>
-            + PrintProgramError
-            + num_traits::FromPrimitive,
-    {
-        match self {
-            TokenError::NotRentExempt => msg!("Error: Lamport balance below rent-exempt threshold"),
-            TokenError::InsufficientFunds => msg!("Error: insufficient funds"),
-            TokenError::InvalidMint => msg!("Error: Invalid Mint"),
-            TokenError::MintMismatch => msg!("Error: Account not associated with this Mint"),
-            TokenError::OwnerMismatch => msg!("Error: owner does not match"),
-            TokenError::FixedSupply => msg!("Error: the total supply of this token is fixed"),
-            TokenError::AlreadyInUse => msg!("Error: account or token already in use"),
-            TokenError::InvalidNumberOfProvidedSigners => {
-                msg!("Error: Invalid number of provided signers")
-            }
-            TokenError::InvalidNumberOfRequiredSigners => {
-                msg!("Error: Invalid number of required signers")
-            }
-            TokenError::UninitializedState => msg!("Error: State is uninitialized"),
-            TokenError::NativeNotSupported => {
-                msg!("Error: Instruction does not support native tokens")
-            }
-            TokenError::NonNativeHasBalance => {
-                msg!("Error: Non-native account can only be closed if its balance is zero")
-            }
-            TokenError::InvalidInstruction => msg!("Error: Invalid instruction"),
-            TokenError::InvalidState => msg!("Error: Invalid account state for operation"),
-            TokenError::Overflow => msg!("Error: Operation overflowed"),
-            TokenError::AuthorityTypeNotSupported => {
-                msg!("Error: Account does not support specified authority type")
-            }
-            TokenError::MintCannotFreeze => msg!("Error: This token mint cannot freeze accounts"),
-            TokenError::AccountFrozen => msg!("Error: Account is frozen"),
-            TokenError::MintDecimalsMismatch => {
-                msg!("Error: decimals different from the Mint decimals")
-            }
-            TokenError::NonNativeNotSupported => {
-                msg!("Error: Instruction does not support non-native tokens")
-            }
-        }
-    }
-}
diff --git a/token/program/src/instruction.rs b/token/program/src/instruction.rs
deleted file mode 100644
index ede7308e34a..00000000000
--- a/token/program/src/instruction.rs
+++ /dev/null
@@ -1,1704 +0,0 @@
-//! Instruction types
-
-use {
-    crate::{check_program_account, error::TokenError},
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::Pubkey,
-        sysvar,
-    },
-    std::{convert::TryInto, mem::size_of},
-};
-
-/// Minimum number of multisignature signers (min N)
-pub const MIN_SIGNERS: usize = 1;
-/// Maximum number of multisignature signers (max N)
-pub const MAX_SIGNERS: usize = 11;
-/// Serialized length of a u64, for unpacking
-const U64_BYTES: usize = 8;
-
-/// Instructions supported by the token program.
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq)]
-pub enum TokenInstruction<'a> {
-    /// Initializes a new mint and optionally deposits all the newly minted
-    /// tokens in an account.
-    ///
-    /// The `InitializeMint` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    ///   1. `[]` Rent sysvar
-    InitializeMint {
-        /// Number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-        /// The authority/multisignature to mint tokens.
-        mint_authority: Pubkey,
-        /// The freeze authority/multisignature of the mint.
-        freeze_authority: COption<Pubkey>,
-    },
-    /// Initializes a new account to hold tokens.  If this account is associated
-    /// with the native mint then the token balance of the initialized account
-    /// will be equal to the amount of SOL in the account. If this account is
-    /// associated with another mint, that mint must be initialized before this
-    /// command can succeed.
-    ///
-    /// The `InitializeAccount` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    ///   2. `[]` The new account's owner/multisignature.
-    ///   3. `[]` Rent sysvar
-    InitializeAccount,
-    /// Initializes a multisignature account with N provided signers.
-    ///
-    /// Multisignature accounts can used in place of any single owner/delegate
-    /// accounts in any token instruction that require an owner/delegate to be
-    /// present.  The variant field represents the number of signers (M)
-    /// required to validate this multisignature account.
-    ///
-    /// The `InitializeMultisig` instruction requires no signers and MUST be
-    /// included within the same Transaction as the system program's
-    /// `CreateAccount` instruction that creates the account being initialized.
-    /// Otherwise another party can acquire ownership of the uninitialized
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The multisignature account to initialize.
-    ///   1. `[]` Rent sysvar
-    ///   2. ..2+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-    ///      11.
-    InitializeMultisig {
-        /// The number of signers (M) required to validate this multisignature
-        /// account.
-        m: u8,
-    },
-    /// Transfers tokens from one account to another either directly or via a
-    /// delegate.  If this account is associated with the native mint then equal
-    /// amounts of SOL and Tokens will be transferred to the destination
-    /// account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[signer]` The source account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The source account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    Transfer {
-        /// The amount of tokens to transfer.
-        amount: u64,
-    },
-    /// Approves a delegate.  A delegate is given the authority over tokens on
-    /// behalf of the source account's owner.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The delegate.
-    ///   2. `[signer]` The source account owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The delegate.
-    ///   2. `[]` The source account's multisignature owner.
-    ///   3. ..3+M `[signer]` M signer accounts
-    Approve {
-        /// The amount of tokens the delegate is approved for.
-        amount: u64,
-    },
-    /// Revokes the delegate's authority.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[signer]` The source account owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The source account's multisignature owner.
-    ///   2. ..2+M `[signer]` M signer accounts
-    Revoke,
-    /// Sets a new authority of a mint or account.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint or account to change the authority of.
-    ///   1. `[signer]` The current authority of the mint or account.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint or account to change the authority of.
-    ///   1. `[]` The mint's or account's current multisignature authority.
-    ///   2. ..2+M `[signer]` M signer accounts
-    SetAuthority {
-        /// The type of authority to update.
-        authority_type: AuthorityType,
-        /// The new authority
-        new_authority: COption<Pubkey>,
-    },
-    /// Mints new tokens to an account.  The native mint does not support
-    /// minting.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[signer]` The mint's minting authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[]` The mint's multisignature mint-tokens authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    MintTo {
-        /// The amount of new tokens to mint.
-        amount: u64,
-    },
-    /// Burns tokens by removing them from an account.  `Burn` does not support
-    /// accounts associated with the native mint, use `CloseAccount` instead.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[signer]` The account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[]` The account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    Burn {
-        /// The amount of tokens to burn.
-        amount: u64,
-    },
-    /// Close an account by transferring all its SOL to the destination account.
-    /// Non-native accounts may only be closed if its token amount is zero.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to close.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[signer]` The account's owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to close.
-    ///   1. `[writable]` The destination account.
-    ///   2. `[]` The account's multisignature owner.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    CloseAccount,
-    /// Freeze an Initialized account using the Mint's freeze_authority (if
-    /// set).
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[signer]` The mint freeze authority.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The mint's multisignature freeze authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    FreezeAccount,
-    /// Thaw a Frozen account using the Mint's freeze_authority (if set).
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[signer]` The mint freeze authority.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The account to freeze.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The mint's multisignature freeze authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    ThawAccount,
-
-    /// Transfers tokens from one account to another either directly or via a
-    /// delegate.  If this account is associated with the native mint then equal
-    /// amounts of SOL and Tokens will be transferred to the destination
-    /// account.
-    ///
-    /// This instruction differs from Transfer in that the token mint and
-    /// decimals value is checked by the caller.  This may be useful when
-    /// creating transactions offline or within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[writable]` The destination account.
-    ///   3. `[signer]` The source account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[writable]` The destination account.
-    ///   3. `[]` The source account's multisignature owner/delegate.
-    ///   4. ..4+M `[signer]` M signer accounts.
-    TransferChecked {
-        /// The amount of tokens to transfer.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Approves a delegate.  A delegate is given the authority over tokens on
-    /// behalf of the source account's owner.
-    ///
-    /// This instruction differs from Approve in that the token mint and
-    /// decimals value is checked by the caller.  This may be useful when
-    /// creating transactions offline or within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The delegate.
-    ///   3. `[signer]` The source account owner.
-    ///
-    ///   * Multisignature owner
-    ///   0. `[writable]` The source account.
-    ///   1. `[]` The token mint.
-    ///   2. `[]` The delegate.
-    ///   3. `[]` The source account's multisignature owner.
-    ///   4. ..4+M `[signer]` M signer accounts
-    ApproveChecked {
-        /// The amount of tokens the delegate is approved for.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Mints new tokens to an account.  The native mint does not support
-    /// minting.
-    ///
-    /// This instruction differs from MintTo in that the decimals value is
-    /// checked by the caller.  This may be useful when creating transactions
-    /// offline or within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[signer]` The mint's minting authority.
-    ///
-    ///   * Multisignature authority
-    ///   0. `[writable]` The mint.
-    ///   1. `[writable]` The account to mint tokens to.
-    ///   2. `[]` The mint's multisignature mint-tokens authority.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    MintToChecked {
-        /// The amount of new tokens to mint.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Burns tokens by removing them from an account.  `BurnChecked` does not
-    /// support accounts associated with the native mint, use `CloseAccount`
-    /// instead.
-    ///
-    /// This instruction differs from Burn in that the decimals value is checked
-    /// by the caller. This may be useful when creating transactions offline or
-    /// within a hardware wallet.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   * Single owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[signer]` The account's owner/delegate.
-    ///
-    ///   * Multisignature owner/delegate
-    ///   0. `[writable]` The account to burn from.
-    ///   1. `[writable]` The token mint.
-    ///   2. `[]` The account's multisignature owner/delegate.
-    ///   3. ..3+M `[signer]` M signer accounts.
-    BurnChecked {
-        /// The amount of tokens to burn.
-        amount: u64,
-        /// Expected number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-    },
-    /// Like InitializeAccount, but the owner pubkey is passed via instruction
-    /// data rather than the accounts list. This variant may be preferable
-    /// when using Cross Program Invocation from an instruction that does
-    /// not need the owner's `AccountInfo` otherwise.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    ///   3. `[]` Rent sysvar
-    InitializeAccount2 {
-        /// The new account's owner/multisignature.
-        owner: Pubkey,
-    },
-    /// Given a wrapped / native token account (a token account containing SOL)
-    /// updates its amount field based on the account's underlying `lamports`.
-    /// This is useful if a non-wrapped SOL account uses
-    /// `system_instruction::transfer` to move lamports to a wrapped token
-    /// account, and needs to have its token `amount` field updated.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The native token account to sync with its underlying
-    ///      lamports.
-    SyncNative,
-    /// Like InitializeAccount2, but does not require the Rent sysvar to be
-    /// provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///   1. `[]` The mint this account will be associated with.
-    InitializeAccount3 {
-        /// The new account's owner/multisignature.
-        owner: Pubkey,
-    },
-    /// Like InitializeMultisig, but does not require the Rent sysvar to be
-    /// provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The multisignature account to initialize.
-    ///   1. ..1+N. `[]` The signer accounts, must equal to N where 1 <= N <=
-    ///      11.
-    InitializeMultisig2 {
-        /// The number of signers (M) required to validate this multisignature
-        /// account.
-        m: u8,
-    },
-    /// Like [`InitializeMint`], but does not require the Rent sysvar to be
-    /// provided
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]` The mint to initialize.
-    InitializeMint2 {
-        /// Number of base 10 digits to the right of the decimal place.
-        decimals: u8,
-        /// The authority/multisignature to mint tokens.
-        mint_authority: Pubkey,
-        /// The freeze authority/multisignature of the mint.
-        freeze_authority: COption<Pubkey>,
-    },
-    /// Gets the required size of an account for the given mint as a
-    /// little-endian `u64`.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserializing
-    /// the return data as a little-endian `u64`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    GetAccountDataSize, // typically, there's also data, but this program ignores it
-    /// Initialize the Immutable Owner extension for the given token account
-    ///
-    /// Fails if the account has already been initialized, so must be called
-    /// before `InitializeAccount`.
-    ///
-    /// No-ops in this version of the program, but is included for compatibility
-    /// with the Associated Token Account program.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[writable]`  The account to initialize.
-    ///
-    /// Data expected by this instruction:
-    ///   None
-    InitializeImmutableOwner,
-    /// Convert an Amount of tokens to a UiAmount `string`, using the given
-    /// mint. In this version of the program, the mint can only specify the
-    /// number of decimals.
-    ///
-    /// Fails on an invalid mint.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserialized
-    /// with `String::from_utf8`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    AmountToUiAmount {
-        /// The amount of tokens to reformat.
-        amount: u64,
-    },
-    /// Convert a UiAmount of tokens to a little-endian `u64` raw Amount, using
-    /// the given mint. In this version of the program, the mint can only
-    /// specify the number of decimals.
-    ///
-    /// Return data can be fetched using `sol_get_return_data` and deserializing
-    /// the return data as a little-endian `u64`.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` The mint to calculate for
-    UiAmountToAmount {
-        /// The ui_amount of tokens to reformat.
-        ui_amount: &'a str,
-    },
-    // Any new variants also need to be added to program-2022 `TokenInstruction`, so that the
-    // latter remains a superset of this instruction set. New variants also need to be added to
-    // token/js/src/instructions/types.ts to maintain @solana/spl-token compatibility
-}
-impl<'a> TokenInstruction<'a> {
-    /// Unpacks a byte buffer into a
-    /// [TokenInstruction](enum.TokenInstruction.html).
-    pub fn unpack(input: &'a [u8]) -> Result<Self, ProgramError> {
-        use TokenError::InvalidInstruction;
-
-        let (&tag, rest) = input.split_first().ok_or(InvalidInstruction)?;
-        Ok(match tag {
-            0 => {
-                let (&decimals, rest) = rest.split_first().ok_or(InvalidInstruction)?;
-                let (mint_authority, rest) = Self::unpack_pubkey(rest)?;
-                let (freeze_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-                Self::InitializeMint {
-                    mint_authority,
-                    freeze_authority,
-                    decimals,
-                }
-            }
-            1 => Self::InitializeAccount,
-            2 => {
-                let &m = rest.first().ok_or(InvalidInstruction)?;
-                Self::InitializeMultisig { m }
-            }
-            3 | 4 | 7 | 8 => {
-                let amount = rest
-                    .get(..8)
-                    .and_then(|slice| slice.try_into().ok())
-                    .map(u64::from_le_bytes)
-                    .ok_or(InvalidInstruction)?;
-                match tag {
-                    3 => Self::Transfer { amount },
-                    4 => Self::Approve { amount },
-                    7 => Self::MintTo { amount },
-                    8 => Self::Burn { amount },
-                    _ => unreachable!(),
-                }
-            }
-            5 => Self::Revoke,
-            6 => {
-                let (authority_type, rest) = rest
-                    .split_first()
-                    .ok_or_else(|| ProgramError::from(InvalidInstruction))
-                    .and_then(|(&t, rest)| Ok((AuthorityType::from(t)?, rest)))?;
-                let (new_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-
-                Self::SetAuthority {
-                    authority_type,
-                    new_authority,
-                }
-            }
-            9 => Self::CloseAccount,
-            10 => Self::FreezeAccount,
-            11 => Self::ThawAccount,
-            12 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::TransferChecked { amount, decimals }
-            }
-            13 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::ApproveChecked { amount, decimals }
-            }
-            14 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::MintToChecked { amount, decimals }
-            }
-            15 => {
-                let (amount, decimals, _rest) = Self::unpack_amount_decimals(rest)?;
-                Self::BurnChecked { amount, decimals }
-            }
-            16 => {
-                let (owner, _rest) = Self::unpack_pubkey(rest)?;
-                Self::InitializeAccount2 { owner }
-            }
-            17 => Self::SyncNative,
-            18 => {
-                let (owner, _rest) = Self::unpack_pubkey(rest)?;
-                Self::InitializeAccount3 { owner }
-            }
-            19 => {
-                let &m = rest.first().ok_or(InvalidInstruction)?;
-                Self::InitializeMultisig2 { m }
-            }
-            20 => {
-                let (&decimals, rest) = rest.split_first().ok_or(InvalidInstruction)?;
-                let (mint_authority, rest) = Self::unpack_pubkey(rest)?;
-                let (freeze_authority, _rest) = Self::unpack_pubkey_option(rest)?;
-                Self::InitializeMint2 {
-                    mint_authority,
-                    freeze_authority,
-                    decimals,
-                }
-            }
-            21 => Self::GetAccountDataSize,
-            22 => Self::InitializeImmutableOwner,
-            23 => {
-                let (amount, _rest) = Self::unpack_u64(rest)?;
-                Self::AmountToUiAmount { amount }
-            }
-            24 => {
-                let ui_amount = std::str::from_utf8(rest).map_err(|_| InvalidInstruction)?;
-                Self::UiAmountToAmount { ui_amount }
-            }
-            _ => return Err(TokenError::InvalidInstruction.into()),
-        })
-    }
-
-    /// Packs a [TokenInstruction](enum.TokenInstruction.html) into a byte
-    /// buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = Vec::with_capacity(size_of::<Self>());
-        match self {
-            &Self::InitializeMint {
-                ref mint_authority,
-                ref freeze_authority,
-                decimals,
-            } => {
-                buf.push(0);
-                buf.push(decimals);
-                buf.extend_from_slice(mint_authority.as_ref());
-                Self::pack_pubkey_option(freeze_authority, &mut buf);
-            }
-            Self::InitializeAccount => buf.push(1),
-            &Self::InitializeMultisig { m } => {
-                buf.push(2);
-                buf.push(m);
-            }
-            &Self::Transfer { amount } => {
-                buf.push(3);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::Approve { amount } => {
-                buf.push(4);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::MintTo { amount } => {
-                buf.push(7);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            &Self::Burn { amount } => {
-                buf.push(8);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            Self::Revoke => buf.push(5),
-            Self::SetAuthority {
-                authority_type,
-                ref new_authority,
-            } => {
-                buf.push(6);
-                buf.push(authority_type.into());
-                Self::pack_pubkey_option(new_authority, &mut buf);
-            }
-            Self::CloseAccount => buf.push(9),
-            Self::FreezeAccount => buf.push(10),
-            Self::ThawAccount => buf.push(11),
-            &Self::TransferChecked { amount, decimals } => {
-                buf.push(12);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::ApproveChecked { amount, decimals } => {
-                buf.push(13);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::MintToChecked { amount, decimals } => {
-                buf.push(14);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::BurnChecked { amount, decimals } => {
-                buf.push(15);
-                buf.extend_from_slice(&amount.to_le_bytes());
-                buf.push(decimals);
-            }
-            &Self::InitializeAccount2 { owner } => {
-                buf.push(16);
-                buf.extend_from_slice(owner.as_ref());
-            }
-            &Self::SyncNative => {
-                buf.push(17);
-            }
-            &Self::InitializeAccount3 { owner } => {
-                buf.push(18);
-                buf.extend_from_slice(owner.as_ref());
-            }
-            &Self::InitializeMultisig2 { m } => {
-                buf.push(19);
-                buf.push(m);
-            }
-            &Self::InitializeMint2 {
-                ref mint_authority,
-                ref freeze_authority,
-                decimals,
-            } => {
-                buf.push(20);
-                buf.push(decimals);
-                buf.extend_from_slice(mint_authority.as_ref());
-                Self::pack_pubkey_option(freeze_authority, &mut buf);
-            }
-            &Self::GetAccountDataSize => {
-                buf.push(21);
-            }
-            &Self::InitializeImmutableOwner => {
-                buf.push(22);
-            }
-            &Self::AmountToUiAmount { amount } => {
-                buf.push(23);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            Self::UiAmountToAmount { ui_amount } => {
-                buf.push(24);
-                buf.extend_from_slice(ui_amount.as_bytes());
-            }
-        };
-        buf
-    }
-
-    fn unpack_pubkey(input: &[u8]) -> Result<(Pubkey, &[u8]), ProgramError> {
-        if input.len() >= 32 {
-            let (key, rest) = input.split_at(32);
-            let pk = Pubkey::try_from(key).map_err(|_| TokenError::InvalidInstruction)?;
-            Ok((pk, rest))
-        } else {
-            Err(TokenError::InvalidInstruction.into())
-        }
-    }
-
-    fn unpack_pubkey_option(input: &[u8]) -> Result<(COption<Pubkey>, &[u8]), ProgramError> {
-        match input.split_first() {
-            Option::Some((&0, rest)) => Ok((COption::None, rest)),
-            Option::Some((&1, rest)) if rest.len() >= 32 => {
-                let (key, rest) = rest.split_at(32);
-                let pk = Pubkey::try_from(key).map_err(|_| TokenError::InvalidInstruction)?;
-                Ok((COption::Some(pk), rest))
-            }
-            _ => Err(TokenError::InvalidInstruction.into()),
-        }
-    }
-
-    fn pack_pubkey_option(value: &COption<Pubkey>, buf: &mut Vec<u8>) {
-        match *value {
-            COption::Some(ref key) => {
-                buf.push(1);
-                buf.extend_from_slice(&key.to_bytes());
-            }
-            COption::None => buf.push(0),
-        }
-    }
-
-    fn unpack_u64(input: &[u8]) -> Result<(u64, &[u8]), ProgramError> {
-        let value = input
-            .get(..U64_BYTES)
-            .and_then(|slice| slice.try_into().ok())
-            .map(u64::from_le_bytes)
-            .ok_or(TokenError::InvalidInstruction)?;
-        Ok((value, &input[U64_BYTES..]))
-    }
-
-    fn unpack_amount_decimals(input: &[u8]) -> Result<(u64, u8, &[u8]), ProgramError> {
-        let (amount, rest) = Self::unpack_u64(input)?;
-        let (&decimals, rest) = rest.split_first().ok_or(TokenError::InvalidInstruction)?;
-        Ok((amount, decimals, rest))
-    }
-}
-
-/// Specifies the authority type for SetAuthority instructions
-#[repr(u8)]
-#[derive(Clone, Debug, PartialEq)]
-pub enum AuthorityType {
-    /// Authority to mint new tokens
-    MintTokens,
-    /// Authority to freeze any account associated with the Mint
-    FreezeAccount,
-    /// Owner of a given token account
-    AccountOwner,
-    /// Authority to close a token account
-    CloseAccount,
-}
-
-impl AuthorityType {
-    fn into(&self) -> u8 {
-        match self {
-            AuthorityType::MintTokens => 0,
-            AuthorityType::FreezeAccount => 1,
-            AuthorityType::AccountOwner => 2,
-            AuthorityType::CloseAccount => 3,
-        }
-    }
-
-    fn from(index: u8) -> Result<Self, ProgramError> {
-        match index {
-            0 => Ok(AuthorityType::MintTokens),
-            1 => Ok(AuthorityType::FreezeAccount),
-            2 => Ok(AuthorityType::AccountOwner),
-            3 => Ok(AuthorityType::CloseAccount),
-            _ => Err(TokenError::InvalidInstruction.into()),
-        }
-    }
-}
-
-/// Creates a `InitializeMint` instruction.
-pub fn initialize_mint(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    mint_authority_pubkey: &Pubkey,
-    freeze_authority_pubkey: Option<&Pubkey>,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let freeze_authority = freeze_authority_pubkey.cloned().into();
-    let data = TokenInstruction::InitializeMint {
-        mint_authority: *mint_authority_pubkey,
-        freeze_authority,
-        decimals,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*mint_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMint2` instruction.
-pub fn initialize_mint2(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    mint_authority_pubkey: &Pubkey,
-    freeze_authority_pubkey: Option<&Pubkey>,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let freeze_authority = freeze_authority_pubkey.cloned().into();
-    let data = TokenInstruction::InitializeMint2 {
-        mint_authority: *mint_authority_pubkey,
-        freeze_authority,
-        decimals,
-    }
-    .pack();
-
-    let accounts = vec![AccountMeta::new(*mint_pubkey, false)];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount` instruction.
-pub fn initialize_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount.pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(*owner_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount2` instruction.
-pub fn initialize_account2(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount2 {
-        owner: *owner_pubkey,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(sysvar::rent::id(), false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeAccount3` instruction.
-pub fn initialize_account3(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::InitializeAccount3 {
-        owner: *owner_pubkey,
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*account_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-    ];
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMultisig` instruction.
-pub fn initialize_multisig(
-    token_program_id: &Pubkey,
-    multisig_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    m: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    if !is_valid_signer_index(m as usize)
-        || !is_valid_signer_index(signer_pubkeys.len())
-        || m as usize > signer_pubkeys.len()
-    {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let data = TokenInstruction::InitializeMultisig { m }.pack();
-
-    let mut accounts = Vec::with_capacity(1 + 1 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*multisig_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(sysvar::rent::id(), false));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, false));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `InitializeMultisig2` instruction.
-pub fn initialize_multisig2(
-    token_program_id: &Pubkey,
-    multisig_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    m: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    if !is_valid_signer_index(m as usize)
-        || !is_valid_signer_index(signer_pubkeys.len())
-        || m as usize > signer_pubkeys.len()
-    {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let data = TokenInstruction::InitializeMultisig2 { m }.pack();
-
-    let mut accounts = Vec::with_capacity(1 + 1 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*multisig_pubkey, false));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, false));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Transfer` instruction.
-pub fn transfer(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::Transfer { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates an `Approve` instruction.
-pub fn approve(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    delegate_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::Approve { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*delegate_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Revoke` instruction.
-pub fn revoke(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::Revoke.pack();
-
-    let mut accounts = Vec::with_capacity(2 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `SetAuthority` instruction.
-pub fn set_authority(
-    token_program_id: &Pubkey,
-    owned_pubkey: &Pubkey,
-    new_authority_pubkey: Option<&Pubkey>,
-    authority_type: AuthorityType,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let new_authority = new_authority_pubkey.cloned().into();
-    let data = TokenInstruction::SetAuthority {
-        authority_type,
-        new_authority,
-    }
-    .pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*owned_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `MintTo` instruction.
-pub fn mint_to(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    account_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::MintTo { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `Burn` instruction.
-pub fn burn(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::Burn { amount }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `CloseAccount` instruction.
-pub fn close_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::CloseAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `FreezeAccount` instruction.
-pub fn freeze_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::FreezeAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `ThawAccount` instruction.
-pub fn thaw_account(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::ThawAccount.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `TransferChecked` instruction.
-#[allow(clippy::too_many_arguments)]
-pub fn transfer_checked(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::TransferChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(4 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*destination_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates an `ApproveChecked` instruction.
-#[allow(clippy::too_many_arguments)]
-pub fn approve_checked(
-    token_program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    delegate_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::ApproveChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(4 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*source_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(*delegate_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `MintToChecked` instruction.
-pub fn mint_to_checked(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    account_pubkey: &Pubkey,
-    owner_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::MintToChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *owner_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `BurnChecked` instruction.
-pub fn burn_checked(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    signer_pubkeys: &[&Pubkey],
-    amount: u64,
-    decimals: u8,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    let data = TokenInstruction::BurnChecked { amount, decimals }.pack();
-
-    let mut accounts = Vec::with_capacity(3 + signer_pubkeys.len());
-    accounts.push(AccountMeta::new(*account_pubkey, false));
-    accounts.push(AccountMeta::new(*mint_pubkey, false));
-    accounts.push(AccountMeta::new_readonly(
-        *authority_pubkey,
-        signer_pubkeys.is_empty(),
-    ));
-    for signer_pubkey in signer_pubkeys.iter() {
-        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
-    }
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts,
-        data,
-    })
-}
-
-/// Creates a `SyncNative` instruction
-pub fn sync_native(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*account_pubkey, false)],
-        data: TokenInstruction::SyncNative.pack(),
-    })
-}
-
-/// Creates a `GetAccountDataSize` instruction
-pub fn get_account_data_size(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::GetAccountDataSize.pack(),
-    })
-}
-
-/// Creates a `InitializeImmutableOwner` instruction
-pub fn initialize_immutable_owner(
-    token_program_id: &Pubkey,
-    account_pubkey: &Pubkey,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new(*account_pubkey, false)],
-        data: TokenInstruction::InitializeImmutableOwner.pack(),
-    })
-}
-
-/// Creates an `AmountToUiAmount` instruction
-pub fn amount_to_ui_amount(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    amount: u64,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::AmountToUiAmount { amount }.pack(),
-    })
-}
-
-/// Creates a `UiAmountToAmount` instruction
-pub fn ui_amount_to_amount(
-    token_program_id: &Pubkey,
-    mint_pubkey: &Pubkey,
-    ui_amount: &str,
-) -> Result<Instruction, ProgramError> {
-    check_program_account(token_program_id)?;
-
-    Ok(Instruction {
-        program_id: *token_program_id,
-        accounts: vec![AccountMeta::new_readonly(*mint_pubkey, false)],
-        data: TokenInstruction::UiAmountToAmount { ui_amount }.pack(),
-    })
-}
-
-/// Utility function that checks index is between MIN_SIGNERS and MAX_SIGNERS
-pub fn is_valid_signer_index(index: usize) -> bool {
-    (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, proptest::prelude::*};
-
-    #[test]
-    fn test_instruction_packing() {
-        let check = TokenInstruction::InitializeMint {
-            decimals: 2,
-            mint_authority: Pubkey::new_from_array([1u8; 32]),
-            freeze_authority: COption::None,
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([0u8, 2]);
-        expect.extend_from_slice(&[1u8; 32]);
-        expect.extend_from_slice(&[0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeMint {
-            decimals: 2,
-            mint_authority: Pubkey::new_from_array([2u8; 32]),
-            freeze_authority: COption::Some(Pubkey::new_from_array([3u8; 32])),
-        };
-        let packed = check.pack();
-        let mut expect = vec![0u8, 2];
-        expect.extend_from_slice(&[2u8; 32]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[3u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeAccount;
-        let packed = check.pack();
-        let expect = Vec::from([1u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeMultisig { m: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([2u8, 1]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::Transfer { amount: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([3u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::Approve { amount: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([4u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::Revoke;
-        let packed = check.pack();
-        let expect = Vec::from([5u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::SetAuthority {
-            authority_type: AuthorityType::FreezeAccount,
-            new_authority: COption::Some(Pubkey::new_from_array([4u8; 32])),
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([6u8, 1]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[4u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::MintTo { amount: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([7u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::Burn { amount: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([8u8, 1, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::CloseAccount;
-        let packed = check.pack();
-        let expect = Vec::from([9u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::FreezeAccount;
-        let packed = check.pack();
-        let expect = Vec::from([10u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::ThawAccount;
-        let packed = check.pack();
-        let expect = Vec::from([11u8]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::TransferChecked {
-            amount: 1,
-            decimals: 2,
-        };
-        let packed = check.pack();
-        let expect = Vec::from([12u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::ApproveChecked {
-            amount: 1,
-            decimals: 2,
-        };
-        let packed = check.pack();
-        let expect = Vec::from([13u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::MintToChecked {
-            amount: 1,
-            decimals: 2,
-        };
-        let packed = check.pack();
-        let expect = Vec::from([14u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::BurnChecked {
-            amount: 1,
-            decimals: 2,
-        };
-        let packed = check.pack();
-        let expect = Vec::from([15u8, 1, 0, 0, 0, 0, 0, 0, 0, 2]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeAccount2 {
-            owner: Pubkey::new_from_array([2u8; 32]),
-        };
-        let packed = check.pack();
-        let mut expect = vec![16u8];
-        expect.extend_from_slice(&[2u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::SyncNative;
-        let packed = check.pack();
-        let expect = vec![17u8];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeAccount3 {
-            owner: Pubkey::new_from_array([2u8; 32]),
-        };
-        let packed = check.pack();
-        let mut expect = vec![18u8];
-        expect.extend_from_slice(&[2u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeMultisig2 { m: 1 };
-        let packed = check.pack();
-        let expect = Vec::from([19u8, 1]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeMint2 {
-            decimals: 2,
-            mint_authority: Pubkey::new_from_array([1u8; 32]),
-            freeze_authority: COption::None,
-        };
-        let packed = check.pack();
-        let mut expect = Vec::from([20u8, 2]);
-        expect.extend_from_slice(&[1u8; 32]);
-        expect.extend_from_slice(&[0]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeMint2 {
-            decimals: 2,
-            mint_authority: Pubkey::new_from_array([2u8; 32]),
-            freeze_authority: COption::Some(Pubkey::new_from_array([3u8; 32])),
-        };
-        let packed = check.pack();
-        let mut expect = vec![20u8, 2];
-        expect.extend_from_slice(&[2u8; 32]);
-        expect.extend_from_slice(&[1]);
-        expect.extend_from_slice(&[3u8; 32]);
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::GetAccountDataSize;
-        let packed = check.pack();
-        let expect = vec![21u8];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::InitializeImmutableOwner;
-        let packed = check.pack();
-        let expect = vec![22u8];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::AmountToUiAmount { amount: 42 };
-        let packed = check.pack();
-        let expect = vec![23u8, 42, 0, 0, 0, 0, 0, 0, 0];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-
-        let check = TokenInstruction::UiAmountToAmount { ui_amount: "0.42" };
-        let packed = check.pack();
-        let expect = vec![24u8, 48, 46, 52, 50];
-        assert_eq!(packed, expect);
-        let unpacked = TokenInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-    }
-
-    #[test]
-    fn test_instruction_unpack_panic() {
-        for i in 0..255u8 {
-            for j in 1..10 {
-                let mut data = vec![0; j];
-                data[0] = i;
-                let _no_panic = TokenInstruction::unpack(&data);
-            }
-        }
-    }
-
-    proptest! {
-        #![proptest_config(ProptestConfig::with_cases(1024))]
-        #[test]
-        fn test_instruction_unpack_proptest(
-            data in prop::collection::vec(any::<u8>(), 0..255)
-        ) {
-            let _no_panic = TokenInstruction::unpack(&data);
-        }
-    }
-}
diff --git a/token/program/src/lib.rs b/token/program/src/lib.rs
deleted file mode 100644
index 25175df702f..00000000000
--- a/token/program/src/lib.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-//! An ERC20-like Token program for the Solana blockchain
-
-pub mod error;
-pub mod instruction;
-pub mod native_mint;
-pub mod processor;
-pub mod state;
-
-#[cfg(not(feature = "no-entrypoint"))]
-mod entrypoint;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-use solana_program::{entrypoint::ProgramResult, program_error::ProgramError, pubkey::Pubkey};
-
-/// Convert the UI representation of a token amount (using the decimals field
-/// defined in its mint) to the raw amount
-pub fn ui_amount_to_amount(ui_amount: f64, decimals: u8) -> u64 {
-    (ui_amount * 10_usize.pow(decimals as u32) as f64) as u64
-}
-
-/// Convert a raw amount to its UI representation (using the decimals field
-/// defined in its mint)
-pub fn amount_to_ui_amount(amount: u64, decimals: u8) -> f64 {
-    amount as f64 / 10_usize.pow(decimals as u32) as f64
-}
-
-/// Convert a raw amount to its UI representation (using the decimals field
-/// defined in its mint)
-pub fn amount_to_ui_amount_string(amount: u64, decimals: u8) -> String {
-    let decimals = decimals as usize;
-    if decimals > 0 {
-        // Left-pad zeros to decimals + 1, so we at least have an integer zero
-        let mut s = format!("{:01$}", amount, decimals + 1);
-        // Add the decimal point (Sorry, "," locales!)
-        s.insert(s.len() - decimals, '.');
-        s
-    } else {
-        amount.to_string()
-    }
-}
-
-/// Convert a raw amount to its UI representation using the given decimals field
-/// Excess zeroes or unneeded decimal point are trimmed.
-pub fn amount_to_ui_amount_string_trimmed(amount: u64, decimals: u8) -> String {
-    let mut s = amount_to_ui_amount_string(amount, decimals);
-    if decimals > 0 {
-        let zeros_trimmed = s.trim_end_matches('0');
-        s = zeros_trimmed.trim_end_matches('.').to_string();
-    }
-    s
-}
-
-/// Try to convert a UI representation of a token amount to its raw amount using
-/// the given decimals field
-pub fn try_ui_amount_into_amount(ui_amount: String, decimals: u8) -> Result<u64, ProgramError> {
-    let decimals = decimals as usize;
-    let mut parts = ui_amount.split('.');
-    // splitting a string, even an empty one, will always yield an iterator of
-    // at least length == 1
-    let mut amount_str = parts.next().unwrap().to_string();
-    let after_decimal = parts.next().unwrap_or("");
-    let after_decimal = after_decimal.trim_end_matches('0');
-    if (amount_str.is_empty() && after_decimal.is_empty())
-        || parts.next().is_some()
-        || after_decimal.len() > decimals
-    {
-        return Err(ProgramError::InvalidArgument);
-    }
-
-    amount_str.push_str(after_decimal);
-    for _ in 0..decimals.saturating_sub(after_decimal.len()) {
-        amount_str.push('0');
-    }
-    amount_str
-        .parse::<u64>()
-        .map_err(|_| ProgramError::InvalidArgument)
-}
-
-solana_program::declare_id!("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-
-/// Checks that the supplied program ID is the correct one for SPL-token
-pub fn check_program_account(spl_token_program_id: &Pubkey) -> ProgramResult {
-    if spl_token_program_id != &id() {
-        return Err(ProgramError::IncorrectProgramId);
-    }
-    Ok(())
-}
diff --git a/token/program/src/native_mint.rs b/token/program/src/native_mint.rs
deleted file mode 100644
index 37f75555547..00000000000
--- a/token/program/src/native_mint.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! The Mint that represents the native token
-
-/// There are 10^9 lamports in one SOL
-pub const DECIMALS: u8 = 9;
-
-// The Mint for native SOL Token accounts
-solana_program::declare_id!("So11111111111111111111111111111111111111112");
-
-#[cfg(test)]
-mod tests {
-    use {super::*, solana_program::native_token::*};
-
-    #[test]
-    fn test_decimals() {
-        assert!(
-            (lamports_to_sol(42) - crate::amount_to_ui_amount(42, DECIMALS)).abs() < f64::EPSILON
-        );
-        assert_eq!(
-            sol_to_lamports(42.),
-            crate::ui_amount_to_amount(42., DECIMALS)
-        );
-    }
-}
diff --git a/token/program/src/processor.rs b/token/program/src/processor.rs
deleted file mode 100644
index 550df44320e..00000000000
--- a/token/program/src/processor.rs
+++ /dev/null
@@ -1,7022 +0,0 @@
-//! Program state processor
-
-use {
-    crate::{
-        amount_to_ui_amount_string_trimmed,
-        error::TokenError,
-        instruction::{is_valid_signer_index, AuthorityType, TokenInstruction, MAX_SIGNERS},
-        state::{Account, AccountState, Mint, Multisig},
-        try_ui_amount_into_amount,
-    },
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program::set_return_data,
-        program_error::ProgramError,
-        program_memory::sol_memcmp,
-        program_option::COption,
-        program_pack::{IsInitialized, Pack},
-        pubkey::{Pubkey, PUBKEY_BYTES},
-        system_program,
-        sysvar::{rent::Rent, Sysvar},
-    },
-};
-
-/// Program state handler.
-pub struct Processor {}
-impl Processor {
-    fn _process_initialize_mint(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: Pubkey,
-        freeze_authority: COption<Pubkey>,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        let mint_data_len = mint_info.data_len();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow())?;
-        if mint.is_initialized {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-
-        if !rent.is_exempt(mint_info.lamports(), mint_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        mint.mint_authority = COption::Some(mint_authority);
-        mint.decimals = decimals;
-        mint.is_initialized = true;
-        mint.freeze_authority = freeze_authority;
-
-        Mint::pack(mint, &mut mint_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeMint](enum.TokenInstruction.html) instruction.
-    pub fn process_initialize_mint(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: Pubkey,
-        freeze_authority: COption<Pubkey>,
-    ) -> ProgramResult {
-        Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, true)
-    }
-
-    /// Processes an [InitializeMint2](enum.TokenInstruction.html) instruction.
-    pub fn process_initialize_mint2(
-        accounts: &[AccountInfo],
-        decimals: u8,
-        mint_authority: Pubkey,
-        freeze_authority: COption<Pubkey>,
-    ) -> ProgramResult {
-        Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, false)
-    }
-
-    fn _process_initialize_account(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        owner: Option<&Pubkey>,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let new_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let owner = if let Some(owner) = owner {
-            owner
-        } else {
-            next_account_info(account_info_iter)?.key
-        };
-        let new_account_info_data_len = new_account_info.data_len();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        let mut account = Account::unpack_unchecked(&new_account_info.data.borrow())?;
-        if account.is_initialized() {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-
-        if !rent.is_exempt(new_account_info.lamports(), new_account_info_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        let is_native_mint = Self::cmp_pubkeys(mint_info.key, &crate::native_mint::id());
-        if !is_native_mint {
-            Self::check_account_owner(program_id, mint_info)?;
-            let _ = Mint::unpack(&mint_info.data.borrow_mut())
-                .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        }
-
-        account.mint = *mint_info.key;
-        account.owner = *owner;
-        account.close_authority = COption::None;
-        account.delegate = COption::None;
-        account.delegated_amount = 0;
-        account.state = AccountState::Initialized;
-        if is_native_mint {
-            let rent_exempt_reserve = rent.minimum_balance(new_account_info_data_len);
-            account.is_native = COption::Some(rent_exempt_reserve);
-            account.amount = new_account_info
-                .lamports()
-                .checked_sub(rent_exempt_reserve)
-                .ok_or(TokenError::Overflow)?;
-        } else {
-            account.is_native = COption::None;
-            account.amount = 0;
-        };
-
-        Account::pack(account, &mut new_account_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes an [InitializeAccount](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        Self::_process_initialize_account(program_id, accounts, None, true)
-    }
-
-    /// Processes an [InitializeAccount2](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account2(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        owner: Pubkey,
-    ) -> ProgramResult {
-        Self::_process_initialize_account(program_id, accounts, Some(&owner), true)
-    }
-
-    /// Processes an [InitializeAccount3](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_account3(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        owner: Pubkey,
-    ) -> ProgramResult {
-        Self::_process_initialize_account(program_id, accounts, Some(&owner), false)
-    }
-
-    fn _process_initialize_multisig(
-        accounts: &[AccountInfo],
-        m: u8,
-        rent_sysvar_account: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let multisig_info = next_account_info(account_info_iter)?;
-        let multisig_info_data_len = multisig_info.data_len();
-        let rent = if rent_sysvar_account {
-            Rent::from_account_info(next_account_info(account_info_iter)?)?
-        } else {
-            Rent::get()?
-        };
-
-        let mut multisig = Multisig::unpack_unchecked(&multisig_info.data.borrow())?;
-        if multisig.is_initialized {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-
-        if !rent.is_exempt(multisig_info.lamports(), multisig_info_data_len) {
-            return Err(TokenError::NotRentExempt.into());
-        }
-
-        let signer_infos = account_info_iter.as_slice();
-        multisig.m = m;
-        multisig.n = signer_infos.len() as u8;
-        if !is_valid_signer_index(multisig.n as usize) {
-            return Err(TokenError::InvalidNumberOfProvidedSigners.into());
-        }
-        if !is_valid_signer_index(multisig.m as usize) {
-            return Err(TokenError::InvalidNumberOfRequiredSigners.into());
-        }
-        for (i, signer_info) in signer_infos.iter().enumerate() {
-            multisig.signers[i] = *signer_info.key;
-        }
-        multisig.is_initialized = true;
-
-        Multisig::pack(multisig, &mut multisig_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes a [InitializeMultisig](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_multisig(accounts: &[AccountInfo], m: u8) -> ProgramResult {
-        Self::_process_initialize_multisig(accounts, m, true)
-    }
-
-    /// Processes a [InitializeMultisig2](enum.TokenInstruction.html)
-    /// instruction.
-    pub fn process_initialize_multisig2(accounts: &[AccountInfo], m: u8) -> ProgramResult {
-        Self::_process_initialize_multisig(accounts, m, false)
-    }
-
-    /// Processes a [Transfer](enum.TokenInstruction.html) instruction.
-    pub fn process_transfer(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-
-        let expected_mint_info = if let Some(expected_decimals) = expected_decimals {
-            Some((next_account_info(account_info_iter)?, expected_decimals))
-        } else {
-            None
-        };
-
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        let mut source_account = Account::unpack(&source_account_info.data.borrow())?;
-        let mut destination_account = Account::unpack(&destination_account_info.data.borrow())?;
-
-        if source_account.is_frozen() || destination_account.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-        if source_account.amount < amount {
-            return Err(TokenError::InsufficientFunds.into());
-        }
-        if !Self::cmp_pubkeys(&source_account.mint, &destination_account.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        if let Some((mint_info, expected_decimals)) = expected_mint_info {
-            if !Self::cmp_pubkeys(mint_info.key, &source_account.mint) {
-                return Err(TokenError::MintMismatch.into());
-            }
-
-            let mint = Mint::unpack(&mint_info.data.borrow_mut())?;
-            if expected_decimals != mint.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        let self_transfer =
-            Self::cmp_pubkeys(source_account_info.key, destination_account_info.key);
-
-        match source_account.delegate {
-            COption::Some(ref delegate) if Self::cmp_pubkeys(authority_info.key, delegate) => {
-                Self::validate_owner(
-                    program_id,
-                    delegate,
-                    authority_info,
-                    account_info_iter.as_slice(),
-                )?;
-                if source_account.delegated_amount < amount {
-                    return Err(TokenError::InsufficientFunds.into());
-                }
-                if !self_transfer {
-                    source_account.delegated_amount = source_account
-                        .delegated_amount
-                        .checked_sub(amount)
-                        .ok_or(TokenError::Overflow)?;
-                    if source_account.delegated_amount == 0 {
-                        source_account.delegate = COption::None;
-                    }
-                }
-            }
-            _ => Self::validate_owner(
-                program_id,
-                &source_account.owner,
-                authority_info,
-                account_info_iter.as_slice(),
-            )?,
-        };
-
-        if self_transfer || amount == 0 {
-            Self::check_account_owner(program_id, source_account_info)?;
-            Self::check_account_owner(program_id, destination_account_info)?;
-        }
-
-        // This check MUST occur just before the amounts are manipulated
-        // to ensure self-transfers are fully validated
-        if self_transfer {
-            return Ok(());
-        }
-
-        source_account.amount = source_account
-            .amount
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?;
-        destination_account.amount = destination_account
-            .amount
-            .checked_add(amount)
-            .ok_or(TokenError::Overflow)?;
-
-        if source_account.is_native() {
-            let source_starting_lamports = source_account_info.lamports();
-            **source_account_info.lamports.borrow_mut() = source_starting_lamports
-                .checked_sub(amount)
-                .ok_or(TokenError::Overflow)?;
-
-            let destination_starting_lamports = destination_account_info.lamports();
-            **destination_account_info.lamports.borrow_mut() = destination_starting_lamports
-                .checked_add(amount)
-                .ok_or(TokenError::Overflow)?;
-        }
-
-        Account::pack(source_account, &mut source_account_info.data.borrow_mut())?;
-        Account::pack(
-            destination_account,
-            &mut destination_account_info.data.borrow_mut(),
-        )?;
-
-        Ok(())
-    }
-
-    /// Processes an [Approve](enum.TokenInstruction.html) instruction.
-    pub fn process_approve(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-
-        let expected_mint_info = if let Some(expected_decimals) = expected_decimals {
-            Some((next_account_info(account_info_iter)?, expected_decimals))
-        } else {
-            None
-        };
-        let delegate_info = next_account_info(account_info_iter)?;
-        let owner_info = next_account_info(account_info_iter)?;
-
-        let mut source_account = Account::unpack(&source_account_info.data.borrow())?;
-
-        if source_account.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        if let Some((mint_info, expected_decimals)) = expected_mint_info {
-            if !Self::cmp_pubkeys(mint_info.key, &source_account.mint) {
-                return Err(TokenError::MintMismatch.into());
-            }
-
-            let mint = Mint::unpack(&mint_info.data.borrow_mut())?;
-            if expected_decimals != mint.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        Self::validate_owner(
-            program_id,
-            &source_account.owner,
-            owner_info,
-            account_info_iter.as_slice(),
-        )?;
-
-        source_account.delegate = COption::Some(*delegate_info.key);
-        source_account.delegated_amount = amount;
-
-        Account::pack(source_account, &mut source_account_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes an [Revoke](enum.TokenInstruction.html) instruction.
-    pub fn process_revoke(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-
-        let mut source_account = Account::unpack(&source_account_info.data.borrow())?;
-
-        let owner_info = next_account_info(account_info_iter)?;
-
-        if source_account.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        Self::validate_owner(
-            program_id,
-            &source_account.owner,
-            owner_info,
-            account_info_iter.as_slice(),
-        )?;
-
-        source_account.delegate = COption::None;
-        source_account.delegated_amount = 0;
-
-        Account::pack(source_account, &mut source_account_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes a [SetAuthority](enum.TokenInstruction.html) instruction.
-    pub fn process_set_authority(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        authority_type: AuthorityType,
-        new_authority: COption<Pubkey>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        if account_info.data_len() == Account::get_packed_len() {
-            let mut account = Account::unpack(&account_info.data.borrow())?;
-
-            if account.is_frozen() {
-                return Err(TokenError::AccountFrozen.into());
-            }
-
-            match authority_type {
-                AuthorityType::AccountOwner => {
-                    Self::validate_owner(
-                        program_id,
-                        &account.owner,
-                        authority_info,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if let COption::Some(authority) = new_authority {
-                        account.owner = authority;
-                    } else {
-                        return Err(TokenError::InvalidInstruction.into());
-                    }
-
-                    account.delegate = COption::None;
-                    account.delegated_amount = 0;
-
-                    if account.is_native() {
-                        account.close_authority = COption::None;
-                    }
-                }
-                AuthorityType::CloseAccount => {
-                    let authority = account.close_authority.unwrap_or(account.owner);
-                    Self::validate_owner(
-                        program_id,
-                        &authority,
-                        authority_info,
-                        account_info_iter.as_slice(),
-                    )?;
-                    account.close_authority = new_authority;
-                }
-                _ => {
-                    return Err(TokenError::AuthorityTypeNotSupported.into());
-                }
-            }
-            Account::pack(account, &mut account_info.data.borrow_mut())?;
-        } else if account_info.data_len() == Mint::get_packed_len() {
-            let mut mint = Mint::unpack(&account_info.data.borrow())?;
-            match authority_type {
-                AuthorityType::MintTokens => {
-                    // Once a mint's supply is fixed, it cannot be undone by setting a new
-                    // mint_authority
-                    let mint_authority = mint
-                        .mint_authority
-                        .ok_or(Into::<ProgramError>::into(TokenError::FixedSupply))?;
-                    Self::validate_owner(
-                        program_id,
-                        &mint_authority,
-                        authority_info,
-                        account_info_iter.as_slice(),
-                    )?;
-                    mint.mint_authority = new_authority;
-                }
-                AuthorityType::FreezeAccount => {
-                    // Once a mint's freeze authority is disabled, it cannot be re-enabled by
-                    // setting a new freeze_authority
-                    let freeze_authority = mint
-                        .freeze_authority
-                        .ok_or(Into::<ProgramError>::into(TokenError::MintCannotFreeze))?;
-                    Self::validate_owner(
-                        program_id,
-                        &freeze_authority,
-                        authority_info,
-                        account_info_iter.as_slice(),
-                    )?;
-                    mint.freeze_authority = new_authority;
-                }
-                _ => {
-                    return Err(TokenError::AuthorityTypeNotSupported.into());
-                }
-            }
-            Mint::pack(mint, &mut account_info.data.borrow_mut())?;
-        } else {
-            return Err(ProgramError::InvalidArgument);
-        }
-
-        Ok(())
-    }
-
-    /// Processes a [MintTo](enum.TokenInstruction.html) instruction.
-    pub fn process_mint_to(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let owner_info = next_account_info(account_info_iter)?;
-
-        let mut destination_account = Account::unpack(&destination_account_info.data.borrow())?;
-        if destination_account.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-
-        if destination_account.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if !Self::cmp_pubkeys(mint_info.key, &destination_account.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        let mut mint = Mint::unpack(&mint_info.data.borrow())?;
-        if let Some(expected_decimals) = expected_decimals {
-            if expected_decimals != mint.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        match mint.mint_authority {
-            COption::Some(mint_authority) => Self::validate_owner(
-                program_id,
-                &mint_authority,
-                owner_info,
-                account_info_iter.as_slice(),
-            )?,
-            COption::None => return Err(TokenError::FixedSupply.into()),
-        }
-
-        if amount == 0 {
-            Self::check_account_owner(program_id, mint_info)?;
-            Self::check_account_owner(program_id, destination_account_info)?;
-        }
-
-        destination_account.amount = destination_account
-            .amount
-            .checked_add(amount)
-            .ok_or(TokenError::Overflow)?;
-
-        mint.supply = mint
-            .supply
-            .checked_add(amount)
-            .ok_or(TokenError::Overflow)?;
-
-        Account::pack(
-            destination_account,
-            &mut destination_account_info.data.borrow_mut(),
-        )?;
-        Mint::pack(mint, &mut mint_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes a [Burn](enum.TokenInstruction.html) instruction.
-    pub fn process_burn(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-        expected_decimals: Option<u8>,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-
-        let source_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        let mut source_account = Account::unpack(&source_account_info.data.borrow())?;
-        let mut mint = Mint::unpack(&mint_info.data.borrow())?;
-
-        if source_account.is_frozen() {
-            return Err(TokenError::AccountFrozen.into());
-        }
-        if source_account.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if source_account.amount < amount {
-            return Err(TokenError::InsufficientFunds.into());
-        }
-        if !Self::cmp_pubkeys(mint_info.key, &source_account.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        if let Some(expected_decimals) = expected_decimals {
-            if expected_decimals != mint.decimals {
-                return Err(TokenError::MintDecimalsMismatch.into());
-            }
-        }
-
-        if !source_account.is_owned_by_system_program_or_incinerator() {
-            match source_account.delegate {
-                COption::Some(ref delegate) if Self::cmp_pubkeys(authority_info.key, delegate) => {
-                    Self::validate_owner(
-                        program_id,
-                        delegate,
-                        authority_info,
-                        account_info_iter.as_slice(),
-                    )?;
-
-                    if source_account.delegated_amount < amount {
-                        return Err(TokenError::InsufficientFunds.into());
-                    }
-                    source_account.delegated_amount = source_account
-                        .delegated_amount
-                        .checked_sub(amount)
-                        .ok_or(TokenError::Overflow)?;
-                    if source_account.delegated_amount == 0 {
-                        source_account.delegate = COption::None;
-                    }
-                }
-                _ => Self::validate_owner(
-                    program_id,
-                    &source_account.owner,
-                    authority_info,
-                    account_info_iter.as_slice(),
-                )?,
-            }
-        }
-
-        if amount == 0 {
-            Self::check_account_owner(program_id, source_account_info)?;
-            Self::check_account_owner(program_id, mint_info)?;
-        }
-
-        source_account.amount = source_account
-            .amount
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?;
-        mint.supply = mint
-            .supply
-            .checked_sub(amount)
-            .ok_or(TokenError::Overflow)?;
-
-        Account::pack(source_account, &mut source_account_info.data.borrow_mut())?;
-        Mint::pack(mint, &mut mint_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes a [CloseAccount](enum.TokenInstruction.html) instruction.
-    pub fn process_close_account(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-        let destination_account_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        if Self::cmp_pubkeys(source_account_info.key, destination_account_info.key) {
-            return Err(ProgramError::InvalidAccountData);
-        }
-
-        let source_account = Account::unpack(&source_account_info.data.borrow())?;
-        if !source_account.is_native() && source_account.amount != 0 {
-            return Err(TokenError::NonNativeHasBalance.into());
-        }
-
-        let authority = source_account
-            .close_authority
-            .unwrap_or(source_account.owner);
-        if !source_account.is_owned_by_system_program_or_incinerator() {
-            Self::validate_owner(
-                program_id,
-                &authority,
-                authority_info,
-                account_info_iter.as_slice(),
-            )?;
-        } else if !solana_program::incinerator::check_id(destination_account_info.key) {
-            return Err(ProgramError::InvalidAccountData);
-        }
-
-        let destination_starting_lamports = destination_account_info.lamports();
-        **destination_account_info.lamports.borrow_mut() = destination_starting_lamports
-            .checked_add(source_account_info.lamports())
-            .ok_or(TokenError::Overflow)?;
-
-        **source_account_info.lamports.borrow_mut() = 0;
-        delete_account(source_account_info)?;
-
-        Ok(())
-    }
-
-    /// Processes a [FreezeAccount](enum.TokenInstruction.html) or a
-    /// [ThawAccount](enum.TokenInstruction.html) instruction.
-    pub fn process_toggle_freeze_account(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        freeze: bool,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let source_account_info = next_account_info(account_info_iter)?;
-        let mint_info = next_account_info(account_info_iter)?;
-        let authority_info = next_account_info(account_info_iter)?;
-
-        let mut source_account = Account::unpack(&source_account_info.data.borrow())?;
-        if freeze && source_account.is_frozen() || !freeze && !source_account.is_frozen() {
-            return Err(TokenError::InvalidState.into());
-        }
-        if source_account.is_native() {
-            return Err(TokenError::NativeNotSupported.into());
-        }
-        if !Self::cmp_pubkeys(mint_info.key, &source_account.mint) {
-            return Err(TokenError::MintMismatch.into());
-        }
-
-        let mint = Mint::unpack(&mint_info.data.borrow_mut())?;
-        match mint.freeze_authority {
-            COption::Some(authority) => Self::validate_owner(
-                program_id,
-                &authority,
-                authority_info,
-                account_info_iter.as_slice(),
-            ),
-            COption::None => Err(TokenError::MintCannotFreeze.into()),
-        }?;
-
-        source_account.state = if freeze {
-            AccountState::Frozen
-        } else {
-            AccountState::Initialized
-        };
-
-        Account::pack(source_account, &mut source_account_info.data.borrow_mut())?;
-
-        Ok(())
-    }
-
-    /// Processes a [SyncNative](enum.TokenInstruction.html) instruction
-    pub fn process_sync_native(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let native_account_info = next_account_info(account_info_iter)?;
-        Self::check_account_owner(program_id, native_account_info)?;
-
-        let mut native_account = Account::unpack(&native_account_info.data.borrow())?;
-
-        if let COption::Some(rent_exempt_reserve) = native_account.is_native {
-            let new_amount = native_account_info
-                .lamports()
-                .checked_sub(rent_exempt_reserve)
-                .ok_or(TokenError::Overflow)?;
-            if new_amount < native_account.amount {
-                return Err(TokenError::InvalidState.into());
-            }
-            native_account.amount = new_amount;
-        } else {
-            return Err(TokenError::NonNativeNotSupported.into());
-        }
-
-        Account::pack(native_account, &mut native_account_info.data.borrow_mut())?;
-        Ok(())
-    }
-
-    /// Processes a [GetAccountDataSize](enum.TokenInstruction.html) instruction
-    pub fn process_get_account_data_size(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        // make sure the mint is valid
-        let mint_info = next_account_info(account_info_iter)?;
-        Self::check_account_owner(program_id, mint_info)?;
-        let _ = Mint::unpack(&mint_info.data.borrow())
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        set_return_data(&Account::LEN.to_le_bytes());
-        Ok(())
-    }
-
-    /// Processes an [InitializeImmutableOwner](enum.TokenInstruction.html)
-    /// instruction
-    pub fn process_initialize_immutable_owner(accounts: &[AccountInfo]) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let token_account_info = next_account_info(account_info_iter)?;
-        let account = Account::unpack_unchecked(&token_account_info.data.borrow())?;
-        if account.is_initialized() {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-        msg!("Please upgrade to SPL Token 2022 for immutable owner support");
-        Ok(())
-    }
-
-    /// Processes an [AmountToUiAmount](enum.TokenInstruction.html) instruction
-    pub fn process_amount_to_ui_amount(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        amount: u64,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        Self::check_account_owner(program_id, mint_info)?;
-
-        let mint = Mint::unpack(&mint_info.data.borrow_mut())
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        let ui_amount = amount_to_ui_amount_string_trimmed(amount, mint.decimals);
-
-        set_return_data(&ui_amount.into_bytes());
-        Ok(())
-    }
-
-    /// Processes an [AmountToUiAmount](enum.TokenInstruction.html) instruction
-    pub fn process_ui_amount_to_amount(
-        program_id: &Pubkey,
-        accounts: &[AccountInfo],
-        ui_amount: &str,
-    ) -> ProgramResult {
-        let account_info_iter = &mut accounts.iter();
-        let mint_info = next_account_info(account_info_iter)?;
-        Self::check_account_owner(program_id, mint_info)?;
-
-        let mint = Mint::unpack(&mint_info.data.borrow_mut())
-            .map_err(|_| Into::<ProgramError>::into(TokenError::InvalidMint))?;
-        let amount = try_ui_amount_into_amount(ui_amount.to_string(), mint.decimals)?;
-
-        set_return_data(&amount.to_le_bytes());
-        Ok(())
-    }
-
-    /// Processes an [Instruction](enum.Instruction.html).
-    pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-        let instruction = TokenInstruction::unpack(input)?;
-
-        match instruction {
-            TokenInstruction::InitializeMint {
-                decimals,
-                mint_authority,
-                freeze_authority,
-            } => {
-                msg!("Instruction: InitializeMint");
-                Self::process_initialize_mint(accounts, decimals, mint_authority, freeze_authority)
-            }
-            TokenInstruction::InitializeMint2 {
-                decimals,
-                mint_authority,
-                freeze_authority,
-            } => {
-                msg!("Instruction: InitializeMint2");
-                Self::process_initialize_mint2(accounts, decimals, mint_authority, freeze_authority)
-            }
-            TokenInstruction::InitializeAccount => {
-                msg!("Instruction: InitializeAccount");
-                Self::process_initialize_account(program_id, accounts)
-            }
-            TokenInstruction::InitializeAccount2 { owner } => {
-                msg!("Instruction: InitializeAccount2");
-                Self::process_initialize_account2(program_id, accounts, owner)
-            }
-            TokenInstruction::InitializeAccount3 { owner } => {
-                msg!("Instruction: InitializeAccount3");
-                Self::process_initialize_account3(program_id, accounts, owner)
-            }
-            TokenInstruction::InitializeMultisig { m } => {
-                msg!("Instruction: InitializeMultisig");
-                Self::process_initialize_multisig(accounts, m)
-            }
-            TokenInstruction::InitializeMultisig2 { m } => {
-                msg!("Instruction: InitializeMultisig2");
-                Self::process_initialize_multisig2(accounts, m)
-            }
-            TokenInstruction::Transfer { amount } => {
-                msg!("Instruction: Transfer");
-                Self::process_transfer(program_id, accounts, amount, None)
-            }
-            TokenInstruction::Approve { amount } => {
-                msg!("Instruction: Approve");
-                Self::process_approve(program_id, accounts, amount, None)
-            }
-            TokenInstruction::Revoke => {
-                msg!("Instruction: Revoke");
-                Self::process_revoke(program_id, accounts)
-            }
-            TokenInstruction::SetAuthority {
-                authority_type,
-                new_authority,
-            } => {
-                msg!("Instruction: SetAuthority");
-                Self::process_set_authority(program_id, accounts, authority_type, new_authority)
-            }
-            TokenInstruction::MintTo { amount } => {
-                msg!("Instruction: MintTo");
-                Self::process_mint_to(program_id, accounts, amount, None)
-            }
-            TokenInstruction::Burn { amount } => {
-                msg!("Instruction: Burn");
-                Self::process_burn(program_id, accounts, amount, None)
-            }
-            TokenInstruction::CloseAccount => {
-                msg!("Instruction: CloseAccount");
-                Self::process_close_account(program_id, accounts)
-            }
-            TokenInstruction::FreezeAccount => {
-                msg!("Instruction: FreezeAccount");
-                Self::process_toggle_freeze_account(program_id, accounts, true)
-            }
-            TokenInstruction::ThawAccount => {
-                msg!("Instruction: ThawAccount");
-                Self::process_toggle_freeze_account(program_id, accounts, false)
-            }
-            TokenInstruction::TransferChecked { amount, decimals } => {
-                msg!("Instruction: TransferChecked");
-                Self::process_transfer(program_id, accounts, amount, Some(decimals))
-            }
-            TokenInstruction::ApproveChecked { amount, decimals } => {
-                msg!("Instruction: ApproveChecked");
-                Self::process_approve(program_id, accounts, amount, Some(decimals))
-            }
-            TokenInstruction::MintToChecked { amount, decimals } => {
-                msg!("Instruction: MintToChecked");
-                Self::process_mint_to(program_id, accounts, amount, Some(decimals))
-            }
-            TokenInstruction::BurnChecked { amount, decimals } => {
-                msg!("Instruction: BurnChecked");
-                Self::process_burn(program_id, accounts, amount, Some(decimals))
-            }
-            TokenInstruction::SyncNative => {
-                msg!("Instruction: SyncNative");
-                Self::process_sync_native(program_id, accounts)
-            }
-            TokenInstruction::GetAccountDataSize => {
-                msg!("Instruction: GetAccountDataSize");
-                Self::process_get_account_data_size(program_id, accounts)
-            }
-            TokenInstruction::InitializeImmutableOwner => {
-                msg!("Instruction: InitializeImmutableOwner");
-                Self::process_initialize_immutable_owner(accounts)
-            }
-            TokenInstruction::AmountToUiAmount { amount } => {
-                msg!("Instruction: AmountToUiAmount");
-                Self::process_amount_to_ui_amount(program_id, accounts, amount)
-            }
-            TokenInstruction::UiAmountToAmount { ui_amount } => {
-                msg!("Instruction: UiAmountToAmount");
-                Self::process_ui_amount_to_amount(program_id, accounts, ui_amount)
-            }
-        }
-    }
-
-    /// Checks that the account is owned by the expected program
-    pub fn check_account_owner(program_id: &Pubkey, account_info: &AccountInfo) -> ProgramResult {
-        if !Self::cmp_pubkeys(program_id, account_info.owner) {
-            Err(ProgramError::IncorrectProgramId)
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Checks two pubkeys for equality in a computationally cheap way using
-    /// `sol_memcmp`
-    pub fn cmp_pubkeys(a: &Pubkey, b: &Pubkey) -> bool {
-        sol_memcmp(a.as_ref(), b.as_ref(), PUBKEY_BYTES) == 0
-    }
-
-    /// Validates owner(s) are present
-    pub fn validate_owner(
-        program_id: &Pubkey,
-        expected_owner: &Pubkey,
-        owner_account_info: &AccountInfo,
-        signers: &[AccountInfo],
-    ) -> ProgramResult {
-        if !Self::cmp_pubkeys(expected_owner, owner_account_info.key) {
-            return Err(TokenError::OwnerMismatch.into());
-        }
-        if Self::cmp_pubkeys(program_id, owner_account_info.owner)
-            && owner_account_info.data_len() == Multisig::get_packed_len()
-        {
-            let multisig = Multisig::unpack(&owner_account_info.data.borrow())?;
-            let mut num_signers = 0;
-            let mut matched = [false; MAX_SIGNERS];
-            for signer in signers.iter() {
-                for (position, key) in multisig.signers[0..multisig.n as usize].iter().enumerate() {
-                    if Self::cmp_pubkeys(key, signer.key) && !matched[position] {
-                        if !signer.is_signer {
-                            return Err(ProgramError::MissingRequiredSignature);
-                        }
-                        matched[position] = true;
-                        num_signers += 1;
-                    }
-                }
-            }
-            if num_signers < multisig.m {
-                return Err(ProgramError::MissingRequiredSignature);
-            }
-            return Ok(());
-        } else if !owner_account_info.is_signer {
-            return Err(ProgramError::MissingRequiredSignature);
-        }
-        Ok(())
-    }
-}
-
-/// Helper function to mostly delete an account in a test environment.  We could
-/// potentially muck around the bytes assuming that a vec is passed in, but that
-/// would be more trouble than it's worth.
-#[cfg(not(target_os = "solana"))]
-fn delete_account(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    account_info.assign(&system_program::id());
-    let mut account_data = account_info.data.borrow_mut();
-    let data_len = account_data.len();
-    solana_program::program_memory::sol_memset(*account_data, 0, data_len);
-    Ok(())
-}
-
-/// Helper function to totally delete an account on-chain
-#[cfg(target_os = "solana")]
-fn delete_account(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    account_info.assign(&system_program::id());
-    account_info.realloc(0, false)
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::instruction::*,
-        serial_test::serial,
-        solana_program::{
-            account_info::IntoAccountInfo,
-            clock::Epoch,
-            instruction::Instruction,
-            program_error::{self, PrintProgramError},
-            sysvar::rent,
-        },
-        solana_sdk::account::{
-            create_account_for_test, create_is_signer_account_infos, Account as SolanaAccount,
-        },
-        std::sync::{Arc, RwLock},
-    };
-
-    lazy_static::lazy_static! {
-        static ref EXPECTED_DATA: Arc<RwLock<Vec<u8>>> = Arc::new(RwLock::new(Vec::new()));
-    }
-
-    fn set_expected_data(expected_data: Vec<u8>) {
-        *EXPECTED_DATA.write().unwrap() = expected_data;
-    }
-
-    struct SyscallStubs {}
-    impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
-        fn sol_log(&self, _message: &str) {}
-
-        fn sol_invoke_signed(
-            &self,
-            _instruction: &Instruction,
-            _account_infos: &[AccountInfo],
-            _signers_seeds: &[&[&[u8]]],
-        ) -> ProgramResult {
-            Err(ProgramError::Custom(42)) // Not supported
-        }
-
-        fn sol_get_clock_sysvar(&self, _var_addr: *mut u8) -> u64 {
-            program_error::UNSUPPORTED_SYSVAR
-        }
-
-        fn sol_get_epoch_schedule_sysvar(&self, _var_addr: *mut u8) -> u64 {
-            program_error::UNSUPPORTED_SYSVAR
-        }
-
-        #[allow(deprecated)]
-        fn sol_get_fees_sysvar(&self, _var_addr: *mut u8) -> u64 {
-            program_error::UNSUPPORTED_SYSVAR
-        }
-
-        fn sol_get_rent_sysvar(&self, var_addr: *mut u8) -> u64 {
-            unsafe {
-                *(var_addr as *mut _ as *mut Rent) = Rent::default();
-            }
-            solana_program::entrypoint::SUCCESS
-        }
-
-        fn sol_set_return_data(&self, data: &[u8]) {
-            assert_eq!(&*EXPECTED_DATA.write().unwrap(), data)
-        }
-    }
-
-    fn do_process_instruction(
-        instruction: Instruction,
-        accounts: Vec<&mut SolanaAccount>,
-    ) -> ProgramResult {
-        {
-            use std::sync::Once;
-            static ONCE: Once = Once::new();
-
-            ONCE.call_once(|| {
-                solana_sdk::program_stubs::set_syscall_stubs(Box::new(SyscallStubs {}));
-            });
-        }
-
-        let mut meta = instruction
-            .accounts
-            .iter()
-            .zip(accounts)
-            .map(|(account_meta, account)| (&account_meta.pubkey, account_meta.is_signer, account))
-            .collect::<Vec<_>>();
-
-        let account_infos = create_is_signer_account_infos(&mut meta);
-        Processor::process(&instruction.program_id, &account_infos, &instruction.data)
-    }
-
-    fn do_process_instruction_dups(
-        instruction: Instruction,
-        account_infos: Vec<AccountInfo>,
-    ) -> ProgramResult {
-        Processor::process(&instruction.program_id, &account_infos, &instruction.data)
-    }
-
-    fn return_token_error_as_program_error() -> ProgramError {
-        TokenError::MintMismatch.into()
-    }
-
-    fn rent_sysvar() -> SolanaAccount {
-        create_account_for_test(&Rent::default())
-    }
-
-    fn mint_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Mint::get_packed_len())
-    }
-
-    fn account_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Account::get_packed_len())
-    }
-
-    fn multisig_minimum_balance() -> u64 {
-        Rent::default().minimum_balance(Multisig::get_packed_len())
-    }
-
-    #[test]
-    fn test_print_error() {
-        let error = return_token_error_as_program_error();
-        error.print::<TokenError>();
-    }
-
-    #[test]
-    fn test_error_as_custom() {
-        assert_eq!(
-            return_token_error_as_program_error(),
-            ProgramError::Custom(3)
-        );
-    }
-
-    #[test]
-    fn test_unique_account_sizes() {
-        assert_ne!(Mint::get_packed_len(), 0);
-        assert_ne!(Mint::get_packed_len(), Account::get_packed_len());
-        assert_ne!(Mint::get_packed_len(), Multisig::get_packed_len());
-        assert_ne!(Account::get_packed_len(), 0);
-        assert_ne!(Account::get_packed_len(), Multisig::get_packed_len());
-        assert_ne!(Multisig::get_packed_len(), 0);
-    }
-
-    #[test]
-    fn test_pack_unpack() {
-        // Mint
-        let check = Mint {
-            mint_authority: COption::Some(Pubkey::new_from_array([1; 32])),
-            supply: 42,
-            decimals: 7,
-            is_initialized: true,
-            freeze_authority: COption::Some(Pubkey::new_from_array([2; 32])),
-        };
-        let mut packed = vec![0; Mint::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Mint::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Mint::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Mint::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Mint::get_packed_len()];
-        Mint::pack(check, &mut packed).unwrap();
-        let expect = vec![
-            1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2,
-            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        ];
-        assert_eq!(packed, expect);
-        let unpacked = Mint::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-
-        // Account
-        let check = Account {
-            mint: Pubkey::new_from_array([1; 32]),
-            owner: Pubkey::new_from_array([2; 32]),
-            amount: 3,
-            delegate: COption::Some(Pubkey::new_from_array([4; 32])),
-            state: AccountState::Frozen,
-            is_native: COption::Some(5),
-            delegated_amount: 6,
-            close_authority: COption::Some(Pubkey::new_from_array([7; 32])),
-        };
-        let mut packed = vec![0; Account::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Account::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Account::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Account::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Account::get_packed_len()];
-        Account::pack(check, &mut packed).unwrap();
-        let expect = vec![
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-            2, 2, 2, 2, 2, 2, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 1, 0, 0, 0, 5, 0, 0,
-            0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-        ];
-        assert_eq!(packed, expect);
-        let unpacked = Account::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-
-        // Multisig
-        let check = Multisig {
-            m: 1,
-            n: 2,
-            is_initialized: true,
-            signers: [Pubkey::new_from_array([3; 32]); MAX_SIGNERS],
-        };
-        let mut packed = vec![0; Multisig::get_packed_len() + 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Multisig::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Multisig::get_packed_len() - 1];
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            Multisig::pack(check, &mut packed)
-        );
-        let mut packed = vec![0; Multisig::get_packed_len()];
-        Multisig::pack(check, &mut packed).unwrap();
-        let expect = vec![
-            1, 2, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-            3, 3, 3, 3, 3, 3, 3,
-        ];
-        assert_eq!(packed, expect);
-        let unpacked = Multisig::unpack(&packed).unwrap();
-        assert_eq!(unpacked, check);
-    }
-
-    #[test]
-    fn test_initialize_mint() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // mint is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar]
-            )
-        );
-
-        mint_account.lamports = mint_minimum_balance();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_mint(&program_id, &mint_key, &owner_key, None, 2,).unwrap(),
-                vec![&mut mint_account, &mut rent_sysvar]
-            )
-        );
-
-        // create another mint that can freeze
-        do_process_instruction(
-            initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap();
-        assert_eq!(mint.freeze_authority, COption::Some(owner_key));
-    }
-
-    #[test]
-    fn test_initialize_mint2() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-
-        // mint is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-                vec![&mut mint_account]
-            )
-        );
-
-        mint_account.lamports = mint_minimum_balance();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_mint2(&program_id, &mint_key, &owner_key, None, 2,).unwrap(),
-                vec![&mut mint_account]
-            )
-        );
-
-        // create another mint that can freeze
-        do_process_instruction(
-            initialize_mint2(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap();
-        assert_eq!(mint.freeze_authority, COption::Some(owner_key));
-    }
-
-    #[test]
-    fn test_initialize_mint_account() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(42, Account::get_packed_len(), &program_id);
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // account is not rent exempt
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-
-        account_account.lamports = account_minimum_balance();
-
-        // mint is not valid (not initialized)
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create twice
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut owner_account,
-                    &mut rent_sysvar
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_transfer_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into();
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_info: AccountInfo = (&account3_key, false, &mut account3_account).into();
-        let account4_key = Pubkey::new_unique();
-        let mut account4_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account4_info: AccountInfo = (&account4_key, true, &mut account4_account).into();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account2_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner transfer
-        do_process_instruction_dups(
-            transfer(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate transfer
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.amount = 1000;
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(account1_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-
-        do_process_instruction_dups(
-            transfer(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // test destination-owner transfer
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account3_key, &mint_key, &account2_key).unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account3_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        account1_info.is_signer = false;
-        account2_info.is_signer = true;
-        do_process_instruction_dups(
-            transfer(
-                &program_id,
-                &account3_key,
-                &account2_key,
-                &account2_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                account2_info.clone(),
-                account2_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // destination-owner TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account3_key,
-                &mint_key,
-                &account2_key,
-                &account2_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account2_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // test source-multisig signer
-        do_process_instruction_dups(
-            initialize_multisig(&program_id, &multisig_key, &[&account4_key], 1).unwrap(),
-            vec![
-                multisig_info.clone(),
-                rent_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account4_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                account4_info.clone(),
-                mint_info.clone(),
-                multisig_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account4_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account4_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-multisig-signer transfer
-        do_process_instruction_dups(
-            transfer(
-                &program_id,
-                &account4_key,
-                &account2_key,
-                &multisig_key,
-                &[&account4_key],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account4_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-multisig-signer TransferChecked
-        do_process_instruction_dups(
-            transfer_checked(
-                &program_id,
-                &account4_key,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&account4_key],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account4_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account4_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_transfer() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // missing signer
-        let mut instruction = transfer(
-            &program_id,
-            &account_key,
-            &account2_key,
-            &owner_key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // mismatch mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &mismatch_key,
-                    &owner_key,
-                    &[],
-                    1000
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mismatch_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner2_key,
-                    &[],
-                    1000
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0,).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-        account_account.owner = program_id;
-
-        // account 2 not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account2_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0,).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-        account2_account.owner = program_id;
-
-        // transfer
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 1).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // transfer half back
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account2_key,
-                &account_key,
-                &owner_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut account_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                transfer_checked(
-                    &program_id,
-                    &account2_key,
-                    &mint_key,
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    1,
-                    10 // <-- incorrect decimals
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut mint_account,
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // incorrect mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                transfer_checked(
-                    &program_id,
-                    &account2_key,
-                    &account3_key, // <-- incorrect mint
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    1,
-                    2
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account3_account, // <-- incorrect mint
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        // transfer rest with explicit decimals
-        do_process_instruction(
-            transfer_checked(
-                &program_id,
-                &account2_key,
-                &mint_key,
-                &account_key,
-                &owner_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut account_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                transfer(&program_id, &account2_key, &account_key, &owner_key, &[], 1).unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // not a delegate of source account
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner2_key, // <-- incorrect owner or delegate
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    101
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-
-        // transfer via delegate
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &delegate_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut delegate_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    1
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-
-        // transfer rest
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                900,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // insufficient funds in source account via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &delegate_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut delegate_account,
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_self_transfer() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let account_info = (&account_key, false, &mut account_account).into_account_info();
-        let account3_info = (&account3_key, false, &mut account3_account).into_account_info();
-        let delegate_info = (&delegate_key, true, &mut delegate_account).into_account_info();
-        let owner_info = (&owner_key, true, &mut owner_account).into_account_info();
-        let owner2_info = (&owner2_key, true, &mut owner2_account).into_account_info();
-        let mint_info = (&mint_key, false, &mut mint_account).into_account_info();
-
-        // transfer
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // transfer checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // missing signer
-        let mut owner_no_sign_info = owner_info.clone();
-        let mut instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_no_sign_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        owner_no_sign_info.is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_no_sign_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing signer checked
-        let mut instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_no_sign_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        instruction.accounts[3].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_no_sign_info,
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing owner
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner2_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner2_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // missing owner checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner2_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner2_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // insufficient funds
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1001,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // insufficient funds checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1001,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // incorrect decimals
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1,
-            10, // <-- incorrect decimals
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // incorrect mint
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            account3_info.key, // <-- incorrect mint
-            account_info.key,
-            owner_info.key,
-            &[],
-            1,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account3_info.clone(), // <-- incorrect mint
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // approve delegate
-        let instruction = approve(
-            &program_id,
-            account_info.key,
-            delegate_info.key,
-            owner_info.key,
-            &[],
-            100,
-        )
-        .unwrap();
-        Processor::process(
-            &instruction.program_id,
-            &[
-                account_info.clone(),
-                delegate_info.clone(),
-                owner_info.clone(),
-            ],
-            &instruction.data,
-        )
-        .unwrap();
-
-        // delegate transfer
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            100,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-        assert_eq!(account.delegated_amount, 100);
-
-        // delegate transfer checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            100,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-        assert_eq!(account.delegated_amount, 100);
-
-        // delegate insufficient funds
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            101,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // delegate insufficient funds checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            delegate_info.key,
-            &[],
-            101,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    delegate_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-
-        // owner transfer with delegate assigned
-        let instruction = transfer(
-            &program_id,
-            account_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-
-        // owner transfer with delegate assigned checked
-        let instruction = transfer_checked(
-            &program_id,
-            account_info.key,
-            mint_info.key,
-            account_info.key,
-            owner_info.key,
-            &[],
-            1000,
-            2,
-        )
-        .unwrap();
-        assert_eq!(
-            Ok(()),
-            Processor::process(
-                &instruction.program_id,
-                &[
-                    account_info.clone(),
-                    mint_info.clone(),
-                    account_info.clone(),
-                    owner_info.clone(),
-                ],
-                &instruction.data,
-            )
-        );
-        // no balance change...
-        let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap();
-        assert_eq!(account.amount, 1000);
-    }
-
-    #[test]
-    fn test_mintable_token_with_zero_supply() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint-able token with zero supply
-        let decimals = 2;
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, decimals).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(
-            mint,
-            Mint {
-                mint_authority: COption::Some(owner_key),
-                supply: 0,
-                decimals,
-                is_initialized: true,
-                freeze_authority: COption::None,
-            }
-        );
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to 2, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                mint_to_checked(
-                    &program_id,
-                    &mint_key,
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    42,
-                    decimals + 1
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to 2
-        do_process_instruction(
-            mint_to_checked(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &owner_key,
-                &[],
-                42,
-                decimals,
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let _ = Mint::unpack(&mint_account.data).unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 84);
-    }
-
-    #[test]
-    fn test_approve_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into();
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_info: AccountInfo = (&account3_key, true, &mut account3_account).into();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account2_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner approve
-        do_process_instruction_dups(
-            approve(
-                &program_id,
-                &account1_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner approve_checked
-        do_process_instruction_dups(
-            approve_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account2_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner revoke
-        do_process_instruction_dups(
-            revoke(&program_id, &account1_key, &account1_key, &[]).unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-
-        // test source-multisig signer
-        do_process_instruction_dups(
-            initialize_multisig(&program_id, &multisig_key, &[&account3_key], 1).unwrap(),
-            vec![
-                multisig_info.clone(),
-                rent_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account3_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                multisig_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account3_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-multisig-signer approve
-        do_process_instruction_dups(
-            approve(
-                &program_id,
-                &account3_key,
-                &account2_key,
-                &multisig_key,
-                &[&account3_key],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-multisig-signer approve_checked
-        do_process_instruction_dups(
-            approve_checked(
-                &program_id,
-                &account3_key,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&account3_key],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account3_info.clone(),
-                mint_info.clone(),
-                account2_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner multisig-signer
-        do_process_instruction_dups(
-            revoke(&program_id, &account3_key, &multisig_key, &[&account3_key]).unwrap(),
-            vec![
-                account3_info.clone(),
-                multisig_info.clone(),
-                account3_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_approve() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // missing signer
-        let mut instruction = approve(
-            &program_id,
-            &account_key,
-            &delegate_key,
-            &owner_key,
-            &[],
-            100,
-        )
-        .unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                approve(
-                    &program_id,
-                    &account_key,
-                    &delegate_key,
-                    &owner2_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // approve delegate 2, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                approve_checked(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100,
-                    0 // <-- incorrect decimals
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate 2, with incorrect mint
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                approve_checked(
-                    &program_id,
-                    &account_key,
-                    &account2_key, // <-- bad mint
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100,
-                    0
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account, // <-- bad mint
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // approve delegate 2
-        do_process_instruction(
-            approve_checked(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                100,
-                2,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // revoke delegate
-        do_process_instruction(
-            revoke(&program_id, &account_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_set_authority_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &mint_key, Some(&mint_key), 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // set mint_authority when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::MintTokens,
-                &mint_key,
-                &[],
-            )
-            .unwrap(),
-            vec![mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // set freeze_authority when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::FreezeAccount,
-                &mint_key,
-                &[],
-            )
-            .unwrap(),
-            vec![mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // set account owner when currently self
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &account1_key,
-                Some(&owner_key),
-                AuthorityType::AccountOwner,
-                &account1_key,
-                &[],
-            )
-            .unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-
-        // set close_authority when currently self
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.close_authority = COption::Some(account1_key);
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-
-        do_process_instruction_dups(
-            set_authority(
-                &program_id,
-                &account1_key,
-                Some(&owner_key),
-                AuthorityType::CloseAccount,
-                &account1_key,
-                &[],
-            )
-            .unwrap(),
-            vec![account1_info.clone(), account1_info.clone()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_set_authority() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let owner3_key = Pubkey::new_unique();
-        let mut owner3_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create mint with owner and freeze_authority
-        do_process_instruction(
-            initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // invalid account
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner2_key),
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint2_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint2_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner_key),
-                    AuthorityType::AccountOwner,
-                    &owner2_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner2_account],
-            )
-        );
-
-        // owner did not sign
-        let mut instruction = set_authority(
-            &program_id,
-            &account_key,
-            Some(&owner2_key),
-            AuthorityType::AccountOwner,
-            &owner_key,
-            &[],
-        )
-        .unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(instruction, vec![&mut account_account, &mut owner_account,],)
-        );
-
-        // wrong authority type
-        assert_eq!(
-            Err(TokenError::AuthorityTypeNotSupported.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // account owner may not be set to None
-        assert_eq!(
-            Err(TokenError::InvalidInstruction.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    None,
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // set delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &owner2_key,
-                &owner_key,
-                &[],
-                u64::MAX,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut owner2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.delegate, COption::Some(owner2_key));
-        assert_eq!(account.delegated_amount, u64::MAX);
-
-        // set owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner3_key),
-                AuthorityType::AccountOwner,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // check delegate cleared
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.delegate, COption::None);
-        assert_eq!(account.delegated_amount, 0);
-
-        // set owner without existing delegate
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::AccountOwner,
-                &owner3_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner3_account],
-        )
-        .unwrap();
-
-        // set close_authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::CloseAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // close_authority may be set to None
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                None,
-                AuthorityType::CloseAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // wrong owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint_key,
-                    Some(&owner3_key),
-                    AuthorityType::MintTokens,
-                    &owner2_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // owner did not sign
-        let mut instruction = set_authority(
-            &program_id,
-            &mint_key,
-            Some(&owner2_key),
-            AuthorityType::MintTokens,
-            &owner_key,
-            &[],
-        )
-        .unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(instruction, vec![&mut mint_account, &mut owner_account],)
-        );
-
-        // cannot freeze
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner_account],
-            )
-        );
-
-        // set owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner2_key),
-                AuthorityType::MintTokens,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // set owner to None
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                None,
-                AuthorityType::MintTokens,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        // test unsetting mint_authority is one-way operation
-        assert_eq!(
-            Err(TokenError::FixedSupply.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint2_key,
-                    Some(&owner2_key),
-                    AuthorityType::MintTokens,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut owner_account],
-            )
-        );
-
-        // set freeze_authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint2_key,
-                Some(&owner2_key),
-                AuthorityType::FreezeAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // test unsetting freeze_authority is one-way operation
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint2_key,
-                None,
-                AuthorityType::FreezeAccount,
-                &owner2_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut owner2_account],
-        )
-        .unwrap();
-
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &mint2_key,
-                    Some(&owner2_key),
-                    AuthorityType::FreezeAccount,
-                    &owner_key,
-                    &[],
-                )
-                .unwrap(),
-                vec![&mut mint2_account, &mut owner2_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_mint_to_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &mint_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                owner_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint_to when mint_authority is self
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &mint_key, &[], 42).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint_to_checked when mint_authority is self
-        do_process_instruction_dups(
-            mint_to_checked(&program_id, &mint_key, &account1_key, &mint_key, &[], 42, 2).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint_to when mint_authority is account owner
-        let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow()).unwrap();
-        mint.mint_authority = COption::Some(account1_key);
-        Mint::pack(mint, &mut mint_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                42,
-            )
-            .unwrap(),
-            vec![
-                mint_info.clone(),
-                account1_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint_to_checked when mint_authority is account owner
-        do_process_instruction_dups(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                42,
-            )
-            .unwrap(),
-            vec![
-                mint_info.clone(),
-                account1_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_mint_to() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let uninitialized_key = Pubkey::new_unique();
-        let mut uninitialized_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // mint to
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 42);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // mint to another account to test supply accumulation
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut mint_account, &mut account2_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 84);
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // missing signer
-        let mut instruction =
-            mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap();
-        instruction.accounts[2].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            do_process_instruction(
-                instruction,
-                vec![&mut mint_account, &mut account2_account, &mut owner_account],
-            )
-        );
-
-        // mismatch account
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mint_account, &mut mismatch_account, &mut owner_account],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account2_key, &owner2_key, &[], 42).unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account2_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-        account_account.owner = program_id;
-
-        // uninitialized destination account
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &uninitialized_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut uninitialized_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // unset mint_authority and test minting fails
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                None,
-                AuthorityType::MintTokens,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        assert_eq!(
-            Err(TokenError::FixedSupply.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mint_account, &mut account2_account, &mut owner_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_burn_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-
-        // source-owner burn
-        do_process_instruction_dups(
-            burn(
-                &program_id,
-                &mint_key,
-                &account1_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint-owner burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.owner = mint_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint-owner burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &mint_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // source-delegate burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(account1_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-delegate burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &account1_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // mint-delegate burn
-        do_process_instruction_dups(
-            mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(),
-            vec![mint_info.clone(), account1_info.clone(), owner_info.clone()],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.delegated_amount = 1000;
-        account.delegate = COption::Some(mint_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-
-        // mint-delegate burn_checked
-        do_process_instruction_dups(
-            burn_checked(
-                &program_id,
-                &account1_key,
-                &mint_key,
-                &mint_key,
-                &[],
-                500,
-                2,
-            )
-            .unwrap(),
-            vec![account1_info.clone(), mint_info.clone(), mint_info.clone()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_burn() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        let mismatch_key = Pubkey::new_unique();
-        let mut mismatch_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint2_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create mismatch account
-        do_process_instruction(
-            initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut mismatch_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // mint to mismatch account and change mint key
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut mismatch_account, &mut owner_account],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap();
-        account.mint = mint2_key;
-        Account::pack(account, &mut mismatch_account.data).unwrap();
-
-        // missing signer
-        let mut instruction =
-            burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 42).unwrap();
-        instruction.accounts[1].is_signer = false;
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                instruction,
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-
-        // missing owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner2_key, &[], 42).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // account not owned by program
-        let not_program_id = Pubkey::new_unique();
-        account_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-        account_account.owner = program_id;
-
-        // mint not owned by program
-        let not_program_id = Pubkey::new_unique();
-        mint_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-        mint_account.owner = program_id;
-
-        // mint mismatch
-        assert_eq!(
-            Err(TokenError::MintMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &mismatch_key, &mint_key, &owner_key, &[], 42).unwrap(),
-                vec![&mut mismatch_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // burn
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 21).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // burn_checked, with incorrect decimals
-        assert_eq!(
-            Err(TokenError::MintDecimalsMismatch.into()),
-            do_process_instruction(
-                burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 3).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // burn_checked
-        do_process_instruction(
-            burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 2).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 2000 - 42);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 1000 - 42);
-
-        // insufficient funds
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &owner_key,
-                    &[],
-                    100_000_000
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // approve delegate
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &delegate_key,
-                &owner_key,
-                &[],
-                84,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut delegate_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // not a delegate of source account
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &mint_key,
-                    &owner2_key, // <-- incorrect owner or delegate
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 85).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-
-        // burn via delegate
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 84).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut delegate_account,
-            ],
-        )
-        .unwrap();
-
-        // match
-        let mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        assert_eq!(mint.supply, 2000 - 42 - 84);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 1000 - 42 - 84);
-
-        // insufficient funds approved via delegate
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 1).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut mint_account,
-                    &mut delegate_account
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_burn_and_close_system_and_incinerator_tokens() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let incinerator_account_key = Pubkey::new_unique();
-        let mut incinerator_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let system_account_key = Pubkey::new_unique();
-        let mut system_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let recipient_key = Pubkey::new_unique();
-        let mut recipient_account = SolanaAccount::default();
-        let mut mock_incinerator_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-
-        // create new mint
-        do_process_instruction(
-            initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account3(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![&mut account_account, &mut mint_account],
-        )
-        .unwrap();
-
-        // create incinerator- and system-owned accounts
-        do_process_instruction(
-            initialize_account3(
-                &program_id,
-                &incinerator_account_key,
-                &mint_key,
-                &solana_program::incinerator::id(),
-            )
-            .unwrap(),
-            vec![&mut incinerator_account, &mut mint_account],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_account3(
-                &program_id,
-                &system_account_key,
-                &mint_key,
-                &solana_program::system_program::id(),
-            )
-            .unwrap(),
-            vec![&mut system_account, &mut mint_account],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // transfer half to incinerator, half to system program
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &incinerator_account_key,
-                &owner_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut incinerator_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &system_account_key,
-                &owner_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut system_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        // close with balance fails
-        assert_eq!(
-            Err(TokenError::NonNativeHasBalance.into()),
-            do_process_instruction(
-                close_account(
-                    &program_id,
-                    &incinerator_account_key,
-                    &solana_program::incinerator::id(),
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![
-                    &mut incinerator_account,
-                    &mut mock_incinerator_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        assert_eq!(
-            Err(TokenError::NonNativeHasBalance.into()),
-            do_process_instruction(
-                close_account(
-                    &program_id,
-                    &system_account_key,
-                    &solana_program::incinerator::id(),
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![
-                    &mut system_account,
-                    &mut mock_incinerator_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // anyone can burn
-        do_process_instruction(
-            burn(
-                &program_id,
-                &incinerator_account_key,
-                &mint_key,
-                &recipient_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut incinerator_account,
-                &mut mint_account,
-                &mut recipient_account,
-            ],
-        )
-        .unwrap();
-        do_process_instruction(
-            burn(
-                &program_id,
-                &system_account_key,
-                &mint_key,
-                &recipient_key,
-                &[],
-                500,
-            )
-            .unwrap(),
-            vec![
-                &mut system_account,
-                &mut mint_account,
-                &mut recipient_account,
-            ],
-        )
-        .unwrap();
-
-        // closing fails if destination is not the incinerator
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            do_process_instruction(
-                close_account(
-                    &program_id,
-                    &incinerator_account_key,
-                    &recipient_key,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![
-                    &mut incinerator_account,
-                    &mut recipient_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidAccountData),
-            do_process_instruction(
-                close_account(
-                    &program_id,
-                    &system_account_key,
-                    &recipient_key,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![
-                    &mut system_account,
-                    &mut recipient_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // closing succeeds with incinerator recipient
-        do_process_instruction(
-            close_account(
-                &program_id,
-                &incinerator_account_key,
-                &solana_program::incinerator::id(),
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                &mut incinerator_account,
-                &mut mock_incinerator_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            close_account(
-                &program_id,
-                &system_account_key,
-                &solana_program::incinerator::id(),
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                &mut system_account,
-                &mut mock_incinerator_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_multisig() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let account_key = Pubkey::new_unique();
-        let mut account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let multisig_key = Pubkey::new_unique();
-        let mut multisig_account = SolanaAccount::new(42, Multisig::get_packed_len(), &program_id);
-        let multisig_delegate_key = Pubkey::new_unique();
-        let mut multisig_delegate_account = SolanaAccount::new(
-            multisig_minimum_balance(),
-            Multisig::get_packed_len(),
-            &program_id,
-        );
-        let signer_keys = vec![Pubkey::new_unique(); MAX_SIGNERS];
-        let signer_key_refs: Vec<&Pubkey> = signer_keys.iter().collect();
-        let mut signer_accounts = vec![SolanaAccount::new(0, 0, &program_id); MAX_SIGNERS];
-        let mut rent_sysvar = rent_sysvar();
-
-        // multisig is not rent exempt
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        assert_eq!(
-            Err(TokenError::NotRentExempt.into()),
-            do_process_instruction(
-                initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-                vec![
-                    &mut multisig_account,
-                    &mut rent_sysvar,
-                    account_info_iter.next().unwrap(),
-                ],
-            )
-        );
-
-        multisig_account.lamports = multisig_minimum_balance();
-        let mut multisig_account2 = multisig_account.clone();
-
-        // single signer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-            vec![
-                &mut multisig_account,
-                &mut rent_sysvar,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // single signer using `initialize_multisig2`
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig2(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(),
-            vec![&mut multisig_account2, account_info_iter.next().unwrap()],
-        )
-        .unwrap();
-
-        // multiple signer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            initialize_multisig(
-                &program_id,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                MAX_SIGNERS as u8,
-            )
-            .unwrap(),
-            vec![
-                &mut multisig_delegate_account,
-                &mut rent_sysvar,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // create new mint with multisig owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &multisig_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account with multisig owner
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &multisig_key).unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account with multisig owner
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &mint_key,
-                &multisig_delegate_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut multisig_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // approve
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            approve(
-                &program_id,
-                &account_key,
-                &multisig_delegate_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut multisig_delegate_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // transfer
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut account2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // transfer via delegate
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut account2_account,
-                &mut multisig_delegate_account,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // mint to
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // burn
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            burn(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // burn via delegate
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            burn(
-                &program_id,
-                &account_key,
-                &mint_key,
-                &multisig_delegate_key,
-                &signer_key_refs,
-                42,
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut mint_account,
-                &mut multisig_delegate_account,
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // freeze account
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mint2_key = Pubkey::new_unique();
-        let mut mint2_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        do_process_instruction(
-            initialize_mint(
-                &program_id,
-                &mint2_key,
-                &multisig_key,
-                Some(&multisig_key),
-                2,
-            )
-            .unwrap(),
-            vec![&mut mint2_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_account(&program_id, &account3_key, &mint2_key, &owner_key).unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint2_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint2_key,
-                &account3_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-                1000,
-            )
-            .unwrap(),
-            vec![
-                &mut mint2_account,
-                &mut account3_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            freeze_account(
-                &program_id,
-                &account3_key,
-                &mint2_key,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut account3_account,
-                &mut mint2_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // do SetAuthority on mint
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &mint_key,
-                Some(&owner_key),
-                AuthorityType::MintTokens,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-
-        // do SetAuthority on account
-        let account_info_iter = &mut signer_accounts.iter_mut();
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner_key),
-                AuthorityType::AccountOwner,
-                &multisig_key,
-                &[&signer_keys[0]],
-            )
-            .unwrap(),
-            vec![
-                &mut account,
-                &mut multisig_account,
-                account_info_iter.next().unwrap(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_validate_owner() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mut signer_keys = [Pubkey::default(); MAX_SIGNERS];
-        for signer_key in signer_keys.iter_mut().take(MAX_SIGNERS) {
-            *signer_key = Pubkey::new_unique();
-        }
-        let mut signer_lamports = 0;
-        let mut signer_data = vec![];
-        let mut signers = vec![
-            AccountInfo::new(
-                &owner_key,
-                true,
-                false,
-                &mut signer_lamports,
-                &mut signer_data,
-                &program_id,
-                false,
-                Epoch::default(),
-            );
-            MAX_SIGNERS + 1
-        ];
-        for (signer, key) in signers.iter_mut().zip(&signer_keys) {
-            signer.key = key;
-        }
-        let mut lamports = 0;
-        let mut data = vec![0; Multisig::get_packed_len()];
-        let mut multisig = Multisig::unpack_unchecked(&data).unwrap();
-        multisig.m = MAX_SIGNERS as u8;
-        multisig.n = MAX_SIGNERS as u8;
-        multisig.signers = signer_keys;
-        multisig.is_initialized = true;
-        Multisig::pack(multisig, &mut data).unwrap();
-        let owner_account_info = AccountInfo::new(
-            &owner_key,
-            false,
-            false,
-            &mut lamports,
-            &mut data,
-            &program_id,
-            false,
-            Epoch::default(),
-        );
-
-        // full 11 of 11
-        Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers).unwrap();
-
-        // 1 of 11
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 1;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers).unwrap();
-
-        // 2:1
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 1;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers)
-        );
-
-        // 0:11
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 0;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers).unwrap();
-
-        // 2:11 but 0 provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &[])
-        );
-        // 2:11 but 1 provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers[0..1])
-        );
-
-        // 2:11, 2 from middle provided
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 2;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers[5..7])
-            .unwrap();
-
-        // 11:11, one is not a signer
-        {
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 11;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-        }
-        signers[5].is_signer = false;
-        assert_eq!(
-            Err(ProgramError::MissingRequiredSignature),
-            Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers)
-        );
-        signers[5].is_signer = true;
-
-        // 11:11, single signer signs multiple times
-        {
-            let mut signer_lamports = 0;
-            let mut signer_data = vec![];
-            let signers = vec![
-                AccountInfo::new(
-                    &signer_keys[5],
-                    true,
-                    false,
-                    &mut signer_lamports,
-                    &mut signer_data,
-                    &program_id,
-                    false,
-                    Epoch::default(),
-                );
-                MAX_SIGNERS + 1
-            ];
-            let mut multisig =
-                Multisig::unpack_unchecked(&owner_account_info.data.borrow()).unwrap();
-            multisig.m = 11;
-            multisig.n = 11;
-            Multisig::pack(multisig, &mut owner_account_info.data.borrow_mut()).unwrap();
-            assert_eq!(
-                Err(ProgramError::MissingRequiredSignature),
-                Processor::validate_owner(&program_id, &owner_key, &owner_account_info, &signers)
-            );
-        }
-    }
-
-    #[test]
-    fn test_owner_close_account_dups() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        let to_close_key = Pubkey::new_unique();
-        let mut to_close_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let to_close_account_info: AccountInfo =
-            (&to_close_key, true, &mut to_close_account).into();
-        let destination_account_key = Pubkey::new_unique();
-        let mut destination_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let destination_account_info: AccountInfo =
-            (&destination_account_key, true, &mut destination_account).into();
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                mint_info.clone(),
-                to_close_account_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // source-owner close
-        do_process_instruction_dups(
-            close_account(
-                &program_id,
-                &to_close_key,
-                &destination_account_key,
-                &to_close_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                destination_account_info.clone(),
-                to_close_account_info.clone(),
-            ],
-        )
-        .unwrap();
-        assert_eq!(*to_close_account_info.data.borrow(), &[0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_close_authority_close_account_dups() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        let to_close_key = Pubkey::new_unique();
-        let mut to_close_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let to_close_account_info: AccountInfo =
-            (&to_close_key, true, &mut to_close_account).into();
-        let destination_account_key = Pubkey::new_unique();
-        let mut destination_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let destination_account_info: AccountInfo =
-            (&destination_account_key, true, &mut destination_account).into();
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                mint_info.clone(),
-                to_close_account_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-        let mut account = Account::unpack_unchecked(&to_close_account_info.data.borrow()).unwrap();
-        account.close_authority = COption::Some(to_close_key);
-        account.owner = owner_key;
-        Account::pack(account, &mut to_close_account_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            close_account(
-                &program_id,
-                &to_close_key,
-                &destination_account_key,
-                &to_close_key,
-                &[],
-            )
-            .unwrap(),
-            vec![
-                to_close_account_info.clone(),
-                destination_account_info.clone(),
-                to_close_account_info.clone(),
-            ],
-        )
-        .unwrap();
-        assert_eq!(*to_close_account_info.data.borrow(), &[0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_close_account() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance() + 42,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mut rent_sysvar = rent_sysvar();
-
-        // uninitialized
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // initialize and mint to non-native account
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 42);
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 42);
-
-        // close non-native account with balance
-        assert_eq!(
-            Err(TokenError::NonNativeHasBalance.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-        assert_eq!(account_account.lamports, account_minimum_balance());
-
-        // empty account
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 42).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // wrong owner
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-
-        // close account
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance());
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 0);
-
-        // fund and initialize new non-native account to test close authority
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        account_account.lamports = 2;
-
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::CloseAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // account owner cannot authorize close if close_authority is set
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account3_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // close non-native account with close_authority
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner2_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance() + 2);
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, 0);
-
-        // close native account
-        do_process_instruction(
-            close_account(&program_id, &account2_key, &account3_key, &owner_key, &[]).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut account3_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account2_account.data, [0u8; Account::LEN]);
-        assert_eq!(
-            account3_account.lamports,
-            3 * account_minimum_balance() + 2 + 42
-        );
-    }
-
-    #[test]
-    fn test_native_token() {
-        let program_id = crate::id();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance() + 40,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account3_key = Pubkey::new_unique();
-        let mut account3_account = SolanaAccount::new(account_minimum_balance(), 0, &program_id);
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let owner3_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 40);
-
-        // initialize native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &account2_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 0);
-
-        // mint_to unsupported
-        assert_eq!(
-            Err(TokenError::NativeNotSupported.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &crate::native_mint::id(),
-                    &account_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account],
-            )
-        );
-
-        // burn unsupported
-        let bogus_mint_key = Pubkey::new_unique();
-        let mut bogus_mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        do_process_instruction(
-            initialize_mint(&program_id, &bogus_mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut bogus_mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        assert_eq!(
-            Err(TokenError::NativeNotSupported.into()),
-            do_process_instruction(
-                burn(
-                    &program_id,
-                    &account_key,
-                    &bogus_mint_key,
-                    &owner_key,
-                    &[],
-                    42
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut bogus_mint_account,
-                    &mut owner_account
-                ],
-            )
-        );
-
-        // ensure can't transfer below rent-exempt reserve
-        assert_eq!(
-            Err(TokenError::InsufficientFunds.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    50,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // transfer between native accounts
-        do_process_instruction(
-            transfer(
-                &program_id,
-                &account_key,
-                &account2_key,
-                &owner_key,
-                &[],
-                40,
-            )
-            .unwrap(),
-            vec![
-                &mut account_account,
-                &mut account2_account,
-                &mut owner_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, account_minimum_balance());
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 0);
-        assert_eq!(account2_account.lamports, account_minimum_balance() + 40);
-        let account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, 40);
-
-        // set close authority
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner3_key),
-                AuthorityType::CloseAccount,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.close_authority, COption::Some(owner3_key));
-
-        // set new account owner
-        do_process_instruction(
-            set_authority(
-                &program_id,
-                &account_key,
-                Some(&owner2_key),
-                AuthorityType::AccountOwner,
-                &owner_key,
-                &[],
-            )
-            .unwrap(),
-            vec![&mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // close authority cleared
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.close_authority, COption::None);
-
-        // close native account
-        do_process_instruction(
-            close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(),
-            vec![
-                &mut account_account,
-                &mut account3_account,
-                &mut owner2_account,
-            ],
-        )
-        .unwrap();
-        assert_eq!(account_account.lamports, 0);
-        assert_eq!(account3_account.lamports, 2 * account_minimum_balance());
-        assert_eq!(account_account.data, [0u8; Account::LEN]);
-    }
-
-    #[test]
-    fn test_overflow() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_owner_key = Pubkey::new_unique();
-        let mut mint_owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &mint_owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create an account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner2_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner2_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint the max to an account
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &mint_owner_key,
-                &[],
-                u64::MAX,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut mint_owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // attempt to mint one more to account
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &account_key,
-                    &mint_owner_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account_account,
-                    &mut mint_owner_account,
-                ],
-            )
-        );
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // attempt to mint one more to the other account
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                mint_to(
-                    &program_id,
-                    &mint_key,
-                    &account2_key,
-                    &mint_owner_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut mint_account,
-                    &mut account2_account,
-                    &mut mint_owner_account,
-                ],
-            )
-        );
-
-        // burn some of the supply
-        do_process_instruction(
-            burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX - 100);
-
-        do_process_instruction(
-            mint_to(
-                &program_id,
-                &mint_key,
-                &account_key,
-                &mint_owner_key,
-                &[],
-                100,
-            )
-            .unwrap(),
-            vec![
-                &mut mint_account,
-                &mut account_account,
-                &mut mint_owner_account,
-            ],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.amount, u64::MAX);
-
-        // manipulate account balance to attempt overflow transfer
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.amount = 1;
-        Account::pack(account, &mut account2_account.data).unwrap();
-
-        assert_eq!(
-            Err(TokenError::Overflow.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account2_key,
-                    &account_key,
-                    &owner2_key,
-                    &[],
-                    1,
-                )
-                .unwrap(),
-                vec![
-                    &mut account2_account,
-                    &mut account_account,
-                    &mut owner2_account,
-                ],
-            )
-        );
-    }
-
-    #[test]
-    fn test_frozen() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account2_key = Pubkey::new_unique();
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint and fund first account
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // create another account
-        do_process_instruction(
-            initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account2_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // fund first account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // no transfer if either account is frozen
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account2_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    500,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.state = AccountState::Initialized;
-        Account::pack(account, &mut account_account.data).unwrap();
-        let mut account = Account::unpack_unchecked(&account2_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account2_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                transfer(
-                    &program_id,
-                    &account_key,
-                    &account2_key,
-                    &owner_key,
-                    &[],
-                    500,
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut account2_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no approve if account is frozen
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account_account.data).unwrap();
-        let delegate_key = Pubkey::new_unique();
-        let mut delegate_account = SolanaAccount::default();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                approve(
-                    &program_id,
-                    &account_key,
-                    &delegate_key,
-                    &owner_key,
-                    &[],
-                    100
-                )
-                .unwrap(),
-                vec![
-                    &mut account_account,
-                    &mut delegate_account,
-                    &mut owner_account,
-                ],
-            )
-        );
-
-        // no revoke if account is frozen
-        let mut account = Account::unpack_unchecked(&account_account.data).unwrap();
-        account.delegate = COption::Some(delegate_key);
-        account.delegated_amount = 100;
-        Account::pack(account, &mut account_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                revoke(&program_id, &account_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut owner_account],
-            )
-        );
-
-        // no set authority if account is frozen
-        let new_owner_key = Pubkey::new_unique();
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                set_authority(
-                    &program_id,
-                    &account_key,
-                    Some(&new_owner_key),
-                    AuthorityType::AccountOwner,
-                    &owner_key,
-                    &[]
-                )
-                .unwrap(),
-                vec![&mut account_account, &mut owner_account,],
-            )
-        );
-
-        // no mint_to if destination account is frozen
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 100).unwrap(),
-                vec![&mut mint_account, &mut account_account, &mut owner_account,],
-            )
-        );
-
-        // no burn if account is frozen
-        assert_eq!(
-            Err(TokenError::AccountFrozen.into()),
-            do_process_instruction(
-                burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-    }
-
-    #[test]
-    fn test_freeze_thaw_dups() {
-        let program_id = crate::id();
-        let account1_key = Pubkey::new_unique();
-        let mut account1_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into();
-        let rent_key = rent::id();
-        let mut rent_sysvar = rent_sysvar();
-        let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into();
-
-        // create mint
-        do_process_instruction_dups(
-            initialize_mint(&program_id, &mint_key, &owner_key, Some(&account1_key), 2).unwrap(),
-            vec![mint_info.clone(), rent_info.clone()],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction_dups(
-            initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-                rent_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // freeze where mint freeze_authority is account
-        do_process_instruction_dups(
-            freeze_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-
-        // thaw where mint freeze_authority is account
-        let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap();
-        account.state = AccountState::Frozen;
-        Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap();
-        do_process_instruction_dups(
-            thaw_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(),
-            vec![
-                account1_info.clone(),
-                mint_info.clone(),
-                account1_info.clone(),
-            ],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_freeze_account() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let account_owner_key = Pubkey::new_unique();
-        let mut account_owner_account = SolanaAccount::default();
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let owner2_key = Pubkey::new_unique();
-        let mut owner2_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create new mint with owner different from account owner
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &account_owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut account_owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // mint to account
-        do_process_instruction(
-            mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(),
-            vec![&mut mint_account, &mut account_account, &mut owner_account],
-        )
-        .unwrap();
-
-        // mint cannot freeze
-        assert_eq!(
-            Err(TokenError::MintCannotFreeze.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // missing freeze_authority
-        let mut mint = Mint::unpack_unchecked(&mint_account.data).unwrap();
-        mint.freeze_authority = COption::Some(owner_key);
-        Mint::pack(mint, &mut mint_account.data).unwrap();
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // check explicit thaw
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // freeze
-        do_process_instruction(
-            freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.state, AccountState::Frozen);
-
-        // check explicit freeze
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner_account],
-            )
-        );
-
-        // check thaw authority
-        assert_eq!(
-            Err(TokenError::OwnerMismatch.into()),
-            do_process_instruction(
-                thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(),
-                vec![&mut account_account, &mut mint_account, &mut owner2_account],
-            )
-        );
-
-        // thaw
-        do_process_instruction(
-            thaw_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(),
-            vec![&mut account_account, &mut mint_account, &mut owner_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&account_account.data).unwrap();
-        assert_eq!(account.state, AccountState::Initialized);
-    }
-
-    #[test]
-    fn test_initialize_account2_and_3() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account2_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let mut account3_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        do_process_instruction(
-            initialize_account2(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![&mut account2_account, &mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        assert_eq!(account_account, account2_account);
-
-        do_process_instruction(
-            initialize_account3(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![&mut account3_account, &mut mint_account],
-        )
-        .unwrap();
-
-        assert_eq!(account_account, account3_account);
-    }
-
-    #[test]
-    fn test_sync_native() {
-        let program_id = crate::id();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let native_account_key = Pubkey::new_unique();
-        let lamports = 40;
-        let mut native_account = SolanaAccount::new(
-            account_minimum_balance() + lamports,
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let non_native_account_key = Pubkey::new_unique();
-        let mut non_native_account = SolanaAccount::new(
-            account_minimum_balance() + 50,
-            Account::get_packed_len(),
-            &program_id,
-        );
-
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mut rent_sysvar = rent_sysvar();
-
-        // initialize non-native mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // initialize non-native account
-        do_process_instruction(
-            initialize_account(&program_id, &non_native_account_key, &mint_key, &owner_key)
-                .unwrap(),
-            vec![
-                &mut non_native_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        let account = Account::unpack_unchecked(&non_native_account.data).unwrap();
-        assert!(!account.is_native());
-        assert_eq!(account.amount, 0);
-
-        // fail sync non-native
-        assert_eq!(
-            Err(TokenError::NonNativeNotSupported.into()),
-            do_process_instruction(
-                sync_native(&program_id, &non_native_account_key,).unwrap(),
-                vec![&mut non_native_account],
-            )
-        );
-
-        // fail sync uninitialized
-        assert_eq!(
-            Err(ProgramError::UninitializedAccount),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-
-        // wrap native account
-        do_process_instruction(
-            initialize_account(
-                &program_id,
-                &native_account_key,
-                &crate::native_mint::id(),
-                &owner_key,
-            )
-            .unwrap(),
-            vec![
-                &mut native_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // fail sync, not owned by program
-        let not_program_id = Pubkey::new_unique();
-        native_account.owner = not_program_id;
-        assert_eq!(
-            Err(ProgramError::IncorrectProgramId),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-        native_account.owner = program_id;
-
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert!(account.is_native());
-        assert_eq!(account.amount, lamports);
-
-        // sync, no change
-        do_process_instruction(
-            sync_native(&program_id, &native_account_key).unwrap(),
-            vec![&mut native_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert_eq!(account.amount, lamports);
-
-        // transfer sol
-        let new_lamports = lamports + 50;
-        native_account.lamports = account_minimum_balance() + new_lamports;
-
-        // success sync
-        do_process_instruction(
-            sync_native(&program_id, &native_account_key).unwrap(),
-            vec![&mut native_account],
-        )
-        .unwrap();
-        let account = Account::unpack_unchecked(&native_account.data).unwrap();
-        assert_eq!(account.amount, new_lamports);
-
-        // reduce sol
-        native_account.lamports -= 1;
-
-        // fail sync
-        assert_eq!(
-            Err(TokenError::InvalidState.into()),
-            do_process_instruction(
-                sync_native(&program_id, &native_account_key,).unwrap(),
-                vec![&mut native_account],
-            )
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn test_get_account_data_size() {
-        // see integration tests for return-data validity
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mut rent_sysvar = rent_sysvar();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mint_key = Pubkey::new_unique();
-        // fail if an invalid mint is passed in
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                get_account_data_size(&program_id, &mint_key).unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data(Account::LEN.to_le_bytes().to_vec());
-        do_process_instruction(
-            get_account_data_size(&program_id, &mint_key).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_initialize_immutable_owner() {
-        let program_id = crate::id();
-        let account_key = Pubkey::new_unique();
-        let mut account_account = SolanaAccount::new(
-            account_minimum_balance(),
-            Account::get_packed_len(),
-            &program_id,
-        );
-        let owner_key = Pubkey::new_unique();
-        let mut owner_account = SolanaAccount::default();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        // success initialize immutable
-        do_process_instruction(
-            initialize_immutable_owner(&program_id, &account_key).unwrap(),
-            vec![&mut account_account],
-        )
-        .unwrap();
-
-        // create account
-        do_process_instruction(
-            initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(),
-            vec![
-                &mut account_account,
-                &mut mint_account,
-                &mut owner_account,
-                &mut rent_sysvar,
-            ],
-        )
-        .unwrap();
-
-        // fail post-init
-        assert_eq!(
-            Err(TokenError::AlreadyInUse.into()),
-            do_process_instruction(
-                initialize_immutable_owner(&program_id, &account_key).unwrap(),
-                vec![&mut account_account],
-            )
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn test_amount_to_ui_amount() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // fail if an invalid mint is passed in
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data("0.23".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 23).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("1.1".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("42".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 4200).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data("0".as_bytes().to_vec());
-        do_process_instruction(
-            amount_to_ui_amount(&program_id, &mint_key, 0).unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[serial]
-    fn test_ui_amount_to_amount() {
-        let program_id = crate::id();
-        let owner_key = Pubkey::new_unique();
-        let mint_key = Pubkey::new_unique();
-        let mut mint_account =
-            SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id);
-        let mut rent_sysvar = rent_sysvar();
-
-        // fail if an invalid mint is passed in
-        assert_eq!(
-            Err(TokenError::InvalidMint.into()),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-
-        // create mint
-        do_process_instruction(
-            initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(),
-            vec![&mut mint_account, &mut rent_sysvar],
-        )
-        .unwrap();
-
-        set_expected_data(23u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.23").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.20").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0.2000").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(20u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, ".20").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(110u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(110u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "1.10").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(4200u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "42").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(4200u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "42.").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        set_expected_data(0u64.to_le_bytes().to_vec());
-        do_process_instruction(
-            ui_amount_to_amount(&program_id, &mint_key, "0").unwrap(),
-            vec![&mut mint_account],
-        )
-        .unwrap();
-
-        // fail if invalid ui_amount passed in
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, ".").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "0.111").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-        assert_eq!(
-            Err(ProgramError::InvalidArgument),
-            do_process_instruction(
-                ui_amount_to_amount(&program_id, &mint_key, "0.t").unwrap(),
-                vec![&mut mint_account],
-            )
-        );
-    }
-}
diff --git a/token/program/src/state.rs b/token/program/src/state.rs
deleted file mode 100644
index fe23fbaafc4..00000000000
--- a/token/program/src/state.rs
+++ /dev/null
@@ -1,492 +0,0 @@
-//! State transition types
-
-use {
-    crate::instruction::MAX_SIGNERS,
-    arrayref::{array_mut_ref, array_ref, array_refs, mut_array_refs},
-    num_enum::TryFromPrimitive,
-    solana_program::{
-        program_error::ProgramError,
-        program_option::COption,
-        program_pack::{IsInitialized, Pack, Sealed},
-        pubkey::{Pubkey, PUBKEY_BYTES},
-    },
-};
-
-/// Mint data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Mint {
-    /// Optional authority used to mint new tokens. The mint authority may only
-    /// be provided during mint creation. If no mint authority is present
-    /// then the mint has a fixed supply and no further tokens may be
-    /// minted.
-    pub mint_authority: COption<Pubkey>,
-    /// Total supply of tokens.
-    pub supply: u64,
-    /// Number of base 10 digits to the right of the decimal place.
-    pub decimals: u8,
-    /// Is `true` if this structure has been initialized
-    pub is_initialized: bool,
-    /// Optional authority to freeze token accounts.
-    pub freeze_authority: COption<Pubkey>,
-}
-impl Sealed for Mint {}
-impl IsInitialized for Mint {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized
-    }
-}
-impl Pack for Mint {
-    const LEN: usize = 82;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 82];
-        let (mint_authority, supply, decimals, is_initialized, freeze_authority) =
-            array_refs![src, 36, 8, 1, 1, 36];
-        let mint_authority = unpack_coption_key(mint_authority)?;
-        let supply = u64::from_le_bytes(*supply);
-        let decimals = decimals[0];
-        let is_initialized = match is_initialized {
-            [0] => false,
-            [1] => true,
-            _ => return Err(ProgramError::InvalidAccountData),
-        };
-        let freeze_authority = unpack_coption_key(freeze_authority)?;
-        Ok(Mint {
-            mint_authority,
-            supply,
-            decimals,
-            is_initialized,
-            freeze_authority,
-        })
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 82];
-        let (
-            mint_authority_dst,
-            supply_dst,
-            decimals_dst,
-            is_initialized_dst,
-            freeze_authority_dst,
-        ) = mut_array_refs![dst, 36, 8, 1, 1, 36];
-        let &Mint {
-            ref mint_authority,
-            supply,
-            decimals,
-            is_initialized,
-            ref freeze_authority,
-        } = self;
-        pack_coption_key(mint_authority, mint_authority_dst);
-        *supply_dst = supply.to_le_bytes();
-        decimals_dst[0] = decimals;
-        is_initialized_dst[0] = is_initialized as u8;
-        pack_coption_key(freeze_authority, freeze_authority_dst);
-    }
-}
-
-/// Account data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Account {
-    /// The mint associated with this account
-    pub mint: Pubkey,
-    /// The owner of this account.
-    pub owner: Pubkey,
-    /// The amount of tokens this account holds.
-    pub amount: u64,
-    /// If `delegate` is `Some` then `delegated_amount` represents
-    /// the amount authorized by the delegate
-    pub delegate: COption<Pubkey>,
-    /// The account's state
-    pub state: AccountState,
-    /// If is_native.is_some, this is a native token, and the value logs the
-    /// rent-exempt reserve. An Account is required to be rent-exempt, so
-    /// the value is used by the Processor to ensure that wrapped SOL
-    /// accounts do not drop below this threshold.
-    pub is_native: COption<u64>,
-    /// The amount delegated
-    pub delegated_amount: u64,
-    /// Optional authority to close the account.
-    pub close_authority: COption<Pubkey>,
-}
-impl Account {
-    /// Checks if account is frozen
-    pub fn is_frozen(&self) -> bool {
-        self.state == AccountState::Frozen
-    }
-    /// Checks if account is native
-    pub fn is_native(&self) -> bool {
-        self.is_native.is_some()
-    }
-    /// Checks if a token Account's owner is the system_program or the
-    /// incinerator
-    pub fn is_owned_by_system_program_or_incinerator(&self) -> bool {
-        solana_program::system_program::check_id(&self.owner)
-            || solana_program::incinerator::check_id(&self.owner)
-    }
-}
-impl Sealed for Account {}
-impl IsInitialized for Account {
-    fn is_initialized(&self) -> bool {
-        self.state != AccountState::Uninitialized
-    }
-}
-impl Pack for Account {
-    const LEN: usize = 165;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 165];
-        let (mint, owner, amount, delegate, state, is_native, delegated_amount, close_authority) =
-            array_refs![src, 32, 32, 8, 36, 1, 12, 8, 36];
-        Ok(Account {
-            mint: Pubkey::new_from_array(*mint),
-            owner: Pubkey::new_from_array(*owner),
-            amount: u64::from_le_bytes(*amount),
-            delegate: unpack_coption_key(delegate)?,
-            state: AccountState::try_from_primitive(state[0])
-                .or(Err(ProgramError::InvalidAccountData))?,
-            is_native: unpack_coption_u64(is_native)?,
-            delegated_amount: u64::from_le_bytes(*delegated_amount),
-            close_authority: unpack_coption_key(close_authority)?,
-        })
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 165];
-        let (
-            mint_dst,
-            owner_dst,
-            amount_dst,
-            delegate_dst,
-            state_dst,
-            is_native_dst,
-            delegated_amount_dst,
-            close_authority_dst,
-        ) = mut_array_refs![dst, 32, 32, 8, 36, 1, 12, 8, 36];
-        let &Account {
-            ref mint,
-            ref owner,
-            amount,
-            ref delegate,
-            state,
-            ref is_native,
-            delegated_amount,
-            ref close_authority,
-        } = self;
-        mint_dst.copy_from_slice(mint.as_ref());
-        owner_dst.copy_from_slice(owner.as_ref());
-        *amount_dst = amount.to_le_bytes();
-        pack_coption_key(delegate, delegate_dst);
-        state_dst[0] = state as u8;
-        pack_coption_u64(is_native, is_native_dst);
-        *delegated_amount_dst = delegated_amount.to_le_bytes();
-        pack_coption_key(close_authority, close_authority_dst);
-    }
-}
-
-/// Account state.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, TryFromPrimitive)]
-pub enum AccountState {
-    /// Account is not yet initialized
-    #[default]
-    Uninitialized,
-    /// Account is initialized; the account owner and/or delegate may perform
-    /// permitted operations on this account
-    Initialized,
-    /// Account has been frozen by the mint freeze authority. Neither the
-    /// account owner nor the delegate are able to perform operations on
-    /// this account.
-    Frozen,
-}
-
-/// Multisignature data.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Multisig {
-    /// Number of signers required
-    pub m: u8,
-    /// Number of valid signers
-    pub n: u8,
-    /// Is `true` if this structure has been initialized
-    pub is_initialized: bool,
-    /// Signer public keys
-    pub signers: [Pubkey; MAX_SIGNERS],
-}
-impl Sealed for Multisig {}
-impl IsInitialized for Multisig {
-    fn is_initialized(&self) -> bool {
-        self.is_initialized
-    }
-}
-impl Pack for Multisig {
-    const LEN: usize = 355;
-    fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
-        let src = array_ref![src, 0, 355];
-        #[allow(clippy::ptr_offset_with_cast)]
-        let (m, n, is_initialized, signers_flat) = array_refs![src, 1, 1, 1, 32 * MAX_SIGNERS];
-        let mut result = Multisig {
-            m: m[0],
-            n: n[0],
-            is_initialized: match is_initialized {
-                [0] => false,
-                [1] => true,
-                _ => return Err(ProgramError::InvalidAccountData),
-            },
-            signers: [Pubkey::new_from_array([0u8; 32]); MAX_SIGNERS],
-        };
-        for (src, dst) in signers_flat.chunks(32).zip(result.signers.iter_mut()) {
-            *dst = Pubkey::try_from(src).map_err(|_| ProgramError::InvalidAccountData)?;
-        }
-        Ok(result)
-    }
-    fn pack_into_slice(&self, dst: &mut [u8]) {
-        let dst = array_mut_ref![dst, 0, 355];
-        #[allow(clippy::ptr_offset_with_cast)]
-        let (m, n, is_initialized, signers_flat) = mut_array_refs![dst, 1, 1, 1, 32 * MAX_SIGNERS];
-        *m = [self.m];
-        *n = [self.n];
-        *is_initialized = [self.is_initialized as u8];
-        for (i, src) in self.signers.iter().enumerate() {
-            let dst_array = array_mut_ref![signers_flat, 32 * i, 32];
-            dst_array.copy_from_slice(src.as_ref());
-        }
-    }
-}
-
-// Helpers
-fn pack_coption_key(src: &COption<Pubkey>, dst: &mut [u8; 36]) {
-    let (tag, body) = mut_array_refs![dst, 4, 32];
-    match src {
-        COption::Some(key) => {
-            *tag = [1, 0, 0, 0];
-            body.copy_from_slice(key.as_ref());
-        }
-        COption::None => {
-            *tag = [0; 4];
-        }
-    }
-}
-fn unpack_coption_key(src: &[u8; 36]) -> Result<COption<Pubkey>, ProgramError> {
-    let (tag, body) = array_refs![src, 4, 32];
-    match *tag {
-        [0, 0, 0, 0] => Ok(COption::None),
-        [1, 0, 0, 0] => Ok(COption::Some(Pubkey::new_from_array(*body))),
-        _ => Err(ProgramError::InvalidAccountData),
-    }
-}
-fn pack_coption_u64(src: &COption<u64>, dst: &mut [u8; 12]) {
-    let (tag, body) = mut_array_refs![dst, 4, 8];
-    match src {
-        COption::Some(amount) => {
-            *tag = [1, 0, 0, 0];
-            *body = amount.to_le_bytes();
-        }
-        COption::None => {
-            *tag = [0; 4];
-        }
-    }
-}
-fn unpack_coption_u64(src: &[u8; 12]) -> Result<COption<u64>, ProgramError> {
-    let (tag, body) = array_refs![src, 4, 8];
-    match *tag {
-        [0, 0, 0, 0] => Ok(COption::None),
-        [1, 0, 0, 0] => Ok(COption::Some(u64::from_le_bytes(*body))),
-        _ => Err(ProgramError::InvalidAccountData),
-    }
-}
-
-const SPL_TOKEN_ACCOUNT_MINT_OFFSET: usize = 0;
-const SPL_TOKEN_ACCOUNT_OWNER_OFFSET: usize = 32;
-
-/// A trait for token Account structs to enable efficiently unpacking various
-/// fields without unpacking the complete state.
-pub trait GenericTokenAccount {
-    /// Check if the account data is a valid token account
-    fn valid_account_data(account_data: &[u8]) -> bool;
-
-    /// Call after account length has already been verified to unpack the
-    /// account owner
-    fn unpack_account_owner_unchecked(account_data: &[u8]) -> &Pubkey {
-        Self::unpack_pubkey_unchecked(account_data, SPL_TOKEN_ACCOUNT_OWNER_OFFSET)
-    }
-
-    /// Call after account length has already been verified to unpack the
-    /// account mint
-    fn unpack_account_mint_unchecked(account_data: &[u8]) -> &Pubkey {
-        Self::unpack_pubkey_unchecked(account_data, SPL_TOKEN_ACCOUNT_MINT_OFFSET)
-    }
-
-    /// Call after account length has already been verified to unpack a Pubkey
-    /// at the specified offset. Panics if `account_data.len()` is less than
-    /// `PUBKEY_BYTES`
-    fn unpack_pubkey_unchecked(account_data: &[u8], offset: usize) -> &Pubkey {
-        bytemuck::from_bytes(&account_data[offset..offset + PUBKEY_BYTES])
-    }
-
-    /// Unpacks an account's owner from opaque account data.
-    fn unpack_account_owner(account_data: &[u8]) -> Option<&Pubkey> {
-        if Self::valid_account_data(account_data) {
-            Some(Self::unpack_account_owner_unchecked(account_data))
-        } else {
-            None
-        }
-    }
-
-    /// Unpacks an account's mint from opaque account data.
-    fn unpack_account_mint(account_data: &[u8]) -> Option<&Pubkey> {
-        if Self::valid_account_data(account_data) {
-            Some(Self::unpack_account_mint_unchecked(account_data))
-        } else {
-            None
-        }
-    }
-}
-
-/// The offset of state field in Account's C representation
-pub const ACCOUNT_INITIALIZED_INDEX: usize = 108;
-
-/// Check if the account data buffer represents an initialized account.
-/// This is checking the `state` (AccountState) field of an Account object.
-pub fn is_initialized_account(account_data: &[u8]) -> bool {
-    *account_data
-        .get(ACCOUNT_INITIALIZED_INDEX)
-        .unwrap_or(&(AccountState::Uninitialized as u8))
-        != AccountState::Uninitialized as u8
-}
-
-impl GenericTokenAccount for Account {
-    fn valid_account_data(account_data: &[u8]) -> bool {
-        account_data.len() == Account::LEN && is_initialized_account(account_data)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_mint_unpack_from_slice() {
-        let src: [u8; 82] = [0; 82];
-        let mint = Mint::unpack_from_slice(&src).unwrap();
-        assert!(!mint.is_initialized);
-
-        let mut src: [u8; 82] = [0; 82];
-        src[45] = 2;
-        let mint = Mint::unpack_from_slice(&src).unwrap_err();
-        assert_eq!(mint, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_account_state() {
-        let account_state = AccountState::default();
-        assert_eq!(account_state, AccountState::Uninitialized);
-    }
-
-    #[test]
-    fn test_multisig_unpack_from_slice() {
-        let src: [u8; 355] = [0; 355];
-        let multisig = Multisig::unpack_from_slice(&src).unwrap();
-        assert_eq!(multisig.m, 0);
-        assert_eq!(multisig.n, 0);
-        assert!(!multisig.is_initialized);
-
-        let mut src: [u8; 355] = [0; 355];
-        src[0] = 1;
-        src[1] = 1;
-        src[2] = 1;
-        let multisig = Multisig::unpack_from_slice(&src).unwrap();
-        assert_eq!(multisig.m, 1);
-        assert_eq!(multisig.n, 1);
-        assert!(multisig.is_initialized);
-
-        let mut src: [u8; 355] = [0; 355];
-        src[2] = 2;
-        let multisig = Multisig::unpack_from_slice(&src).unwrap_err();
-        assert_eq!(multisig, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_unpack_coption_key() {
-        let src: [u8; 36] = [0; 36];
-        let result = unpack_coption_key(&src).unwrap();
-        assert_eq!(result, COption::None);
-
-        let mut src: [u8; 36] = [0; 36];
-        src[1] = 1;
-        let result = unpack_coption_key(&src).unwrap_err();
-        assert_eq!(result, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_unpack_coption_u64() {
-        let src: [u8; 12] = [0; 12];
-        let result = unpack_coption_u64(&src).unwrap();
-        assert_eq!(result, COption::None);
-
-        let mut src: [u8; 12] = [0; 12];
-        src[0] = 1;
-        let result = unpack_coption_u64(&src).unwrap();
-        assert_eq!(result, COption::Some(0));
-
-        let mut src: [u8; 12] = [0; 12];
-        src[1] = 1;
-        let result = unpack_coption_u64(&src).unwrap_err();
-        assert_eq!(result, ProgramError::InvalidAccountData);
-    }
-
-    #[test]
-    fn test_unpack_token_owner() {
-        // Account data length < Account::LEN, unpack will not return a key
-        let src: [u8; 12] = [0; 12];
-        let result = Account::unpack_account_owner(&src);
-        assert_eq!(result, Option::None);
-
-        // The right account data size and initialized, unpack will return some key
-        let mut src: [u8; Account::LEN] = [0; Account::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_some());
-
-        // The right account data size and frozen, unpack will return some key
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Frozen as u8;
-        let result = Account::unpack_account_owner(&src);
-        assert!(result.is_some());
-
-        // The right account data size and uninitialized, unpack will return None
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Uninitialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-
-        // Account data length > account data size, unpack will not return a key
-        let src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        let result = Account::unpack_account_owner(&src);
-        assert_eq!(result, Option::None);
-    }
-
-    #[test]
-    fn test_unpack_token_mint() {
-        // Account data length < Account::LEN, unpack will not return a key
-        let src: [u8; 12] = [0; 12];
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-
-        // The right account data size and initialized, unpack will return some key
-        let mut src: [u8; Account::LEN] = [0; Account::LEN];
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Initialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_some());
-
-        // The right account data size and frozen, unpack will return some key
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Frozen as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert!(result.is_some());
-
-        // The right account data size and uninitialized, unpack will return None
-        src[ACCOUNT_INITIALIZED_INDEX] = AccountState::Uninitialized as u8;
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-
-        // Account data length > account data size, unpack will not return a key
-        let src: [u8; Account::LEN + 5] = [0; Account::LEN + 5];
-        let result = Account::unpack_account_mint(&src);
-        assert_eq!(result, Option::None);
-    }
-}
diff --git a/token/program/tests/action.rs b/token/program/tests/action.rs
deleted file mode 100644
index 0a67538b0ff..00000000000
--- a/token/program/tests/action.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-use {
-    solana_program_test::BanksClient,
-    solana_sdk::{
-        hash::Hash,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-        transport::TransportError,
-    },
-    spl_token::{
-        id, instruction,
-        state::{Account, Mint},
-    },
-};
-
-pub async fn create_mint(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    pool_mint: &Keypair,
-    manager: &Pubkey,
-    decimals: u8,
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let mint_rent = rent.minimum_balance(Mint::LEN);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &pool_mint.pubkey(),
-                mint_rent,
-                Mint::LEN as u64,
-                &id(),
-            ),
-            instruction::initialize_mint(&id(), &pool_mint.pubkey(), manager, None, decimals)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, pool_mint],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn create_account(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    account: &Keypair,
-    pool_mint: &Pubkey,
-    owner: &Pubkey,
-) -> Result<(), TransportError> {
-    let rent = banks_client.get_rent().await.unwrap();
-    let account_rent = rent.minimum_balance(Account::LEN);
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &payer.pubkey(),
-                &account.pubkey(),
-                account_rent,
-                Account::LEN as u64,
-                &id(),
-            ),
-            instruction::initialize_account(&id(), &account.pubkey(), pool_mint, owner).unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn mint_to(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    mint: &Pubkey,
-    account: &Pubkey,
-    mint_authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::mint_to(&id(), mint, account, &mint_authority.pubkey(), &[], amount)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, mint_authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn transfer(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    source: &Pubkey,
-    destination: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::transfer(&id(), source, destination, &authority.pubkey(), &[], amount)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
-
-pub async fn burn(
-    banks_client: &mut BanksClient,
-    payer: &Keypair,
-    recent_blockhash: Hash,
-    mint: &Pubkey,
-    account: &Pubkey,
-    authority: &Keypair,
-    amount: u64,
-) -> Result<(), TransportError> {
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::burn(&id(), account, mint, &authority.pubkey(), &[], amount).unwrap()],
-        Some(&payer.pubkey()),
-        &[payer, authority],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await?;
-    Ok(())
-}
diff --git a/token/program/tests/assert_instruction_count.rs b/token/program/tests/assert_instruction_count.rs
deleted file mode 100644
index a6df337092c..00000000000
--- a/token/program/tests/assert_instruction_count.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-mod action;
-use {
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-        system_instruction,
-        transaction::Transaction,
-    },
-    spl_token::{
-        id, instruction,
-        processor::Processor,
-        state::{Account, Mint},
-    },
-};
-
-const TRANSFER_AMOUNT: u64 = 1_000_000_000_000_000;
-
-#[tokio::test]
-async fn initialize_mint() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(5_000); // last known 2252
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner_key = Pubkey::new_unique();
-    let mint = Keypair::new();
-    let decimals = 9;
-
-    let rent = banks_client.get_rent().await.unwrap();
-    let mint_rent = rent.minimum_balance(Mint::LEN);
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &mint.pubkey(),
-            mint_rent,
-            Mint::LEN as u64,
-            &id(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &mint],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            instruction::initialize_mint(&id(), &mint.pubkey(), &owner_key, None, decimals)
-                .unwrap(),
-        ],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn initialize_account() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(6_000); // last known 3284
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    let rent = banks_client.get_rent().await.unwrap();
-    let account_rent = rent.minimum_balance(Account::LEN);
-    let transaction = Transaction::new_signed_with_payer(
-        &[system_instruction::create_account(
-            &payer.pubkey(),
-            &account.pubkey(),
-            account_rent,
-            Account::LEN as u64,
-            &id(),
-        )],
-        Some(&payer.pubkey()),
-        &[&payer, &account],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::initialize_account(
-            &id(),
-            &account.pubkey(),
-            &mint.pubkey(),
-            &owner.pubkey(),
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn mint_to() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(6_000); // last known 2668
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::mint_to(
-            &id(),
-            &mint.pubkey(),
-            &account.pubkey(),
-            &owner.pubkey(),
-            &[],
-            TRANSFER_AMOUNT,
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer, &owner],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
-
-#[tokio::test]
-async fn transfer() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(7_000); // last known 2972
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let source = Keypair::new();
-    let destination = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &destination,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    action::mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &source.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    action::transfer(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &source.pubkey(),
-        &destination.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn burn() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(6_000); // last known 2655
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    action::mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &account.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-
-    action::burn(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint.pubkey(),
-        &account.pubkey(),
-        &owner,
-        TRANSFER_AMOUNT,
-    )
-    .await
-    .unwrap();
-}
-
-#[tokio::test]
-async fn close_account() {
-    let mut pt = ProgramTest::new("spl_token", id(), processor!(Processor::process));
-    pt.set_compute_max_units(6_000); // last known 1783
-    let (mut banks_client, payer, recent_blockhash) = pt.start().await;
-
-    let owner = Keypair::new();
-    let mint = Keypair::new();
-    let account = Keypair::new();
-    let decimals = 9;
-
-    action::create_mint(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &mint,
-        &owner.pubkey(),
-        decimals,
-    )
-    .await
-    .unwrap();
-    action::create_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &account,
-        &mint.pubkey(),
-        &owner.pubkey(),
-    )
-    .await
-    .unwrap();
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[instruction::close_account(
-            &id(),
-            &account.pubkey(),
-            &owner.pubkey(),
-            &owner.pubkey(),
-            &[],
-        )
-        .unwrap()],
-        Some(&payer.pubkey()),
-        &[&payer, &owner],
-        recent_blockhash,
-    );
-    banks_client.process_transaction(transaction).await.unwrap();
-}
diff --git a/token/program/tests/close_account.rs b/token/program/tests/close_account.rs
deleted file mode 100644
index 8425fe206bf..00000000000
--- a/token/program/tests/close_account.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio, ProgramTest, ProgramTestContext},
-    solana_sdk::{
-        instruction::InstructionError,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_token::{
-        instruction,
-        processor::Processor,
-        state::{Account, Mint},
-    },
-};
-
-async fn setup_mint_and_account(
-    context: &mut ProgramTestContext,
-    mint: &Keypair,
-    token_account: &Keypair,
-    owner: &Pubkey,
-    token_program_id: &Pubkey,
-) {
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let mint_authority_pubkey = Pubkey::new_unique();
-
-    let space = Mint::LEN;
-    let tx = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &mint.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                token_program_id,
-            ),
-            instruction::initialize_mint(
-                token_program_id,
-                &mint.pubkey(),
-                &mint_authority_pubkey,
-                None,
-                9,
-            )
-            .unwrap(),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, mint],
-        context.last_blockhash,
-    );
-    context.banks_client.process_transaction(tx).await.unwrap();
-    let space = Account::LEN;
-    let tx = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &token_account.pubkey(),
-                rent.minimum_balance(space),
-                space as u64,
-                token_program_id,
-            ),
-            instruction::initialize_account(
-                token_program_id,
-                &token_account.pubkey(),
-                &mint.pubkey(),
-                owner,
-            )
-            .unwrap(),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, token_account],
-        context.last_blockhash,
-    );
-    context.banks_client.process_transaction(tx).await.unwrap();
-}
-
-#[tokio::test]
-async fn success_init_after_close_account() {
-    let program_test =
-        ProgramTest::new("spl_token", spl_token::id(), processor!(Processor::process));
-    let mut context = program_test.start_with_context().await;
-    let mint = Keypair::new();
-    let token_account = Keypair::new();
-    let owner = Keypair::new();
-    let token_program_id = spl_token::id();
-    setup_mint_and_account(
-        &mut context,
-        &mint,
-        &token_account,
-        &owner.pubkey(),
-        &token_program_id,
-    )
-    .await;
-
-    let destination = Pubkey::new_unique();
-    let tx = Transaction::new_signed_with_payer(
-        &[
-            instruction::close_account(
-                &token_program_id,
-                &token_account.pubkey(),
-                &destination,
-                &owner.pubkey(),
-                &[],
-            )
-            .unwrap(),
-            system_instruction::create_account(
-                &context.payer.pubkey(),
-                &token_account.pubkey(),
-                1_000_000_000,
-                Account::LEN as u64,
-                &token_program_id,
-            ),
-            instruction::initialize_account(
-                &token_program_id,
-                &token_account.pubkey(),
-                &mint.pubkey(),
-                &owner.pubkey(),
-            )
-            .unwrap(),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &owner, &token_account],
-        context.last_blockhash,
-    );
-    context.banks_client.process_transaction(tx).await.unwrap();
-    let destination = context
-        .banks_client
-        .get_account(destination)
-        .await
-        .unwrap()
-        .unwrap();
-    assert!(destination.lamports > 0);
-}
-
-#[tokio::test]
-async fn fail_init_after_close_account() {
-    let program_test =
-        ProgramTest::new("spl_token", spl_token::id(), processor!(Processor::process));
-    let mut context = program_test.start_with_context().await;
-    let mint = Keypair::new();
-    let token_account = Keypair::new();
-    let owner = Keypair::new();
-    let token_program_id = spl_token::id();
-    setup_mint_and_account(
-        &mut context,
-        &mint,
-        &token_account,
-        &owner.pubkey(),
-        &token_program_id,
-    )
-    .await;
-
-    let destination = Pubkey::new_unique();
-    let tx = Transaction::new_signed_with_payer(
-        &[
-            instruction::close_account(
-                &token_program_id,
-                &token_account.pubkey(),
-                &destination,
-                &owner.pubkey(),
-                &[],
-            )
-            .unwrap(),
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &token_account.pubkey(),
-                1_000_000_000,
-            ),
-            instruction::initialize_account(
-                &token_program_id,
-                &token_account.pubkey(),
-                &mint.pubkey(),
-                &owner.pubkey(),
-            )
-            .unwrap(),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &owner],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(tx)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(2, InstructionError::InvalidAccountData)
-    );
-    assert!(context
-        .banks_client
-        .get_account(destination)
-        .await
-        .unwrap()
-        .is_none());
-}
diff --git a/token/transfer-hook/cli/Cargo.toml b/token/transfer-hook/cli/Cargo.toml
deleted file mode 100644
index ecdc2fec1dc..00000000000
--- a/token/transfer-hook/cli/Cargo.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-[package]
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-description = "SPL Transfer Hook Command-line Utility"
-edition = "2021"
-homepage = "https://spl.solana.com/token"
-license = "Apache-2.0"
-name = "spl-transfer-hook-cli"
-repository = "https://github.com/solana-labs/solana-program-library"
-version = "0.2.0"
-
-[dependencies]
-clap = { version = "3", features = ["cargo"] }
-futures-util = "0.3.30"
-solana-clap-v3-utils = ">=1.18.11,<=2"
-solana-cli-config = ">=1.18.11,<=2"
-solana-client = ">=1.18.11,<=2"
-solana-logger = ">=1.18.11,<=2"
-solana-remote-wallet = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-spl-transfer-hook-interface = { version = "0.6.3", path = "../interface" }
-spl-tlv-account-resolution = { version = "0.6.3" , path = "../../../libraries/tlv-account-resolution", features = ["serde-traits"] }
-strum = "0.26"
-strum_macros = "0.26"
-tokio = { version = "1", features = ["full"] }
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.117"
-serde_yaml = "0.9.34"
-
-[dev-dependencies]
-solana-test-validator = ">=1.18.11,<=2"
-spl-token-2022 = { version = "3.0.2", path = "../../program-2022", features = ["no-entrypoint"] }
-spl-token-client = { version = "0.10.0", path = "../../client" }
-spl-transfer-hook-example = { version = "0.6.0", path = "../example" }
-
-[[bin]]
-name = "spl-transfer-hook"
-path = "src/main.rs"
diff --git a/token/transfer-hook/cli/src/main.rs b/token/transfer-hook/cli/src/main.rs
deleted file mode 100644
index 67721380aa8..00000000000
--- a/token/transfer-hook/cli/src/main.rs
+++ /dev/null
@@ -1,654 +0,0 @@
-pub mod meta;
-
-use {
-    crate::meta::parse_transfer_hook_account_arg,
-    clap::{crate_description, crate_name, crate_version, Arg, Command},
-    solana_clap_v3_utils::{
-        input_parsers::{
-            parse_url_or_moniker,
-            signer::{SignerSource, SignerSourceParserBuilder},
-        },
-        input_validators::normalize_to_url_if_moniker,
-        keypair::{pubkey_from_source, DefaultSigner},
-    },
-    solana_client::nonblocking::rpc_client::RpcClient,
-    solana_remote_wallet::remote_wallet::RemoteWalletManager,
-    solana_sdk::{
-        commitment_config::CommitmentConfig,
-        instruction::Instruction,
-        pubkey::Pubkey,
-        signature::{Signature, Signer},
-        system_instruction, system_program,
-        transaction::Transaction,
-    },
-    spl_tlv_account_resolution::{account::ExtraAccountMeta, state::ExtraAccountMetaList},
-    spl_transfer_hook_interface::{
-        get_extra_account_metas_address,
-        instruction::{initialize_extra_account_meta_list, update_extra_account_meta_list},
-    },
-    std::{process::exit, rc::Rc},
-};
-
-// Helper function to calculate the required lamports for rent
-async fn calculate_rent_lamports(
-    rpc_client: &RpcClient,
-    account_address: &Pubkey,
-    account_size: usize,
-) -> Result<u64, Box<dyn std::error::Error>> {
-    let required_lamports = rpc_client
-        .get_minimum_balance_for_rent_exemption(account_size)
-        .await
-        .map_err(|err| format!("error: unable to fetch rent-exemption: {err}"))?;
-    let account_info = rpc_client.get_account(account_address).await;
-    let current_lamports = account_info.map(|a| a.lamports).unwrap_or(0);
-    Ok(required_lamports.saturating_sub(current_lamports))
-}
-
-async fn build_transaction_with_rent_transfer(
-    rpc_client: &RpcClient,
-    payer: &dyn Signer,
-    extra_account_metas_address: &Pubkey,
-    extra_account_metas: &[ExtraAccountMeta],
-    instruction: Instruction,
-) -> Result<Transaction, Box<dyn std::error::Error>> {
-    let account_size = ExtraAccountMetaList::size_of(extra_account_metas.len())?;
-    let transfer_lamports =
-        calculate_rent_lamports(rpc_client, extra_account_metas_address, account_size).await?;
-
-    let mut instructions = vec![];
-    if transfer_lamports > 0 {
-        instructions.push(system_instruction::transfer(
-            &payer.pubkey(),
-            extra_account_metas_address,
-            transfer_lamports,
-        ));
-    }
-
-    instructions.push(instruction);
-
-    let transaction = Transaction::new_with_payer(&instructions, Some(&payer.pubkey()));
-
-    Ok(transaction)
-}
-
-async fn sign_and_send_transaction(
-    transaction: &mut Transaction,
-    rpc_client: &RpcClient,
-    payer: &dyn Signer,
-    mint_authority: &dyn Signer,
-) -> Result<Signature, Box<dyn std::error::Error>> {
-    let mut signers = vec![payer];
-    if payer.pubkey() != mint_authority.pubkey() {
-        signers.push(mint_authority);
-    }
-
-    let blockhash = rpc_client
-        .get_latest_blockhash()
-        .await
-        .map_err(|err| format!("error: unable to get latest blockhash: {err}"))?;
-
-    transaction
-        .try_sign(&signers, blockhash)
-        .map_err(|err| format!("error: failed to sign transaction: {err}"))?;
-
-    rpc_client
-        .send_and_confirm_transaction_with_spinner(transaction)
-        .await
-        .map_err(|err| format!("error: send transaction: {err}").into())
-}
-
-struct Config {
-    commitment_config: CommitmentConfig,
-    default_signer: Box<dyn Signer>,
-    json_rpc_url: String,
-    verbose: bool,
-}
-
-async fn process_create_extra_account_metas(
-    rpc_client: &RpcClient,
-    program_id: &Pubkey,
-    token: &Pubkey,
-    extra_account_metas: Vec<ExtraAccountMeta>,
-    mint_authority: &dyn Signer,
-    payer: &dyn Signer,
-) -> Result<Signature, Box<dyn std::error::Error>> {
-    let extra_account_metas_address = get_extra_account_metas_address(token, program_id);
-
-    // Check if the extra meta account has already been initialized
-    let extra_account_metas_account = rpc_client.get_account(&extra_account_metas_address).await;
-    if let Ok(account) = &extra_account_metas_account {
-        if account.owner != system_program::id() {
-            return Err(format!("error: extra account metas for mint {token} and program {program_id} already exists").into());
-        }
-    }
-
-    let instruction = initialize_extra_account_meta_list(
-        program_id,
-        &extra_account_metas_address,
-        token,
-        &mint_authority.pubkey(),
-        &extra_account_metas,
-    );
-
-    let mut transaction = build_transaction_with_rent_transfer(
-        rpc_client,
-        payer,
-        &extra_account_metas_address,
-        &extra_account_metas,
-        instruction,
-    )
-    .await?;
-
-    sign_and_send_transaction(&mut transaction, rpc_client, payer, mint_authority).await
-}
-
-async fn process_update_extra_account_metas(
-    rpc_client: &RpcClient,
-    program_id: &Pubkey,
-    token: &Pubkey,
-    extra_account_metas: Vec<ExtraAccountMeta>,
-    mint_authority: &dyn Signer,
-    payer: &dyn Signer,
-) -> Result<Signature, Box<dyn std::error::Error>> {
-    let extra_account_metas_address = get_extra_account_metas_address(token, program_id);
-
-    // Check if the extra meta account has been initialized first
-    let extra_account_metas_account = rpc_client.get_account(&extra_account_metas_address).await;
-    if extra_account_metas_account.is_err() {
-        return Err(format!(
-            "error: extra account metas for mint {token} and program {program_id} does not exist"
-        )
-        .into());
-    }
-
-    let instruction = update_extra_account_meta_list(
-        program_id,
-        &extra_account_metas_address,
-        token,
-        &mint_authority.pubkey(),
-        &extra_account_metas,
-    );
-
-    let mut transaction = build_transaction_with_rent_transfer(
-        rpc_client,
-        payer,
-        &extra_account_metas_address,
-        &extra_account_metas,
-        instruction,
-    )
-    .await?;
-
-    sign_and_send_transaction(&mut transaction, rpc_client, payer, mint_authority).await
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let app_matches = Command::new(crate_name!())
-        .about(crate_description!())
-        .version(crate_version!())
-        .subcommand_required(true)
-        .arg_required_else_help(true)
-        .arg({
-            let arg = Arg::new("config_file")
-                .short('C')
-                .long("config")
-                .value_name("PATH")
-                .takes_value(true)
-                .global(true)
-                .help("Configuration file to use");
-            if let Some(ref config_file) = *solana_cli_config::CONFIG_FILE {
-                arg.default_value(config_file)
-            } else {
-                arg
-            }
-        })
-        .arg(
-            Arg::new("fee_payer")
-                .long("fee-payer")
-                .value_name("KEYPAIR")
-                .value_parser(SignerSourceParserBuilder::default().allow_all().build())
-                .takes_value(true)
-                .global(true)
-                .help("Filepath or URL to a keypair to pay transaction fee [default: client keypair]"),
-        )
-        .arg(
-            Arg::new("verbose")
-                .long("verbose")
-                .short('v')
-                .takes_value(false)
-                .global(true)
-                .help("Show additional information"),
-        )
-        .arg(
-            Arg::new("json_rpc_url")
-                .short('u')
-                .long("url")
-                .value_name("URL")
-                .takes_value(true)
-                .global(true)
-                .value_parser(parse_url_or_moniker)
-                .help("JSON RPC URL for the cluster [default: value from configuration file]"),
-        )
-        .subcommand(
-            Command::new("create-extra-metas")
-                .about("Create the extra account metas account for a transfer hook program")
-                .arg(
-                    Arg::with_name("program_id")
-                        .value_parser(SignerSourceParserBuilder::default().allow_pubkey().allow_file_path().build())
-                        .value_name("TRANSFER_HOOK_PROGRAM")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The transfer hook program id"),
-                )
-                .arg(
-                    Arg::with_name("token")
-                        .value_parser(SignerSourceParserBuilder::default().allow_pubkey().allow_file_path().build())
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("The token mint address for the transfer hook"),
-                )
-                .arg(
-                    Arg::with_name("transfer_hook_accounts")
-                        .value_parser(parse_transfer_hook_account_arg)
-                        .value_name("TRANSFER_HOOK_ACCOUNTS")
-                        .takes_value(true)
-                        .multiple(true)
-                        .min_values(0)
-                        .index(3)
-                        .help(r#"Additional account(s) required for a transfer hook and their respective configurations, whether they are a fixed address or PDA.
-
-Additional accounts with known fixed addresses can be passed at the command line in the format "<PUBKEY>:<ROLE>". The role must be "readonly", "writable". "readonlySigner", or "writableSigner".
-
-Additional accounts requiring seed configurations can be defined in a configuration file using either JSON or YAML. The format is as follows:
-
-```json
-{
-    "extraMetas": [
-        {
-            "pubkey": "39UhV...",
-            "role": "readonlySigner"
-        },
-        {
-            "seeds": [
-                {
-                    "literal": {
-                        "bytes": [1, 2, 3, 4, 5, 6]
-                    }
-                },
-                {
-                    "accountKey": {
-                        "index": 0
-                    }
-                }
-            ],
-            "role": "writable"
-        }
-    ]
-}
-```
-
-```yaml
-extraMetas:
-  - pubkey: "39UhV..."
-      role: "readonlySigner"
-  - seeds:
-      - literal:
-          bytes: [1, 2, 3, 4, 5, 6]
-      - accountKey:
-          index: 0
-      role: "writable"
-```
-"#)
-                )
-                .arg(
-                    Arg::new("mint_authority")
-                        .long("mint-authority")
-                        .value_name("KEYPAIR")
-                        .value_parser(SignerSourceParserBuilder::default().allow_all().build())
-                        .takes_value(true)
-                        .global(true)
-                        .help("Filepath or URL to mint-authority keypair [default: client keypair]"),
-                )
-        )
-        .subcommand(
-            Command::new("update-extra-metas")
-                .about("Update the extra account metas account for a transfer hook program")
-                .arg(
-                    Arg::with_name("program_id")
-                        .value_parser(SignerSourceParserBuilder::default().allow_pubkey().allow_file_path().build())
-                        .value_name("TRANSFER_HOOK_PROGRAM")
-                        .takes_value(true)
-                        .index(1)
-                        .required(true)
-                        .help("The transfer hook program id"),
-                )
-                .arg(
-                    Arg::with_name("token")
-                        .value_parser(SignerSourceParserBuilder::default().allow_pubkey().allow_file_path().build())
-                        .value_name("TOKEN_MINT_ADDRESS")
-                        .takes_value(true)
-                        .index(2)
-                        .required(true)
-                        .help("The token mint address for the transfer hook"),
-                )
-                .arg(
-                    Arg::with_name("transfer_hook_accounts")
-                        .value_parser(parse_transfer_hook_account_arg)
-                        .value_name("TRANSFER_HOOK_ACCOUNTS")
-                        .takes_value(true)
-                        .multiple(true)
-                        .min_values(0)
-                        .index(3)
-                        .help(r#"Additional account(s) required for a transfer hook and their respective configurations, whether they are a fixed address or PDA.
-
-Additional accounts with known fixed addresses can be passed at the command line in the format "<PUBKEY>:<ROLE>". The role must be "readonly", "writable". "readonlySigner", or "writableSigner".
-
-Additional accounts requiring seed configurations can be defined in a configuration file using either JSON or YAML. The format is as follows:
-
-```json
-{
-    "extraMetas": [
-        {
-            "pubkey": "39UhV...",
-            "role": "readonlySigner"
-        },
-        {
-            "seeds": [
-                {
-                    "literal": {
-                        "bytes": [1, 2, 3, 4, 5, 6]
-                    }
-                },
-                {
-                    "accountKey": {
-                        "index": 0
-                    }
-                }
-            ],
-            "role": "writable"
-        }
-    ]
-}
-```
-
-```yaml
-extraMetas:
-  - pubkey: "39UhV..."
-      role: "readonlySigner"
-  - seeds:
-      - literal:
-          bytes: [1, 2, 3, 4, 5, 6]
-      - accountKey:
-          index: 0
-      role: "writable"
-```
-"#)
-                )
-                .arg(
-                    Arg::new("mint_authority")
-                        .long("mint-authority")
-                        .value_name("KEYPAIR")
-                        .value_parser(SignerSourceParserBuilder::default().allow_all().build())
-                        .takes_value(true)
-                        .global(true)
-                        .help("Filepath or URL to mint-authority keypair [default: client keypair]"),
-                )
-        ).get_matches();
-
-    let (command, matches) = app_matches.subcommand().unwrap();
-    let mut wallet_manager: Option<Rc<RemoteWalletManager>> = None;
-
-    let cli_config = if let Some(config_file) = matches.value_of("config_file") {
-        solana_cli_config::Config::load(config_file).unwrap_or_default()
-    } else {
-        solana_cli_config::Config::default()
-    };
-
-    let config = {
-        let default_signer = DefaultSigner::new(
-            "fee_payer",
-            matches
-                .value_of("fee_payer")
-                .map(|s| s.to_string())
-                .unwrap_or_else(|| cli_config.keypair_path.clone()),
-        );
-
-        let json_rpc_url = normalize_to_url_if_moniker(
-            matches
-                .value_of("json_rpc_url")
-                .unwrap_or(&cli_config.json_rpc_url),
-        );
-
-        Config {
-            commitment_config: CommitmentConfig::confirmed(),
-            default_signer: default_signer
-                .signer_from_path(matches, &mut wallet_manager)
-                .unwrap_or_else(|err| {
-                    eprintln!("error: {err}");
-                    exit(1);
-                }),
-            json_rpc_url,
-            verbose: matches.is_present("verbose"),
-        }
-    };
-    solana_logger::setup_with_default("solana=info");
-
-    if config.verbose {
-        println!("JSON RPC URL: {}", config.json_rpc_url);
-    }
-    let rpc_client =
-        RpcClient::new_with_commitment(config.json_rpc_url.clone(), config.commitment_config);
-
-    match (command, matches) {
-        ("create-extra-metas", arg_matches) => {
-            let program_id_source = arg_matches
-                .try_get_one::<SignerSource>("program_id")?
-                .unwrap();
-            let program_id = pubkey_from_source(
-                arg_matches,
-                program_id_source,
-                "program_id",
-                &mut wallet_manager,
-            )
-            .unwrap();
-
-            let token_source = arg_matches.try_get_one::<SignerSource>("token")?.unwrap();
-            let token = pubkey_from_source(arg_matches, token_source, "token", &mut wallet_manager)
-                .unwrap();
-
-            let transfer_hook_accounts = arg_matches
-                .get_many::<Vec<ExtraAccountMeta>>("transfer_hook_accounts")
-                .unwrap_or_default()
-                .flatten()
-                .cloned()
-                .collect();
-            let mint_authority = DefaultSigner::new(
-                "mint_authority",
-                matches
-                    .value_of("mint_authority")
-                    .map(|s| s.to_string())
-                    .unwrap_or_else(|| cli_config.keypair_path.clone()),
-            )
-            .signer_from_path(matches, &mut wallet_manager)
-            .unwrap_or_else(|err| {
-                eprintln!("error: {err}");
-                exit(1);
-            });
-            let signature = process_create_extra_account_metas(
-                &rpc_client,
-                &program_id,
-                &token,
-                transfer_hook_accounts,
-                mint_authority.as_ref(),
-                config.default_signer.as_ref(),
-            )
-            .await
-            .unwrap_or_else(|err| {
-                eprintln!("error: send transaction: {err}");
-                exit(1);
-            });
-            println!("Signature: {signature}");
-        }
-        ("update-extra-metas", arg_matches) => {
-            let program_id_source = arg_matches
-                .try_get_one::<SignerSource>("program_id")?
-                .unwrap();
-            let program_id = pubkey_from_source(
-                arg_matches,
-                program_id_source,
-                "program_id",
-                &mut wallet_manager,
-            )
-            .unwrap();
-
-            let token_source = arg_matches.try_get_one::<SignerSource>("token")?.unwrap();
-            let token = pubkey_from_source(arg_matches, token_source, "token", &mut wallet_manager)
-                .unwrap();
-
-            let transfer_hook_accounts = arg_matches
-                .get_many::<Vec<ExtraAccountMeta>>("transfer_hook_accounts")
-                .unwrap_or_default()
-                .flatten()
-                .cloned()
-                .collect();
-            let mint_authority = DefaultSigner::new(
-                "mint_authority",
-                matches
-                    .value_of("mint_authority")
-                    .map(|s| s.to_string())
-                    .unwrap_or_else(|| cli_config.keypair_path.clone()),
-            )
-            .signer_from_path(matches, &mut wallet_manager)
-            .unwrap_or_else(|err| {
-                eprintln!("error: {err}");
-                exit(1);
-            });
-            let signature = process_update_extra_account_metas(
-                &rpc_client,
-                &program_id,
-                &token,
-                transfer_hook_accounts,
-                mint_authority.as_ref(),
-                config.default_signer.as_ref(),
-            )
-            .await
-            .unwrap_or_else(|err| {
-                eprintln!("error: send transaction: {err}");
-                exit(1);
-            });
-            println!("Signature: {signature}");
-        }
-        _ => unreachable!(),
-    };
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod test {
-    use {
-        super::*,
-        solana_sdk::{
-            account::Account, bpf_loader_upgradeable, instruction::AccountMeta,
-            program_option::COption, signer::keypair::Keypair,
-        },
-        solana_test_validator::{TestValidator, TestValidatorGenesis, UpgradeableProgramInfo},
-        spl_token_2022::{
-            extension::{ExtensionType, StateWithExtensionsMut},
-            state::Mint,
-        },
-        spl_token_client::{
-            client::{ProgramRpcClient, ProgramRpcClientSendTransaction},
-            token::Token,
-        },
-        std::{path::PathBuf, sync::Arc},
-    };
-
-    async fn new_validator_for_test(
-        program_id: Pubkey,
-        mint_authority: &Pubkey,
-        decimals: u8,
-    ) -> (TestValidator, Keypair) {
-        solana_logger::setup();
-        let mut test_validator_genesis = TestValidatorGenesis::default();
-        test_validator_genesis.add_upgradeable_programs_with_path(&[UpgradeableProgramInfo {
-            program_id,
-            loader: bpf_loader_upgradeable::id(),
-            program_path: PathBuf::from("../../../target/deploy/spl_transfer_hook_example.so"),
-            upgrade_authority: Pubkey::new_unique(),
-        }]);
-
-        let mint_size = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-        let mut mint_data = vec![0; mint_size];
-        let mut state =
-            StateWithExtensionsMut::<Mint>::unpack_uninitialized(&mut mint_data).unwrap();
-        let token_amount = 1_000_000_000_000;
-        state.base = Mint {
-            mint_authority: COption::Some(*mint_authority),
-            supply: token_amount,
-            decimals,
-            is_initialized: true,
-            freeze_authority: COption::None,
-        };
-        state.pack_base();
-        test_validator_genesis.add_account(
-            spl_transfer_hook_example::mint::id(),
-            Account {
-                lamports: 1_000_000_000,
-                data: mint_data,
-                owner: spl_token_2022::id(),
-                ..Account::default()
-            }
-            .into(),
-        );
-        test_validator_genesis.start_async().await
-    }
-
-    #[tokio::test]
-    async fn test_create() {
-        let program_id = Pubkey::new_unique();
-
-        let decimals = 2;
-        let mint_authority = Keypair::new();
-        let (test_validator, payer) =
-            new_validator_for_test(program_id, &mint_authority.pubkey(), decimals).await;
-        let payer: Arc<dyn Signer> = Arc::new(payer);
-        let rpc_client = Arc::new(test_validator.get_async_rpc_client());
-        let client = Arc::new(ProgramRpcClient::new(
-            rpc_client.clone(),
-            ProgramRpcClientSendTransaction,
-        ));
-
-        let token = Token::new(
-            client.clone(),
-            &spl_token_2022::id(),
-            &spl_transfer_hook_example::mint::id(),
-            Some(decimals),
-            payer.clone(),
-        );
-
-        let required_address = Pubkey::new_unique();
-        let accounts = vec![AccountMeta::new_readonly(required_address, false)];
-        process_create_extra_account_metas(
-            &rpc_client,
-            &program_id,
-            token.get_address(),
-            accounts.iter().map(|a| a.into()).collect(),
-            &mint_authority,
-            payer.as_ref(),
-        )
-        .await
-        .unwrap();
-
-        let extra_account_metas_address =
-            get_extra_account_metas_address(token.get_address(), &program_id);
-        let account = rpc_client
-            .get_account(&extra_account_metas_address)
-            .await
-            .unwrap();
-        assert_eq!(account.owner, program_id);
-    }
-}
diff --git a/token/transfer-hook/cli/src/meta.rs b/token/transfer-hook/cli/src/meta.rs
deleted file mode 100644
index b72dfa80686..00000000000
--- a/token/transfer-hook/cli/src/meta.rs
+++ /dev/null
@@ -1,322 +0,0 @@
-use {
-    serde::{Deserialize, Serialize},
-    solana_sdk::pubkey::Pubkey,
-    spl_tlv_account_resolution::{account::ExtraAccountMeta, seeds::Seed},
-    std::{path::Path, str::FromStr},
-    strum_macros::{EnumString, IntoStaticStr},
-};
-
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct Access {
-    is_signer: bool,
-    is_writable: bool,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, EnumString, IntoStaticStr, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-#[strum(serialize_all = "camelCase")]
-enum Role {
-    Readonly,
-    Writable,
-    ReadonlySigner,
-    WritableSigner,
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-enum AddressConfig {
-    Pubkey(String),
-    Seeds(Vec<Seed>),
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct Config {
-    #[serde(flatten)]
-    address_config: AddressConfig,
-    role: Role,
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct ConfigFile {
-    extra_metas: Vec<Config>,
-}
-
-impl From<&Role> for Access {
-    fn from(role: &Role) -> Self {
-        match role {
-            Role::Readonly => Access {
-                is_signer: false,
-                is_writable: false,
-            },
-            Role::Writable => Access {
-                is_signer: false,
-                is_writable: true,
-            },
-            Role::ReadonlySigner => Access {
-                is_signer: true,
-                is_writable: false,
-            },
-            Role::WritableSigner => Access {
-                is_signer: true,
-                is_writable: true,
-            },
-        }
-    }
-}
-
-impl From<&Config> for ExtraAccountMeta {
-    fn from(config: &Config) -> Self {
-        let Access {
-            is_signer,
-            is_writable,
-        } = Access::from(&config.role);
-        match &config.address_config {
-            AddressConfig::Pubkey(pubkey_string) => ExtraAccountMeta::new_with_pubkey(
-                &Pubkey::from_str(pubkey_string).unwrap(),
-                is_signer,
-                is_writable,
-            )
-            .unwrap(),
-            AddressConfig::Seeds(seeds) => {
-                ExtraAccountMeta::new_with_seeds(seeds, is_signer, is_writable).unwrap()
-            }
-        }
-    }
-}
-
-type ParseFn = fn(&str) -> Result<ConfigFile, String>;
-
-fn get_parse_function(path: &Path) -> Result<ParseFn, String> {
-    match path.extension().and_then(|s| s.to_str()) {
-        Some("json") => Ok(|v: &str| {
-            serde_json::from_str::<ConfigFile>(v).map_err(|e| format!("Unable to parse file: {e}"))
-        }),
-        Some("yaml") | Some("yml") => Ok(|v: &str| {
-            serde_yaml::from_str::<ConfigFile>(v).map_err(|e| format!("Unable to parse file: {e}"))
-        }),
-        _ => Err(format!(
-            "Unsupported file extension: {}. Only JSON and YAML files are supported",
-            path.display()
-        )),
-    }
-}
-
-fn parse_config_file_arg(path_str: &str) -> Result<Vec<ExtraAccountMeta>, String> {
-    let path = Path::new(path_str);
-    let parse_fn = get_parse_function(path)?;
-    let file =
-        std::fs::read_to_string(path).map_err(|err| format!("Unable to read file: {err}"))?;
-    let parsed_config_file = parse_fn(&file)?;
-    Ok(parsed_config_file
-        .extra_metas
-        .iter()
-        .map(ExtraAccountMeta::from)
-        .collect())
-}
-
-fn parse_pubkey_role_arg(pubkey_string: &str, role: &str) -> Result<Vec<ExtraAccountMeta>, String> {
-    let pubkey = Pubkey::from_str(pubkey_string).map_err(|e| format!("{e}"))?;
-    let role = &Role::from_str(role).map_err(|e| format!("{e}"))?;
-    let Access {
-        is_signer,
-        is_writable,
-    } = role.into();
-    ExtraAccountMeta::new_with_pubkey(&pubkey, is_signer, is_writable)
-        .map(|meta| vec![meta])
-        .map_err(|e| format!("{e}"))
-}
-
-pub fn parse_transfer_hook_account_arg(arg: &str) -> Result<Vec<ExtraAccountMeta>, String> {
-    match arg.split(':').collect::<Vec<_>>().as_slice() {
-        [pubkey_str, role] => parse_pubkey_role_arg(pubkey_str, role),
-        _ => parse_config_file_arg(arg),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_json() {
-        let config = r#"{
-            "extraMetas": [
-                {
-                    "pubkey": "39UhVsxAmJwzPnoWhBSHsZ6nBDtdzt9D8rfDa8zGHrP6",
-                    "role": "readonlySigner"
-                },
-                {
-                    "pubkey": "6WEvW9B9jTKc3EhP1ewGEJPrxw5d8vD9eMYCf2snNYsV",
-                    "role": "readonly"
-                },
-                {
-                    "seeds": [
-                        {
-                            "literal": {
-                                "bytes": [1, 2, 3, 4, 5, 6]
-                            }
-                        },
-                        {
-                            "instructionData": {
-                                "index": 0,
-                                "length": 8
-                            }
-                        },
-                        {
-                            "accountKey": {
-                                "index": 0
-                            }
-                        }
-                    ],
-                    "role": "writable"
-                },
-                {
-                    "seeds": [
-                        {
-                            "accountData": {
-                                "accountIndex": 1,
-                                "dataIndex": 4,
-                                "length": 4
-                            }
-                        },
-                        {
-                            "accountKey": {
-                                "index": 1
-                            }
-                        }
-                    ],
-                    "role": "readonly"
-                }
-            ]
-        }"#;
-        let parsed_config_file = serde_json::from_str::<ConfigFile>(config).unwrap();
-        let parsed_extra_metas: Vec<ExtraAccountMeta> = parsed_config_file
-            .extra_metas
-            .iter()
-            .map(|config| config.into())
-            .collect::<Vec<_>>();
-        let expected = vec![
-            ExtraAccountMeta::new_with_pubkey(
-                &Pubkey::from_str("39UhVsxAmJwzPnoWhBSHsZ6nBDtdzt9D8rfDa8zGHrP6").unwrap(),
-                true,
-                false,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey(
-                &Pubkey::from_str("6WEvW9B9jTKc3EhP1ewGEJPrxw5d8vD9eMYCf2snNYsV").unwrap(),
-                false,
-                false,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: vec![1, 2, 3, 4, 5, 6],
-                    },
-                    Seed::InstructionData {
-                        index: 0,
-                        length: 8,
-                    },
-                    Seed::AccountKey { index: 0 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::AccountData {
-                        account_index: 1,
-                        data_index: 4,
-                        length: 4,
-                    },
-                    Seed::AccountKey { index: 1 },
-                ],
-                false,
-                false,
-            )
-            .unwrap(),
-        ];
-        assert_eq!(parsed_extra_metas, expected);
-    }
-
-    #[test]
-    fn test_parse_yaml() {
-        let config = r#"
-            extraMetas:
-                - pubkey: "39UhVsxAmJwzPnoWhBSHsZ6nBDtdzt9D8rfDa8zGHrP6"
-                  role: "readonlySigner"
-                - pubkey: "6WEvW9B9jTKc3EhP1ewGEJPrxw5d8vD9eMYCf2snNYsV"
-                  role: "readonly"
-                - seeds:
-                    - literal:
-                        bytes: [1, 2, 3, 4, 5, 6]
-                    - instructionData:
-                        index: 0
-                        length: 8
-                    - accountKey:
-                        index: 0
-                  role: "writable"
-                - seeds:
-                    - accountData:
-                        accountIndex: 1
-                        dataIndex: 4
-                        length: 4
-                    - accountKey:
-                        index: 1
-                  role: "readonly"
-        "#;
-        let parsed_config_file = serde_yaml::from_str::<ConfigFile>(config).unwrap();
-        let parsed_extra_metas: Vec<ExtraAccountMeta> = parsed_config_file
-            .extra_metas
-            .iter()
-            .map(|config| config.into())
-            .collect::<Vec<_>>();
-        let expected = vec![
-            ExtraAccountMeta::new_with_pubkey(
-                &Pubkey::from_str("39UhVsxAmJwzPnoWhBSHsZ6nBDtdzt9D8rfDa8zGHrP6").unwrap(),
-                true,
-                false,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_pubkey(
-                &Pubkey::from_str("6WEvW9B9jTKc3EhP1ewGEJPrxw5d8vD9eMYCf2snNYsV").unwrap(),
-                false,
-                false,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::Literal {
-                        bytes: vec![1, 2, 3, 4, 5, 6],
-                    },
-                    Seed::InstructionData {
-                        index: 0,
-                        length: 8,
-                    },
-                    Seed::AccountKey { index: 0 },
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::AccountData {
-                        account_index: 1,
-                        data_index: 4,
-                        length: 4,
-                    },
-                    Seed::AccountKey { index: 1 },
-                ],
-                false,
-                false,
-            )
-            .unwrap(),
-        ];
-        assert_eq!(parsed_extra_metas, expected);
-    }
-}
diff --git a/token/transfer-hook/example/Cargo.toml b/token/transfer-hook/example/Cargo.toml
deleted file mode 100644
index b5b0056648b..00000000000
--- a/token/transfer-hook/example/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-name = "spl-transfer-hook-example"
-version = "0.6.0"
-description = "Solana Program Library Transfer Hook Example Program"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[features]
-default = ["forbid-additional-mints"]
-no-entrypoint = []
-test-sbf = []
-forbid-additional-mints = []
-
-[dependencies]
-arrayref = "0.3.7"
-solana-program = ">=1.18.11,<=2"
-spl-tlv-account-resolution = { version = "0.6.3" , path = "../../../libraries/tlv-account-resolution" }
-spl-token-2022 = { version = "3.0.2",  path = "../../program-2022", features = ["no-entrypoint"] }
-spl-transfer-hook-interface = { version = "0.6.3" , path = "../interface" }
-spl-type-length-value = { version = "0.4.3" , path = "../../../libraries/type-length-value" }
-
-[dev-dependencies]
-solana-program-test = ">=1.18.11,<=2"
-solana-sdk = ">=1.18.11,<=2"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token/transfer-hook/example/README.md b/token/transfer-hook/example/README.md
deleted file mode 100644
index f3d2aef4a4b..00000000000
--- a/token/transfer-hook/example/README.md
+++ /dev/null
@@ -1,66 +0,0 @@
-## Transfer-Hook Example
-
-Full example program and tests implementing the `spl-transfer-hook-interface`,
-to be used for testing a program that calls into the `spl-transfer-hook-interface`.
-
-See the
-[SPL Transfer Hook Interface](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface)
-code for more information.
-
-### Example usage of example
-
-When testing your program that uses `spl-transfer-hook-interface`, you can also
-import this crate, and then use it with `solana-program-test`, ie:
-
-```rust
-use {
-    solana_program_test::{processor, ProgramTest},
-    solana_sdk::{account::Account, instruction::AccountMeta},
-    spl_transfer_hook_example::state::example_data,
-    spl_transfer_hook_interface::get_extra_account_metas_address,
-};
-
-#[test]
-fn my_program_test() {
-    let mut program_test = ProgramTest::new(
-        "my_program",
-        my_program_id,
-        processor!(my_program_processor),
-    );
-
-    let transfer_hook_program_id = Pubkey::new_unique();
-    program_test.prefer_bpf(false); // BPF won't work, unless you've built this from scratch!
-    program_test.add_program(
-        "spl_transfer_hook_example",
-        transfer_hook_program_id,
-        processor!(spl_transfer_hook_example::processor::process),
-    );
-
-    let mint = Pubkey::new_unique();
-    let extra_accounts_address = get_extra_account_metas_address(&mint, &transfer_hook_program_id);
-    let account_metas = vec![
-        AccountMeta {
-            pubkey: Pubkey::new_unique(),
-            is_signer: false,
-            is_writable: false,
-        },
-        AccountMeta {
-            pubkey: Pubkey::new_unique(),
-            is_signer: false,
-            is_writable: false,
-        },
-    ];
-    let data = example_data(&account_metas);
-    program_test.add_account(
-        extra_accounts_address,
-        Account {
-            lamports: 1_000_000_000, // a lot, just to be safe
-            data,
-            owner: transfer_hook_program_id,
-            ..Account::default()
-        },
-    );
-
-    // run your test logic!
-}
-```
diff --git a/token/transfer-hook/example/src/entrypoint.rs b/token/transfer-hook/example/src/entrypoint.rs
deleted file mode 100644
index b2046037275..00000000000
--- a/token/transfer-hook/example/src/entrypoint.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//! Program entrypoint
-
-use {
-    crate::processor,
-    solana_program::{
-        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
-        pubkey::Pubkey,
-    },
-    spl_transfer_hook_interface::error::TransferHookError,
-};
-
-solana_program::entrypoint!(process_instruction);
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-    if let Err(error) = processor::process(program_id, accounts, instruction_data) {
-        // catch the error so we can print it
-        error.print::<TransferHookError>();
-        return Err(error);
-    }
-    Ok(())
-}
diff --git a/token/transfer-hook/example/src/lib.rs b/token/transfer-hook/example/src/lib.rs
deleted file mode 100644
index aa49d80c431..00000000000
--- a/token/transfer-hook/example/src/lib.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Crate defining an example program for performing a hook on transfer, where
-//! the token program calls into a separate program with additional accounts
-//! after all other logic, to be sure that a transfer has accomplished all
-//! required preconditions.
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod processor;
-pub mod state;
-
-#[cfg(not(feature = "no-entrypoint"))]
-mod entrypoint;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-
-/// Place the mint id that you want to target with your transfer hook program.
-/// Any other mint will fail to initialize, protecting the transfer hook program
-/// from rogue mints trying to get access to accounts.
-///
-/// There are many situations where it's reasonable to support multiple mints
-/// with one transfer-hook program, but because it's easy to make something
-/// unsafe, this simple example implementation only allows for one mint.
-#[cfg(feature = "forbid-additional-mints")]
-pub mod mint {
-    solana_program::declare_id!("Mint111111111111111111111111111111111111111");
-}
diff --git a/token/transfer-hook/example/src/processor.rs b/token/transfer-hook/example/src/processor.rs
deleted file mode 100644
index 8bac5a99e88..00000000000
--- a/token/transfer-hook/example/src/processor.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-//! Program state processor
-
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult,
-        msg,
-        program::invoke_signed,
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        system_instruction,
-    },
-    spl_tlv_account_resolution::{account::ExtraAccountMeta, state::ExtraAccountMetaList},
-    spl_token_2022::{
-        extension::{
-            transfer_hook::TransferHookAccount, BaseStateWithExtensions, StateWithExtensions,
-        },
-        state::{Account, Mint},
-    },
-    spl_transfer_hook_interface::{
-        collect_extra_account_metas_signer_seeds,
-        error::TransferHookError,
-        get_extra_account_metas_address, get_extra_account_metas_address_and_bump_seed,
-        instruction::{ExecuteInstruction, TransferHookInstruction},
-    },
-};
-
-fn check_token_account_is_transferring(account_info: &AccountInfo) -> Result<(), ProgramError> {
-    let account_data = account_info.try_borrow_data()?;
-    let token_account = StateWithExtensions::<Account>::unpack(&account_data)?;
-    let extension = token_account.get_extension::<TransferHookAccount>()?;
-    if bool::from(extension.transferring) {
-        Ok(())
-    } else {
-        Err(TransferHookError::ProgramCalledOutsideOfTransfer.into())
-    }
-}
-
-/// Processes an [Execute](enum.TransferHookInstruction.html) instruction.
-pub fn process_execute(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    amount: u64,
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let source_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let destination_account_info = next_account_info(account_info_iter)?;
-    let _authority_info = next_account_info(account_info_iter)?;
-    let extra_account_metas_info = next_account_info(account_info_iter)?;
-
-    // Check that the accounts are properly in "transferring" mode
-    check_token_account_is_transferring(source_account_info)?;
-    check_token_account_is_transferring(destination_account_info)?;
-
-    // For the example program, we just check that the correct pda and validation
-    // pubkeys are provided
-    let expected_validation_address = get_extra_account_metas_address(mint_info.key, program_id);
-    if expected_validation_address != *extra_account_metas_info.key {
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    let data = extra_account_metas_info.try_borrow_data()?;
-
-    ExtraAccountMetaList::check_account_infos::<ExecuteInstruction>(
-        accounts,
-        &TransferHookInstruction::Execute { amount }.pack(),
-        program_id,
-        &data,
-    )?;
-
-    Ok(())
-}
-
-/// Processes a
-/// [InitializeExtraAccountMetaList](enum.TransferHookInstruction.html)
-/// instruction.
-pub fn process_initialize_extra_account_meta_list(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    extra_account_metas: &[ExtraAccountMeta],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let extra_account_metas_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-    let _system_program_info = next_account_info(account_info_iter)?;
-
-    // check that the one mint we want to target is trying to create extra
-    // account metas
-    #[cfg(feature = "forbid-additional-mints")]
-    if *mint_info.key != crate::mint::id() {
-        return Err(ProgramError::InvalidArgument);
-    }
-
-    // check that the mint authority is valid without fully deserializing
-    let mint_data = mint_info.try_borrow_data()?;
-    let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-    let mint_authority = mint
-        .base
-        .mint_authority
-        .ok_or(TransferHookError::MintHasNoMintAuthority)?;
-
-    // Check signers
-    if !authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    if *authority_info.key != mint_authority {
-        return Err(TransferHookError::IncorrectMintAuthority.into());
-    }
-
-    // Check validation account
-    let (expected_validation_address, bump_seed) =
-        get_extra_account_metas_address_and_bump_seed(mint_info.key, program_id);
-    if expected_validation_address != *extra_account_metas_info.key {
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    // Create the account
-    let bump_seed = [bump_seed];
-    let signer_seeds = collect_extra_account_metas_signer_seeds(mint_info.key, &bump_seed);
-    let length = extra_account_metas.len();
-    let account_size = ExtraAccountMetaList::size_of(length)?;
-    invoke_signed(
-        &system_instruction::allocate(extra_account_metas_info.key, account_size as u64),
-        &[extra_account_metas_info.clone()],
-        &[&signer_seeds],
-    )?;
-    invoke_signed(
-        &system_instruction::assign(extra_account_metas_info.key, program_id),
-        &[extra_account_metas_info.clone()],
-        &[&signer_seeds],
-    )?;
-
-    // Write the data
-    let mut data = extra_account_metas_info.try_borrow_mut_data()?;
-    ExtraAccountMetaList::init::<ExecuteInstruction>(&mut data, extra_account_metas)?;
-
-    Ok(())
-}
-
-/// Processes a
-/// [UpdateExtraAccountMetaList](enum.TransferHookInstruction.html)
-/// instruction.
-pub fn process_update_extra_account_meta_list(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    extra_account_metas: &[ExtraAccountMeta],
-) -> ProgramResult {
-    let account_info_iter = &mut accounts.iter();
-
-    let extra_account_metas_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let authority_info = next_account_info(account_info_iter)?;
-
-    // check that the mint authority is valid without fully deserializing
-    let mint_data = mint_info.try_borrow_data()?;
-    let mint = StateWithExtensions::<Mint>::unpack(&mint_data)?;
-    let mint_authority = mint
-        .base
-        .mint_authority
-        .ok_or(TransferHookError::MintHasNoMintAuthority)?;
-
-    // Check signers
-    if !authority_info.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    if *authority_info.key != mint_authority {
-        return Err(TransferHookError::IncorrectMintAuthority.into());
-    }
-
-    // Check validation account
-    let expected_validation_address = get_extra_account_metas_address(mint_info.key, program_id);
-    if expected_validation_address != *extra_account_metas_info.key {
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    // Check if the extra metas have been initialized
-    let min_account_size = ExtraAccountMetaList::size_of(0)?;
-    let original_account_size = extra_account_metas_info.data_len();
-    if program_id != extra_account_metas_info.owner || original_account_size < min_account_size {
-        return Err(ProgramError::UninitializedAccount);
-    }
-
-    // If the new extra_account_metas length is different, resize the account and
-    // update
-    let length = extra_account_metas.len();
-    let account_size = ExtraAccountMetaList::size_of(length)?;
-    if account_size >= original_account_size {
-        extra_account_metas_info.realloc(account_size, false)?;
-        let mut data = extra_account_metas_info.try_borrow_mut_data()?;
-        ExtraAccountMetaList::update::<ExecuteInstruction>(&mut data, extra_account_metas)?;
-    } else {
-        {
-            let mut data = extra_account_metas_info.try_borrow_mut_data()?;
-            ExtraAccountMetaList::update::<ExecuteInstruction>(&mut data, extra_account_metas)?;
-        }
-        extra_account_metas_info.realloc(account_size, false)?;
-    }
-
-    Ok(())
-}
-
-/// Processes an [Instruction](enum.Instruction.html).
-pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
-    let instruction = TransferHookInstruction::unpack(input)?;
-
-    match instruction {
-        TransferHookInstruction::Execute { amount } => {
-            msg!("Instruction: Execute");
-            process_execute(program_id, accounts, amount)
-        }
-        TransferHookInstruction::InitializeExtraAccountMetaList {
-            extra_account_metas,
-        } => {
-            msg!("Instruction: InitializeExtraAccountMetaList");
-            process_initialize_extra_account_meta_list(program_id, accounts, &extra_account_metas)
-        }
-        TransferHookInstruction::UpdateExtraAccountMetaList {
-            extra_account_metas,
-        } => {
-            msg!("Instruction: UpdateExtraAccountMetaList");
-            process_update_extra_account_meta_list(program_id, accounts, &extra_account_metas)
-        }
-    }
-}
diff --git a/token/transfer-hook/example/src/state.rs b/token/transfer-hook/example/src/state.rs
deleted file mode 100644
index b2c962c5072..00000000000
--- a/token/transfer-hook/example/src/state.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//! State helpers for working with the example program
-
-use {
-    solana_program::program_error::ProgramError,
-    spl_tlv_account_resolution::{account::ExtraAccountMeta, state::ExtraAccountMetaList},
-    spl_transfer_hook_interface::instruction::ExecuteInstruction,
-};
-
-/// Generate example data to be used directly in an account for testing
-pub fn example_data(account_metas: &[ExtraAccountMeta]) -> Result<Vec<u8>, ProgramError> {
-    let account_size = ExtraAccountMetaList::size_of(account_metas.len())?;
-    let mut data = vec![0; account_size];
-    ExtraAccountMetaList::init::<ExecuteInstruction>(&mut data, account_metas)?;
-    Ok(data)
-}
diff --git a/token/transfer-hook/example/tests/functional.rs b/token/transfer-hook/example/tests/functional.rs
deleted file mode 100644
index 0d64d1abf28..00000000000
--- a/token/transfer-hook/example/tests/functional.rs
+++ /dev/null
@@ -1,1464 +0,0 @@
-// Mark this test as SBF-only due to current `ProgramTest` limitations when
-// CPIing into the system program
-#![cfg(feature = "test-sbf")]
-
-use {
-    solana_program_test::{processor, tokio, ProgramTest},
-    solana_sdk::{
-        account::Account as SolanaAccount,
-        account_info::AccountInfo,
-        entrypoint::ProgramResult,
-        instruction::{AccountMeta, InstructionError},
-        program_error::ProgramError,
-        program_option::COption,
-        pubkey::Pubkey,
-        signature::Signer,
-        signer::keypair::Keypair,
-        system_instruction, sysvar,
-        transaction::{Transaction, TransactionError},
-    },
-    spl_tlv_account_resolution::{
-        account::ExtraAccountMeta, error::AccountResolutionError, seeds::Seed,
-        state::ExtraAccountMetaList,
-    },
-    spl_token_2022::{
-        extension::{
-            transfer_hook::TransferHookAccount, BaseStateWithExtensionsMut, ExtensionType,
-            StateWithExtensionsMut,
-        },
-        state::{Account, AccountState, Mint},
-    },
-    spl_transfer_hook_interface::{
-        error::TransferHookError,
-        get_extra_account_metas_address,
-        instruction::{
-            execute_with_extra_account_metas, initialize_extra_account_meta_list,
-            update_extra_account_meta_list,
-        },
-        onchain,
-    },
-};
-
-fn setup(program_id: &Pubkey) -> ProgramTest {
-    let mut program_test = ProgramTest::new(
-        "spl_transfer_hook_example",
-        *program_id,
-        processor!(spl_transfer_hook_example::processor::process),
-    );
-
-    program_test.prefer_bpf(false); // simplicity in the build
-
-    program_test.add_program(
-        "spl_token_2022",
-        spl_token_2022::id(),
-        processor!(spl_token_2022::processor::Processor::process),
-    );
-
-    program_test
-}
-
-#[allow(clippy::too_many_arguments)]
-fn setup_token_accounts(
-    program_test: &mut ProgramTest,
-    program_id: &Pubkey,
-    mint_address: &Pubkey,
-    mint_authority: &Pubkey,
-    source: &Pubkey,
-    destination: &Pubkey,
-    owner: &Pubkey,
-    decimals: u8,
-    transferring: bool,
-) {
-    // add mint, source, and destination accounts by hand to always force
-    // the "transferring" flag to true
-    let mint_size = ExtensionType::try_calculate_account_len::<Mint>(&[]).unwrap();
-    let mut mint_data = vec![0; mint_size];
-    let mut state = StateWithExtensionsMut::<Mint>::unpack_uninitialized(&mut mint_data).unwrap();
-    let token_amount = 1_000_000_000_000;
-    state.base = Mint {
-        mint_authority: COption::Some(*mint_authority),
-        supply: token_amount,
-        decimals,
-        is_initialized: true,
-        freeze_authority: COption::None,
-    };
-    state.pack_base();
-    program_test.add_account(
-        *mint_address,
-        SolanaAccount {
-            lamports: 1_000_000_000,
-            data: mint_data,
-            owner: *program_id,
-            ..SolanaAccount::default()
-        },
-    );
-
-    let account_size =
-        ExtensionType::try_calculate_account_len::<Account>(&[ExtensionType::TransferHookAccount])
-            .unwrap();
-    let mut account_data = vec![0; account_size];
-    let mut state =
-        StateWithExtensionsMut::<Account>::unpack_uninitialized(&mut account_data).unwrap();
-    let extension = state.init_extension::<TransferHookAccount>(true).unwrap();
-    extension.transferring = transferring.into();
-    let token_amount = 1_000_000_000_000;
-    state.base = Account {
-        mint: *mint_address,
-        owner: *owner,
-        amount: token_amount,
-        delegate: COption::None,
-        state: AccountState::Initialized,
-        is_native: COption::None,
-        delegated_amount: 0,
-        close_authority: COption::None,
-    };
-    state.pack_base();
-    state.init_account_type().unwrap();
-
-    program_test.add_account(
-        *source,
-        SolanaAccount {
-            lamports: 1_000_000_000,
-            data: account_data.clone(),
-            owner: *program_id,
-            ..SolanaAccount::default()
-        },
-    );
-    program_test.add_account(
-        *destination,
-        SolanaAccount {
-            lamports: 1_000_000_000,
-            data: account_data,
-            owner: *program_id,
-            ..SolanaAccount::default()
-        },
-    );
-}
-
-#[tokio::test]
-async fn success_execute() {
-    let program_id = Pubkey::new_unique();
-    let mut program_test = setup(&program_id);
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    let amount = 0u64;
-
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    let extra_account_metas_address = get_extra_account_metas_address(&mint_address, &program_id);
-
-    let writable_pubkey = Pubkey::new_unique();
-
-    let init_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&writable_pubkey, false, true).unwrap(),
-    ];
-
-    let extra_pda_1 = Pubkey::find_program_address(
-        &[
-            b"seed-prefix",  // Literal prefix
-            source.as_ref(), // Account at index 0
-        ],
-        &program_id,
-    )
-    .0;
-    let extra_pda_2 = Pubkey::find_program_address(
-        &[
-            &amount.to_le_bytes(), // Instruction data bytes 8 to 16
-            destination.as_ref(),  // Account at index 2
-        ],
-        &program_id,
-    )
-    .0;
-
-    let extra_account_metas = [
-        AccountMeta::new_readonly(sysvar::instructions::id(), false),
-        AccountMeta::new_readonly(mint_authority_pubkey, true),
-        AccountMeta::new(extra_pda_1, false),
-        AccountMeta::new(extra_pda_2, false),
-        AccountMeta::new(writable_pubkey, false),
-    ];
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(init_extra_account_metas.len()).unwrap());
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &init_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // fail with missing account
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas[..2],
-                amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with wrong account
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, true),
-            AccountMeta::new(extra_pda_1, false),
-            AccountMeta::new(extra_pda_2, false),
-            AccountMeta::new(Pubkey::new_unique(), false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with wrong PDA
-    let wrong_pda_2 = Pubkey::find_program_address(
-        &[
-            &99u64.to_le_bytes(), // Wrong data
-            destination.as_ref(),
-        ],
-        &program_id,
-    )
-    .0;
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, true),
-            AccountMeta::new(extra_pda_1, false),
-            AccountMeta::new(wrong_pda_2, false),
-            AccountMeta::new(writable_pubkey, false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with not signer
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, false),
-            AccountMeta::new(extra_pda_1, false),
-            AccountMeta::new(extra_pda_2, false),
-            AccountMeta::new(writable_pubkey, false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // success with correct params
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-    }
-}
-
-#[tokio::test]
-async fn fail_incorrect_derivation() {
-    let program_id = Pubkey::new_unique();
-    let mut program_test = setup(&program_id);
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    // wrong derivation
-    let extra_account_metas = get_extra_account_metas_address(&program_id, &mint_address);
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent.minimum_balance(ExtraAccountMetaList::size_of(0).unwrap());
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas,
-                &mint_address,
-                &mint_authority_pubkey,
-                &[],
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(1, InstructionError::InvalidSeeds)
-    );
-}
-
-#[tokio::test]
-async fn fail_incorrect_mint() {
-    let program_id = Pubkey::new_unique();
-    let mut program_test = setup(&program_id);
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    // wrong mint, only `spl_transfer_hook_example::mint::id()` allowed
-    let mint_address = Pubkey::new_unique();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    let extra_account_metas = get_extra_account_metas_address(&mint_address, &program_id);
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent.minimum_balance(ExtraAccountMetaList::size_of(0).unwrap());
-
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas,
-                &mint_address,
-                &mint_authority_pubkey,
-                &[],
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(1, InstructionError::InvalidArgument)
-    );
-}
-
-/// Test program to CPI into default transfer-hook-interface program
-pub fn process_instruction(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let amount = input
-        .get(8..16)
-        .and_then(|slice| slice.try_into().ok())
-        .map(u64::from_le_bytes)
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    onchain::invoke_execute(
-        accounts[0].key,
-        accounts[1].clone(),
-        accounts[2].clone(),
-        accounts[3].clone(),
-        accounts[4].clone(),
-        &accounts[5..],
-        amount,
-    )
-}
-
-#[tokio::test]
-async fn success_on_chain_invoke() {
-    let hook_program_id = Pubkey::new_unique();
-    let mut program_test = setup(&hook_program_id);
-    let program_id = Pubkey::new_unique();
-    program_test.add_program(
-        "test_cpi_program",
-        program_id,
-        processor!(process_instruction),
-    );
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    let amount = 0u64;
-
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    let extra_account_metas_address =
-        get_extra_account_metas_address(&mint_address, &hook_program_id);
-    let writable_pubkey = Pubkey::new_unique();
-
-    let init_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&writable_pubkey, false, true).unwrap(),
-    ];
-
-    let extra_pda_1 = Pubkey::find_program_address(
-        &[
-            b"seed-prefix",  // Literal prefix
-            source.as_ref(), // Account at index 0
-        ],
-        &hook_program_id,
-    )
-    .0;
-    let extra_pda_2 = Pubkey::find_program_address(
-        &[
-            &amount.to_le_bytes(), // Instruction data bytes 8 to 16
-            destination.as_ref(),  // Account at index 2
-        ],
-        &hook_program_id,
-    )
-    .0;
-
-    let extra_account_metas = [
-        AccountMeta::new_readonly(sysvar::instructions::id(), false),
-        AccountMeta::new_readonly(mint_authority_pubkey, true),
-        AccountMeta::new(extra_pda_1, false),
-        AccountMeta::new(extra_pda_2, false),
-        AccountMeta::new(writable_pubkey, false),
-    ];
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(init_extra_account_metas.len()).unwrap());
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &hook_program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &init_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // easier to hack this up!
-    let mut test_instruction = execute_with_extra_account_metas(
-        &program_id,
-        &source,
-        &mint_address,
-        &destination,
-        &wallet.pubkey(),
-        &extra_account_metas_address,
-        &extra_account_metas,
-        amount,
-    );
-    test_instruction
-        .accounts
-        .insert(0, AccountMeta::new_readonly(hook_program_id, false));
-    let transaction = Transaction::new_signed_with_payer(
-        &[test_instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn fail_without_transferring_flag() {
-    let program_id = Pubkey::new_unique();
-    let mut program_test = setup(&program_id);
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        false,
-    );
-
-    let extra_account_metas_address = get_extra_account_metas_address(&mint_address, &program_id);
-    let extra_account_metas = [];
-    let init_extra_account_metas = [];
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(init_extra_account_metas.len()).unwrap());
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &init_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-    let transaction = Transaction::new_signed_with_payer(
-        &[execute_with_extra_account_metas(
-            &program_id,
-            &source,
-            &mint_address,
-            &destination,
-            &wallet.pubkey(),
-            &extra_account_metas_address,
-            &extra_account_metas,
-            0,
-        )],
-        Some(&context.payer.pubkey()),
-        &[&context.payer],
-        context.last_blockhash,
-    );
-    let error = context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap_err()
-        .unwrap();
-    assert_eq!(
-        error,
-        TransactionError::InstructionError(
-            0,
-            InstructionError::Custom(TransferHookError::ProgramCalledOutsideOfTransfer as u32)
-        )
-    );
-}
-
-#[tokio::test]
-async fn success_on_chain_invoke_with_updated_extra_account_metas() {
-    let hook_program_id = Pubkey::new_unique();
-    let mut program_test = setup(&hook_program_id);
-    let program_id = Pubkey::new_unique();
-    program_test.add_program(
-        "test_cpi_program",
-        program_id,
-        processor!(process_instruction),
-    );
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    let amount = 0u64;
-
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    let extra_account_metas_address =
-        get_extra_account_metas_address(&mint_address, &hook_program_id);
-    let writable_pubkey = Pubkey::new_unique();
-
-    // Create an initial account metas list
-    let init_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"init-seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&writable_pubkey, false, true).unwrap(),
-    ];
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(init_extra_account_metas.len()).unwrap());
-    let init_transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &hook_program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &init_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(init_transaction)
-        .await
-        .unwrap();
-
-    // Create an updated account metas list
-    let updated_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"updated-seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&writable_pubkey, false, true).unwrap(),
-    ];
-
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(updated_extra_account_metas.len()).unwrap());
-    let update_transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            update_extra_account_meta_list(
-                &hook_program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &updated_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(update_transaction)
-        .await
-        .unwrap();
-
-    let updated_extra_pda_1 = Pubkey::find_program_address(
-        &[
-            b"updated-seed-prefix", // Literal prefix
-            source.as_ref(),        // Account at index 0
-        ],
-        &hook_program_id,
-    )
-    .0;
-    let extra_pda_2 = Pubkey::find_program_address(
-        &[
-            &amount.to_le_bytes(), // Instruction data bytes 8 to 16
-            destination.as_ref(),  // Account at index 2
-        ],
-        &hook_program_id,
-    )
-    .0;
-
-    let test_updated_extra_account_metas = [
-        AccountMeta::new_readonly(sysvar::instructions::id(), false),
-        AccountMeta::new_readonly(mint_authority_pubkey, true),
-        AccountMeta::new(updated_extra_pda_1, false),
-        AccountMeta::new(extra_pda_2, false),
-        AccountMeta::new(writable_pubkey, false),
-    ];
-
-    // Use updated account metas list
-    let mut test_instruction = execute_with_extra_account_metas(
-        &program_id,
-        &source,
-        &mint_address,
-        &destination,
-        &wallet.pubkey(),
-        &extra_account_metas_address,
-        &test_updated_extra_account_metas,
-        amount,
-    );
-    test_instruction
-        .accounts
-        .insert(0, AccountMeta::new_readonly(hook_program_id, false));
-    let transaction = Transaction::new_signed_with_payer(
-        &[test_instruction],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn success_execute_with_updated_extra_account_metas() {
-    let program_id = Pubkey::new_unique();
-    let mut program_test = setup(&program_id);
-
-    let token_program_id = spl_token_2022::id();
-    let wallet = Keypair::new();
-    let mint_address = spl_transfer_hook_example::mint::id();
-    let mint_authority = Keypair::new();
-    let mint_authority_pubkey = mint_authority.pubkey();
-    let source = Pubkey::new_unique();
-    let destination = Pubkey::new_unique();
-    let decimals = 2;
-    let amount = 0u64;
-
-    setup_token_accounts(
-        &mut program_test,
-        &token_program_id,
-        &mint_address,
-        &mint_authority_pubkey,
-        &source,
-        &destination,
-        &wallet.pubkey(),
-        decimals,
-        true,
-    );
-
-    let extra_account_metas_address = get_extra_account_metas_address(&mint_address, &program_id);
-
-    let writable_pubkey = Pubkey::new_unique();
-
-    let init_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&writable_pubkey, false, true).unwrap(),
-    ];
-
-    let extra_pda_1 = Pubkey::find_program_address(
-        &[
-            b"seed-prefix",  // Literal prefix
-            source.as_ref(), // Account at index 0
-        ],
-        &program_id,
-    )
-    .0;
-
-    let extra_pda_2 = Pubkey::find_program_address(
-        &[
-            &amount.to_le_bytes(), // Instruction data bytes 8 to 16
-            destination.as_ref(),  // Account at index 2
-        ],
-        &program_id,
-    )
-    .0;
-
-    let init_account_metas = [
-        AccountMeta::new_readonly(sysvar::instructions::id(), false),
-        AccountMeta::new_readonly(mint_authority_pubkey, true),
-        AccountMeta::new(extra_pda_1, false),
-        AccountMeta::new(extra_pda_2, false),
-        AccountMeta::new(writable_pubkey, false),
-    ];
-
-    let mut context = program_test.start_with_context().await;
-    let rent = context.banks_client.get_rent().await.unwrap();
-    let rent_lamports = rent
-        .minimum_balance(ExtraAccountMetaList::size_of(init_extra_account_metas.len()).unwrap());
-    let transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            initialize_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &init_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    let updated_amount = 1u64;
-    let updated_writable_pubkey = Pubkey::new_unique();
-
-    // Create updated extra account metas
-    let updated_extra_account_metas = [
-        ExtraAccountMeta::new_with_pubkey(&sysvar::instructions::id(), false, false).unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&mint_authority_pubkey, true, false).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"updated-seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::InstructionData {
-                    index: 8,  // After instruction discriminator
-                    length: 8, // `u64` (amount)
-                },
-                Seed::AccountKey { index: 2 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-        ExtraAccountMeta::new_with_pubkey(&updated_writable_pubkey, false, true).unwrap(),
-        ExtraAccountMeta::new_with_seeds(
-            &[
-                Seed::Literal {
-                    bytes: b"new-seed-prefix".to_vec(),
-                },
-                Seed::AccountKey { index: 0 },
-            ],
-            false,
-            true,
-        )
-        .unwrap(),
-    ];
-
-    let updated_extra_pda_1 = Pubkey::find_program_address(
-        &[
-            b"updated-seed-prefix", // Literal prefix
-            source.as_ref(),        // Account at index 0
-        ],
-        &program_id,
-    )
-    .0;
-
-    let updated_extra_pda_2 = Pubkey::find_program_address(
-        &[
-            &updated_amount.to_le_bytes(), // Instruction data bytes 8 to 16
-            destination.as_ref(),          // Account at index 2
-        ],
-        &program_id,
-    )
-    .0;
-
-    // add another PDA
-    let new_extra_pda = Pubkey::find_program_address(
-        &[
-            b"new-seed-prefix", // Literal prefix
-            source.as_ref(),    // Account at index 0
-        ],
-        &program_id,
-    )
-    .0;
-
-    let updated_account_metas = [
-        AccountMeta::new_readonly(sysvar::instructions::id(), false),
-        AccountMeta::new_readonly(mint_authority_pubkey, true),
-        AccountMeta::new(updated_extra_pda_1, false),
-        AccountMeta::new(updated_extra_pda_2, false),
-        AccountMeta::new(updated_writable_pubkey, false),
-        AccountMeta::new(new_extra_pda, false),
-    ];
-
-    let update_transaction = Transaction::new_signed_with_payer(
-        &[
-            system_instruction::transfer(
-                &context.payer.pubkey(),
-                &extra_account_metas_address,
-                rent_lamports,
-            ),
-            update_extra_account_meta_list(
-                &program_id,
-                &extra_account_metas_address,
-                &mint_address,
-                &mint_authority_pubkey,
-                &updated_extra_account_metas,
-            ),
-        ],
-        Some(&context.payer.pubkey()),
-        &[&context.payer, &mint_authority],
-        context.last_blockhash,
-    );
-
-    context
-        .banks_client
-        .process_transaction(update_transaction)
-        .await
-        .unwrap();
-
-    // fail with initial account metas list
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &init_account_metas,
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with missing account
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &updated_account_metas[..2],
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with wrong account
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, true),
-            AccountMeta::new(updated_extra_pda_1, false),
-            AccountMeta::new(updated_extra_pda_2, false),
-            AccountMeta::new(Pubkey::new_unique(), false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with wrong PDA
-    let wrong_pda_2 = Pubkey::find_program_address(
-        &[
-            &99u64.to_le_bytes(), // Wrong data
-            destination.as_ref(),
-        ],
-        &program_id,
-    )
-    .0;
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, true),
-            AccountMeta::new(updated_extra_pda_1, false),
-            AccountMeta::new(wrong_pda_2, false),
-            AccountMeta::new(writable_pubkey, false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // fail with not signer
-    {
-        let extra_account_metas = [
-            AccountMeta::new_readonly(sysvar::instructions::id(), false),
-            AccountMeta::new_readonly(mint_authority_pubkey, false),
-            AccountMeta::new(updated_extra_pda_1, false),
-            AccountMeta::new(updated_extra_pda_2, false),
-            AccountMeta::new(writable_pubkey, false),
-        ];
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &extra_account_metas,
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer],
-            context.last_blockhash,
-        );
-        let error = context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap();
-        assert_eq!(
-            error,
-            TransactionError::InstructionError(
-                0,
-                InstructionError::Custom(AccountResolutionError::IncorrectAccount as u32),
-            )
-        );
-    }
-
-    // success with correct params
-    {
-        let transaction = Transaction::new_signed_with_payer(
-            &[execute_with_extra_account_metas(
-                &program_id,
-                &source,
-                &mint_address,
-                &destination,
-                &wallet.pubkey(),
-                &extra_account_metas_address,
-                &updated_account_metas,
-                updated_amount,
-            )],
-            Some(&context.payer.pubkey()),
-            &[&context.payer, &mint_authority],
-            context.last_blockhash,
-        );
-        context
-            .banks_client
-            .process_transaction(transaction)
-            .await
-            .unwrap();
-    }
-}
diff --git a/token/transfer-hook/interface/Cargo.toml b/token/transfer-hook/interface/Cargo.toml
deleted file mode 100644
index d2d9201e249..00000000000
--- a/token/transfer-hook/interface/Cargo.toml
+++ /dev/null
@@ -1,27 +0,0 @@
-[package]
-name = "spl-transfer-hook-interface"
-version = "0.6.3"
-description = "Solana Program Library Transfer Hook Interface"
-authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
-repository = "https://github.com/solana-labs/solana-program-library"
-license = "Apache-2.0"
-edition = "2021"
-
-[dependencies]
-arrayref = "0.3.7"
-bytemuck = { version = "1.16.0", features = ["derive"] }
-solana-program = ">=1.18.11,<=2"
-spl-discriminator = { version = "0.2.2" , path = "../../../libraries/discriminator" }
-spl-program-error = { version = "0.4.0" , path = "../../../libraries/program-error" }
-spl-tlv-account-resolution = { version = "0.6.3" , path = "../../../libraries/tlv-account-resolution" }
-spl-type-length-value = { version = "0.4.3" , path = "../../../libraries/type-length-value" }
-spl-pod = { version = "0.2.2", path = "../../../libraries/pod" }
-
-[lib]
-crate-type = ["cdylib", "lib"]
-
-[dev-dependencies]
-tokio = { version = "1.38.0", features = ["full"] }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
diff --git a/token/transfer-hook/interface/README.md b/token/transfer-hook/interface/README.md
deleted file mode 100644
index 376cdb1b1b1..00000000000
--- a/token/transfer-hook/interface/README.md
+++ /dev/null
@@ -1,149 +0,0 @@
-## Transfer-Hook Interface
-
-### Example program
-
-Here is an example program that only implements the required "execute" instruction,
-assuming that the proper account data is already written to the appropriate 
-program-derived address defined by the interface.
-
-```rust
-use {
-    solana_program::{entrypoint::ProgramResult, program_error::ProgramError},
-    spl_tlv_account_resolution::state::ExtraAccountMetaList,
-    spl_transfer_hook_interface::instruction::{ExecuteInstruction, TransferHookInstruction},
-    spl_type_length_value::state::TlvStateBorrowed,
-};
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    input: &[u8],
-) -> ProgramResult {
-    let instruction = TransferHookInstruction::unpack(input)?;
-    let _amount = match instruction {
-        TransferHookInstruction::Execute { amount } => amount,
-        _ => return Err(ProgramError::InvalidInstructionData),
-    };
-    let account_info_iter = &mut accounts.iter();
-
-    // Pull out the accounts in order, none are validated in this test program
-    let _source_account_info = next_account_info(account_info_iter)?;
-    let mint_info = next_account_info(account_info_iter)?;
-    let _destination_account_info = next_account_info(account_info_iter)?;
-    let _authority_info = next_account_info(account_info_iter)?;
-    let extra_account_metas_info = next_account_info(account_info_iter)?;
-
-    // Only check that the correct pda and account are provided
-    let expected_validation_address = get_extra_account_metas_address(mint_info.key, program_id);
-    if expected_validation_address != *extra_account_metas_info.key {
-        return Err(ProgramError::InvalidSeeds);
-    }
-
-    // Load the extra required accounts from the validation account
-    let data = extra_account_metas_info.try_borrow_data()?;
-
-    // Check the provided accounts against the validation data
-    ExtraAccountMetaList::check_account_infos::<ExecuteInstruction>(
-        accounts,
-        &TransferHookInstruction::Execute { amount }.pack(),
-        program_id,
-        &data,
-    )?;
-
-    Ok(())
-}
-```
-
-### Motivation
-
-Token creators may need more control over how their token is transferred. The
-most prominent use case revolves around NFT royalties. Whenever a token is moved,
-the creator should be entitled to royalties, but due to the design of the current
-token program, it's impossible to stop a transfer at the protocol level.
-
-Current solutions typically resort to perpetually freezing tokens, which requires
-a whole proxy layer to interact with the token. Wallets and marketplaces need
-to be aware of the proxy layer in order to properly use the token.
-
-Worse still, different royalty systems have different proxy layers for using
-their token. All in all, these systems harm composability and make development
-harder.
-
-### Solution
-
-To improve the situation, Token-2022 introduces the concept of the transfer-hook
-interface and extension. A token creator must develop and deploy a program that
-implements the interface and then configure their token mint to use their program.
-
-During transfer, Token-2022 calls into the program with the accounts specified
-at a well-defined program-derived address for that mint and program id. This
-call happens after all other transfer logic, so the accounts reflect the *end*
-state of the transfer.
-
-### How to Use
-
-Developers must implement the `Execute` instruction, and optionally the
-`InitializeExtraAccountMetaList` instruction to write the required additional account
-pubkeys into the program-derived address defined by the mint and program id.
-
-Note: it's technically not required to implement `InitializeExtraAccountMetaList`
-at that instruction descriminator. Your program may implement multiple interfaces,
-so any other instruction in your program can create the account at the program-derived
-address!
-
-When your program stores configurations for extra required accounts in the
-well-defined program-derived address, it's possible to send an instruction -
-such as `Execute` (transfer) - to your program with only accounts required
-for the interface instruction, and all extra required accounts are
-automatically resolved!
-
-### Account Resolution
-
-Implementers of the transfer-hook interface are encouraged to make use of the
-[spl-tlv-account-resolution](https://github.com/solana-labs/solana-program-library/tree/master/libraries/tlv-account-resolution/README.md)
-library to manage the additional required accounts for their transfer hook
-program.
-
-TLV Account Resolution is capable of powering on-chain account resolution
-when an instruction that requires extra accounts is invoked.
-Read more about how account resolution works in the repository's
-[README file](https://github.com/solana-labs/solana-program-library/tree/master/libraries/tlv-account-resolution/README.md).
-
-### An Example
-
-You have created a DAO to govern a community. Your DAO's authority is a
-multisig account, and you want to ensure that any transfer of your token is
-approved by the DAO. You also want to make sure that someone who intends to
-transfer your token has the proper permissions to do so.
-
-Let's assume the DAO multisig has some **fixed address**. And let's assume that
-in order to have the `can_transfer` permission, a user must have this
-**dynamic program-derived address** associated with their wallet via the
-following seeds: `"can_transfer" + <wallet_address>`.
-
-Using the transfer-hook interface, you can store these configurations in the
-well-defined program-derived address for your mint and program id.
-
-When a user attempts to transfer your token, they might provide to Token-2022:
-
-```rust
-[source, mint, destination, owner/delegate]
-```
-
-Token-2022 will then call into your program,
-**resolving the extra required accounts automatically** from your stored
-configurations, to result in the following accounts being provided to your
-program:
-
-```rust
-[source, mint, destination, owner/delegate, dao_authority, can_transfer_pda]
-```
-
-### Utilities
-
-The `spl-transfer-hook-interface` library provides offchain and onchain helpers
-for resolving the additional accounts required. See
-[onchain.rs](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface/src/onchain.rs)
-for usage on-chain, and
-[offchain.rs](https://github.com/solana-labs/solana-program-library/tree/master/token/transfer-hook/interface/src/offchain.rs)
-for fetching the additional required account metas with any async off-chain client
-like `BanksClient` or `RpcClient`.
diff --git a/token/transfer-hook/interface/src/error.rs b/token/transfer-hook/interface/src/error.rs
deleted file mode 100644
index aaf25e19627..00000000000
--- a/token/transfer-hook/interface/src/error.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! Error types
-
-use spl_program_error::*;
-
-/// Errors that may be returned by the interface.
-#[spl_program_error(hash_error_code_start = 2_110_272_652)]
-pub enum TransferHookError {
-    /// Incorrect account provided
-    #[error("Incorrect account provided")]
-    IncorrectAccount,
-    /// Mint has no mint authority
-    #[error("Mint has no mint authority")]
-    MintHasNoMintAuthority,
-    /// Incorrect mint authority has signed the instruction
-    #[error("Incorrect mint authority has signed the instruction")]
-    IncorrectMintAuthority,
-    /// Program called outside of a token transfer
-    #[error("Program called outside of a token transfer")]
-    ProgramCalledOutsideOfTransfer,
-}
diff --git a/token/transfer-hook/interface/src/instruction.rs b/token/transfer-hook/interface/src/instruction.rs
deleted file mode 100644
index 39639d5d646..00000000000
--- a/token/transfer-hook/interface/src/instruction.rs
+++ /dev/null
@@ -1,306 +0,0 @@
-//! Instruction types
-
-use {
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-        system_program,
-    },
-    spl_discriminator::{ArrayDiscriminator, SplDiscriminate},
-    spl_pod::{bytemuck::pod_slice_to_bytes, slice::PodSlice},
-    spl_tlv_account_resolution::account::ExtraAccountMeta,
-    std::convert::TryInto,
-};
-
-/// Instructions supported by the transfer hook interface.
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq)]
-pub enum TransferHookInstruction {
-    /// Runs additional transfer logic.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[]` Source account
-    ///   1. `[]` Token mint
-    ///   2. `[]` Destination account
-    ///   3. `[]` Source account's owner/delegate
-    ///   4. `[]` Validation account
-    ///   5..5+M `[]` `M` additional accounts, written in validation account
-    ///     data
-    Execute {
-        /// Amount of tokens to transfer
-        amount: u64,
-    },
-
-    /// Initializes the extra account metas on an account, writing into the
-    /// first open TLV space.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Account with extra account metas
-    ///   1. `[]` Mint
-    ///   2. `[s]` Mint authority
-    ///   3. `[]` System program
-    InitializeExtraAccountMetaList {
-        /// List of `ExtraAccountMeta`s to write into the account
-        extra_account_metas: Vec<ExtraAccountMeta>,
-    },
-    /// Updates the extra account metas on an account by overwriting the
-    /// existing list.
-    ///
-    /// Accounts expected by this instruction:
-    ///
-    ///   0. `[w]` Account with extra account metas
-    ///   1. `[]` Mint
-    ///   2. `[s]` Mint authority
-    UpdateExtraAccountMetaList {
-        /// The new list of `ExtraAccountMetas` to overwrite the existing entry
-        /// in the account.
-        extra_account_metas: Vec<ExtraAccountMeta>,
-    },
-}
-/// TLV instruction type only used to define the discriminator. The actual data
-/// is entirely managed by `ExtraAccountMetaList`, and it is the only data
-/// contained by this type.
-#[derive(SplDiscriminate)]
-#[discriminator_hash_input("spl-transfer-hook-interface:execute")]
-pub struct ExecuteInstruction;
-
-/// TLV instruction type used to initialize extra account metas
-/// for the transfer hook
-#[derive(SplDiscriminate)]
-#[discriminator_hash_input("spl-transfer-hook-interface:initialize-extra-account-metas")]
-pub struct InitializeExtraAccountMetaListInstruction;
-
-/// TLV instruction type used to update extra account metas
-/// for the transfer hook
-#[derive(SplDiscriminate)]
-#[discriminator_hash_input("spl-transfer-hook-interface:update-extra-account-metas")]
-pub struct UpdateExtraAccountMetaListInstruction;
-
-impl TransferHookInstruction {
-    /// Unpacks a byte buffer into a
-    /// [TransferHookInstruction](enum.TransferHookInstruction.html).
-    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
-        if input.len() < ArrayDiscriminator::LENGTH {
-            return Err(ProgramError::InvalidInstructionData);
-        }
-        let (discriminator, rest) = input.split_at(ArrayDiscriminator::LENGTH);
-        Ok(match discriminator {
-            ExecuteInstruction::SPL_DISCRIMINATOR_SLICE => {
-                let amount = rest
-                    .get(..8)
-                    .and_then(|slice| slice.try_into().ok())
-                    .map(u64::from_le_bytes)
-                    .ok_or(ProgramError::InvalidInstructionData)?;
-                Self::Execute { amount }
-            }
-            InitializeExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE => {
-                let pod_slice = PodSlice::<ExtraAccountMeta>::unpack(rest)?;
-                let extra_account_metas = pod_slice.data().to_vec();
-                Self::InitializeExtraAccountMetaList {
-                    extra_account_metas,
-                }
-            }
-            UpdateExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE => {
-                let pod_slice = PodSlice::<ExtraAccountMeta>::unpack(rest)?;
-                let extra_account_metas = pod_slice.data().to_vec();
-                Self::UpdateExtraAccountMetaList {
-                    extra_account_metas,
-                }
-            }
-            _ => return Err(ProgramError::InvalidInstructionData),
-        })
-    }
-
-    /// Packs a [TokenInstruction](enum.TokenInstruction.html) into a byte
-    /// buffer.
-    pub fn pack(&self) -> Vec<u8> {
-        let mut buf = vec![];
-        match self {
-            Self::Execute { amount } => {
-                buf.extend_from_slice(ExecuteInstruction::SPL_DISCRIMINATOR_SLICE);
-                buf.extend_from_slice(&amount.to_le_bytes());
-            }
-            Self::InitializeExtraAccountMetaList {
-                extra_account_metas,
-            } => {
-                buf.extend_from_slice(
-                    InitializeExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE,
-                );
-                buf.extend_from_slice(&(extra_account_metas.len() as u32).to_le_bytes());
-                buf.extend_from_slice(pod_slice_to_bytes(extra_account_metas));
-            }
-            Self::UpdateExtraAccountMetaList {
-                extra_account_metas,
-            } => {
-                buf.extend_from_slice(
-                    UpdateExtraAccountMetaListInstruction::SPL_DISCRIMINATOR_SLICE,
-                );
-                buf.extend_from_slice(&(extra_account_metas.len() as u32).to_le_bytes());
-                buf.extend_from_slice(pod_slice_to_bytes(extra_account_metas));
-            }
-        };
-        buf
-    }
-}
-
-/// Creates an `Execute` instruction, provided all of the additional required
-/// account metas
-#[allow(clippy::too_many_arguments)]
-pub fn execute_with_extra_account_metas(
-    program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    validate_state_pubkey: &Pubkey,
-    additional_accounts: &[AccountMeta],
-    amount: u64,
-) -> Instruction {
-    let mut instruction = execute(
-        program_id,
-        source_pubkey,
-        mint_pubkey,
-        destination_pubkey,
-        authority_pubkey,
-        validate_state_pubkey,
-        amount,
-    );
-    instruction.accounts.extend_from_slice(additional_accounts);
-    instruction
-}
-
-/// Creates an `Execute` instruction, without the additional accounts
-#[allow(clippy::too_many_arguments)]
-pub fn execute(
-    program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    validate_state_pubkey: &Pubkey,
-    amount: u64,
-) -> Instruction {
-    let data = TransferHookInstruction::Execute { amount }.pack();
-    let accounts = vec![
-        AccountMeta::new_readonly(*source_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(*destination_pubkey, false),
-        AccountMeta::new_readonly(*authority_pubkey, false),
-        AccountMeta::new_readonly(*validate_state_pubkey, false),
-    ];
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates a `InitializeExtraAccountMetaList` instruction.
-pub fn initialize_extra_account_meta_list(
-    program_id: &Pubkey,
-    extra_account_metas_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    extra_account_metas: &[ExtraAccountMeta],
-) -> Instruction {
-    let data = TransferHookInstruction::InitializeExtraAccountMetaList {
-        extra_account_metas: extra_account_metas.to_vec(),
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*extra_account_metas_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(*authority_pubkey, true),
-        AccountMeta::new_readonly(system_program::id(), false),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-/// Creates a `UpdateExtraAccountMetaList` instruction.
-pub fn update_extra_account_meta_list(
-    program_id: &Pubkey,
-    extra_account_metas_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    extra_account_metas: &[ExtraAccountMeta],
-) -> Instruction {
-    let data = TransferHookInstruction::UpdateExtraAccountMetaList {
-        extra_account_metas: extra_account_metas.to_vec(),
-    }
-    .pack();
-
-    let accounts = vec![
-        AccountMeta::new(*extra_account_metas_pubkey, false),
-        AccountMeta::new_readonly(*mint_pubkey, false),
-        AccountMeta::new_readonly(*authority_pubkey, true),
-    ];
-
-    Instruction {
-        program_id: *program_id,
-        accounts,
-        data,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, crate::NAMESPACE, solana_program::hash, spl_pod::bytemuck::pod_from_bytes};
-
-    #[test]
-    fn validate_packing() {
-        let amount = 111_111_111;
-        let check = TransferHookInstruction::Execute { amount };
-        let packed = check.pack();
-        // Please use ExecuteInstruction::SPL_DISCRIMINATOR in your program, the
-        // following is just for test purposes
-        let preimage = hash::hashv(&[format!("{NAMESPACE}:execute").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        let mut expect = vec![];
-        expect.extend_from_slice(discriminator.as_ref());
-        expect.extend_from_slice(&amount.to_le_bytes());
-        assert_eq!(packed, expect);
-        let unpacked = TransferHookInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-    }
-
-    #[test]
-    fn initialize_validation_pubkeys_packing() {
-        let extra_meta_len_bytes = &[
-            1, 0, 0, 0, // `1u32`
-        ];
-        let extra_meta_bytes = &[
-            0, // `AccountMeta`
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, // pubkey
-            0, // is_signer
-            0, // is_writable
-        ];
-        let extra_account_metas =
-            vec![*pod_from_bytes::<ExtraAccountMeta>(extra_meta_bytes).unwrap()];
-        let check = TransferHookInstruction::InitializeExtraAccountMetaList {
-            extra_account_metas,
-        };
-        let packed = check.pack();
-        // Please use INITIALIZE_EXTRA_ACCOUNT_METAS_DISCRIMINATOR in your program,
-        // the following is just for test purposes
-        let preimage =
-            hash::hashv(&[format!("{NAMESPACE}:initialize-extra-account-metas").as_bytes()]);
-        let discriminator = &preimage.as_ref()[..ArrayDiscriminator::LENGTH];
-        let mut expect = vec![];
-        expect.extend_from_slice(discriminator.as_ref());
-        expect.extend_from_slice(extra_meta_len_bytes);
-        expect.extend_from_slice(extra_meta_bytes);
-        assert_eq!(packed, expect);
-        let unpacked = TransferHookInstruction::unpack(&expect).unwrap();
-        assert_eq!(unpacked, check);
-    }
-}
diff --git a/token/transfer-hook/interface/src/lib.rs b/token/transfer-hook/interface/src/lib.rs
deleted file mode 100644
index d22b7f89f18..00000000000
--- a/token/transfer-hook/interface/src/lib.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! Crate defining an interface for performing a hook on transfer, where the
-//! token program calls into a separate program with additional accounts after
-//! all other logic, to be sure that a transfer has accomplished all required
-//! preconditions.
-
-#![allow(clippy::arithmetic_side_effects)]
-#![deny(missing_docs)]
-#![cfg_attr(not(test), forbid(unsafe_code))]
-
-pub mod error;
-pub mod instruction;
-pub mod offchain;
-pub mod onchain;
-
-// Export current sdk types for downstream users building with a different sdk
-// version
-pub use solana_program;
-use solana_program::pubkey::Pubkey;
-
-/// Namespace for all programs implementing transfer-hook
-pub const NAMESPACE: &str = "spl-transfer-hook-interface";
-
-/// Seed for the state
-const EXTRA_ACCOUNT_METAS_SEED: &[u8] = b"extra-account-metas";
-
-/// Get the state address PDA
-pub fn get_extra_account_metas_address(mint: &Pubkey, program_id: &Pubkey) -> Pubkey {
-    get_extra_account_metas_address_and_bump_seed(mint, program_id).0
-}
-
-/// Function used by programs implementing the interface, when creating the PDA,
-/// to also get the bump seed
-pub fn get_extra_account_metas_address_and_bump_seed(
-    mint: &Pubkey,
-    program_id: &Pubkey,
-) -> (Pubkey, u8) {
-    Pubkey::find_program_address(&collect_extra_account_metas_seeds(mint), program_id)
-}
-
-/// Function used by programs implementing the interface, when creating the PDA,
-/// to get all of the PDA seeds
-pub fn collect_extra_account_metas_seeds(mint: &Pubkey) -> [&[u8]; 2] {
-    [EXTRA_ACCOUNT_METAS_SEED, mint.as_ref()]
-}
-
-/// Function used by programs implementing the interface, when creating the PDA,
-/// to sign for the PDA
-pub fn collect_extra_account_metas_signer_seeds<'a>(
-    mint: &'a Pubkey,
-    bump_seed: &'a [u8],
-) -> [&'a [u8]; 3] {
-    [EXTRA_ACCOUNT_METAS_SEED, mint.as_ref(), bump_seed]
-}
diff --git a/token/transfer-hook/interface/src/offchain.rs b/token/transfer-hook/interface/src/offchain.rs
deleted file mode 100644
index 2d3b7bbdd39..00000000000
--- a/token/transfer-hook/interface/src/offchain.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-//! Offchain helper for fetching required accounts to build instructions
-
-pub use spl_tlv_account_resolution::state::{AccountDataResult, AccountFetchError};
-use {
-    crate::{
-        error::TransferHookError,
-        get_extra_account_metas_address,
-        instruction::{execute, ExecuteInstruction},
-    },
-    solana_program::{
-        instruction::{AccountMeta, Instruction},
-        program_error::ProgramError,
-        pubkey::Pubkey,
-    },
-    spl_tlv_account_resolution::state::ExtraAccountMetaList,
-    std::future::Future,
-};
-
-/// Offchain helper to get all additional required account metas for an execute
-/// instruction, based on a validation state account.
-///
-/// The instruction being provided to this function must contain at least the
-/// same account keys as the ones being provided, in order. Specifically:
-/// 1. source
-/// 2. mint
-/// 3. destination
-/// 4. authority
-///
-/// The `program_id` should be the program ID of the program that the
-/// created `ExecuteInstruction` is for.
-///
-/// To be client-agnostic and to avoid pulling in the full solana-sdk, this
-/// simply takes a function that will return its data as `Future<Vec<u8>>` for
-/// the given address. Can be called in the following way:
-///
-/// ```rust,ignore
-/// add_extra_account_metas_for_execute(
-///     &mut instruction,
-///     &program_id,
-///     &source,
-///     &mint,
-///     &destination,
-///     &authority,
-///     amount,
-///     |address| self.client.get_account(&address).map_ok(|opt| opt.map(|acc| acc.data)),
-/// )
-/// .await?;
-/// ```
-#[allow(clippy::too_many_arguments)]
-pub async fn add_extra_account_metas_for_execute<F, Fut>(
-    instruction: &mut Instruction,
-    program_id: &Pubkey,
-    source_pubkey: &Pubkey,
-    mint_pubkey: &Pubkey,
-    destination_pubkey: &Pubkey,
-    authority_pubkey: &Pubkey,
-    amount: u64,
-    fetch_account_data_fn: F,
-) -> Result<(), AccountFetchError>
-where
-    F: Fn(Pubkey) -> Fut,
-    Fut: Future<Output = AccountDataResult>,
-{
-    let validate_state_pubkey = get_extra_account_metas_address(mint_pubkey, program_id);
-    let validate_state_data = fetch_account_data_fn(validate_state_pubkey)
-        .await?
-        .ok_or(ProgramError::InvalidAccountData)?;
-
-    // Check to make sure the provided keys are in the instruction
-    if [
-        source_pubkey,
-        mint_pubkey,
-        destination_pubkey,
-        authority_pubkey,
-    ]
-    .iter()
-    .any(|&key| !instruction.accounts.iter().any(|meta| meta.pubkey == *key))
-    {
-        Err(TransferHookError::IncorrectAccount)?;
-    }
-
-    let mut execute_instruction = execute(
-        program_id,
-        source_pubkey,
-        mint_pubkey,
-        destination_pubkey,
-        authority_pubkey,
-        &validate_state_pubkey,
-        amount,
-    );
-
-    ExtraAccountMetaList::add_to_instruction::<ExecuteInstruction, _, _>(
-        &mut execute_instruction,
-        fetch_account_data_fn,
-        &validate_state_data,
-    )
-    .await?;
-
-    // Add only the extra accounts resolved from the validation state
-    instruction
-        .accounts
-        .extend_from_slice(&execute_instruction.accounts[5..]);
-
-    // Add the program id and validation state account
-    instruction
-        .accounts
-        .push(AccountMeta::new_readonly(*program_id, false));
-    instruction
-        .accounts
-        .push(AccountMeta::new_readonly(validate_state_pubkey, false));
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        spl_tlv_account_resolution::{account::ExtraAccountMeta, seeds::Seed},
-        tokio,
-    };
-
-    const PROGRAM_ID: Pubkey = Pubkey::new_from_array([1u8; 32]);
-    const EXTRA_META_1: Pubkey = Pubkey::new_from_array([2u8; 32]);
-    const EXTRA_META_2: Pubkey = Pubkey::new_from_array([3u8; 32]);
-
-    // Mock to return the validation state account data
-    async fn mock_fetch_account_data_fn(_address: Pubkey) -> AccountDataResult {
-        let extra_metas = vec![
-            ExtraAccountMeta::new_with_pubkey(&EXTRA_META_1, true, false).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&EXTRA_META_2, true, false).unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::AccountKey { index: 0 }, // source
-                    Seed::AccountKey { index: 2 }, // destination
-                    Seed::AccountKey { index: 4 }, // validation state
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::InstructionData {
-                        index: 8,
-                        length: 8,
-                    }, // amount
-                    Seed::AccountKey { index: 2 }, // destination
-                    Seed::AccountKey { index: 5 }, // extra meta 1
-                    Seed::AccountKey { index: 7 }, // extra meta 3 (PDA)
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-        ];
-        let account_size = ExtraAccountMetaList::size_of(extra_metas.len()).unwrap();
-        let mut data = vec![0u8; account_size];
-        ExtraAccountMetaList::init::<ExecuteInstruction>(&mut data, &extra_metas)?;
-        Ok(Some(data))
-    }
-
-    #[tokio::test]
-    async fn test_add_extra_account_metas_for_execute() {
-        let source = Pubkey::new_unique();
-        let mint = Pubkey::new_unique();
-        let destination = Pubkey::new_unique();
-        let authority = Pubkey::new_unique();
-        let amount = 100u64;
-
-        let validate_state_pubkey = get_extra_account_metas_address(&mint, &PROGRAM_ID);
-        let extra_meta_3_pubkey = Pubkey::find_program_address(
-            &[
-                source.as_ref(),
-                destination.as_ref(),
-                validate_state_pubkey.as_ref(),
-            ],
-            &PROGRAM_ID,
-        )
-        .0;
-        let extra_meta_4_pubkey = Pubkey::find_program_address(
-            &[
-                amount.to_le_bytes().as_ref(),
-                destination.as_ref(),
-                EXTRA_META_1.as_ref(),
-                extra_meta_3_pubkey.as_ref(),
-            ],
-            &PROGRAM_ID,
-        )
-        .0;
-
-        // Fail missing key
-        let mut instruction = Instruction::new_with_bytes(
-            PROGRAM_ID,
-            &[],
-            vec![
-                // source missing
-                AccountMeta::new_readonly(mint, false),
-                AccountMeta::new(destination, false),
-                AccountMeta::new_readonly(authority, true),
-            ],
-        );
-        assert_eq!(
-            add_extra_account_metas_for_execute(
-                &mut instruction,
-                &PROGRAM_ID,
-                &source,
-                &mint,
-                &destination,
-                &authority,
-                amount,
-                mock_fetch_account_data_fn,
-            )
-            .await
-            .unwrap_err()
-            .downcast::<TransferHookError>()
-            .unwrap(),
-            Box::new(TransferHookError::IncorrectAccount)
-        );
-
-        // Success
-        let mut instruction = Instruction::new_with_bytes(
-            PROGRAM_ID,
-            &[],
-            vec![
-                AccountMeta::new(source, false),
-                AccountMeta::new_readonly(mint, false),
-                AccountMeta::new(destination, false),
-                AccountMeta::new_readonly(authority, true),
-            ],
-        );
-        add_extra_account_metas_for_execute(
-            &mut instruction,
-            &PROGRAM_ID,
-            &source,
-            &mint,
-            &destination,
-            &authority,
-            amount,
-            mock_fetch_account_data_fn,
-        )
-        .await
-        .unwrap();
-
-        let check_metas = [
-            AccountMeta::new(source, false),
-            AccountMeta::new_readonly(mint, false),
-            AccountMeta::new(destination, false),
-            AccountMeta::new_readonly(authority, true),
-            AccountMeta::new_readonly(EXTRA_META_1, true),
-            AccountMeta::new_readonly(EXTRA_META_2, true),
-            AccountMeta::new(extra_meta_3_pubkey, false),
-            AccountMeta::new(extra_meta_4_pubkey, false),
-            AccountMeta::new_readonly(PROGRAM_ID, false),
-            AccountMeta::new_readonly(validate_state_pubkey, false),
-        ];
-
-        assert_eq!(instruction.accounts, check_metas);
-    }
-}
diff --git a/token/transfer-hook/interface/src/onchain.rs b/token/transfer-hook/interface/src/onchain.rs
deleted file mode 100644
index 41c2ec1b27a..00000000000
--- a/token/transfer-hook/interface/src/onchain.rs
+++ /dev/null
@@ -1,493 +0,0 @@
-//! On-chain program invoke helper to perform on-chain `execute` with correct
-//! accounts
-
-use {
-    crate::{error::TransferHookError, get_extra_account_metas_address, instruction},
-    solana_program::{
-        account_info::AccountInfo,
-        entrypoint::ProgramResult,
-        instruction::{AccountMeta, Instruction},
-        program::invoke,
-        pubkey::Pubkey,
-    },
-    spl_tlv_account_resolution::state::ExtraAccountMetaList,
-};
-/// Helper to CPI into a transfer-hook program on-chain, looking through the
-/// additional account infos to create the proper instruction
-pub fn invoke_execute<'a>(
-    program_id: &Pubkey,
-    source_info: AccountInfo<'a>,
-    mint_info: AccountInfo<'a>,
-    destination_info: AccountInfo<'a>,
-    authority_info: AccountInfo<'a>,
-    additional_accounts: &[AccountInfo<'a>],
-    amount: u64,
-) -> ProgramResult {
-    let validation_pubkey = get_extra_account_metas_address(mint_info.key, program_id);
-    let validation_info = additional_accounts
-        .iter()
-        .find(|&x| *x.key == validation_pubkey)
-        .ok_or(TransferHookError::IncorrectAccount)?;
-    let mut cpi_instruction = instruction::execute(
-        program_id,
-        source_info.key,
-        mint_info.key,
-        destination_info.key,
-        authority_info.key,
-        &validation_pubkey,
-        amount,
-    );
-
-    let mut cpi_account_infos = vec![
-        source_info,
-        mint_info,
-        destination_info,
-        authority_info,
-        validation_info.clone(),
-    ];
-    ExtraAccountMetaList::add_to_cpi_instruction::<instruction::ExecuteInstruction>(
-        &mut cpi_instruction,
-        &mut cpi_account_infos,
-        &validation_info.try_borrow_data()?,
-        additional_accounts,
-    )?;
-    invoke(&cpi_instruction, &cpi_account_infos)
-}
-
-/// Helper to add accounts required for an `ExecuteInstruction` on-chain,
-/// looking through the additional account infos to add the proper accounts.
-///
-/// Note this helper is designed to add the extra accounts that will be
-/// required for a CPI to a transfer hook program. However, the instruction
-/// being provided to this helper is for the program that will CPI to the
-/// transfer hook program. Because of this, we must resolve the extra accounts
-/// for the `ExecuteInstruction` CPI, then add those extra resolved accounts to
-/// the provided instruction.
-#[allow(clippy::too_many_arguments)]
-pub fn add_extra_accounts_for_execute_cpi<'a>(
-    cpi_instruction: &mut Instruction,
-    cpi_account_infos: &mut Vec<AccountInfo<'a>>,
-    program_id: &Pubkey,
-    source_info: AccountInfo<'a>,
-    mint_info: AccountInfo<'a>,
-    destination_info: AccountInfo<'a>,
-    authority_info: AccountInfo<'a>,
-    amount: u64,
-    additional_accounts: &[AccountInfo<'a>],
-) -> ProgramResult {
-    let validate_state_pubkey = get_extra_account_metas_address(mint_info.key, program_id);
-    let validate_state_info = additional_accounts
-        .iter()
-        .find(|&x| *x.key == validate_state_pubkey)
-        .ok_or(TransferHookError::IncorrectAccount)?;
-
-    let program_info = additional_accounts
-        .iter()
-        .find(|&x| x.key == program_id)
-        .ok_or(TransferHookError::IncorrectAccount)?;
-
-    let mut execute_instruction = instruction::execute(
-        program_id,
-        source_info.key,
-        mint_info.key,
-        destination_info.key,
-        authority_info.key,
-        &validate_state_pubkey,
-        amount,
-    );
-    let mut execute_account_infos = vec![
-        source_info,
-        mint_info,
-        destination_info,
-        authority_info,
-        validate_state_info.clone(),
-    ];
-
-    ExtraAccountMetaList::add_to_cpi_instruction::<instruction::ExecuteInstruction>(
-        &mut execute_instruction,
-        &mut execute_account_infos,
-        &validate_state_info.try_borrow_data()?,
-        additional_accounts,
-    )?;
-
-    // Add only the extra accounts resolved from the validation state
-    cpi_instruction
-        .accounts
-        .extend_from_slice(&execute_instruction.accounts[5..]);
-    cpi_account_infos.extend_from_slice(&execute_account_infos[5..]);
-
-    // Add the program id and validation state account
-    cpi_instruction
-        .accounts
-        .push(AccountMeta::new_readonly(*program_id, false));
-    cpi_instruction
-        .accounts
-        .push(AccountMeta::new_readonly(validate_state_pubkey, false));
-    cpi_account_infos.push(program_info.clone());
-    cpi_account_infos.push(validate_state_info.clone());
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::instruction::ExecuteInstruction,
-        solana_program::{bpf_loader_upgradeable, system_program},
-        spl_tlv_account_resolution::{
-            account::ExtraAccountMeta, error::AccountResolutionError, seeds::Seed,
-        },
-    };
-
-    const EXTRA_META_1: Pubkey = Pubkey::new_from_array([2u8; 32]);
-    const EXTRA_META_2: Pubkey = Pubkey::new_from_array([3u8; 32]);
-
-    fn setup_validation_data() -> Vec<u8> {
-        let extra_metas = vec![
-            ExtraAccountMeta::new_with_pubkey(&EXTRA_META_1, true, false).unwrap(),
-            ExtraAccountMeta::new_with_pubkey(&EXTRA_META_2, true, false).unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::AccountKey { index: 0 }, // source
-                    Seed::AccountKey { index: 2 }, // destination
-                    Seed::AccountKey { index: 4 }, // validation state
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-            ExtraAccountMeta::new_with_seeds(
-                &[
-                    Seed::InstructionData {
-                        index: 8,
-                        length: 8,
-                    }, // amount
-                    Seed::AccountKey { index: 2 }, // destination
-                    Seed::AccountKey { index: 5 }, // extra meta 1
-                    Seed::AccountKey { index: 7 }, // extra meta 3 (PDA)
-                ],
-                false,
-                true,
-            )
-            .unwrap(),
-        ];
-        let account_size = ExtraAccountMetaList::size_of(extra_metas.len()).unwrap();
-        let mut data = vec![0u8; account_size];
-        ExtraAccountMetaList::init::<ExecuteInstruction>(&mut data, &extra_metas).unwrap();
-        data
-    }
-
-    #[test]
-    fn test_add_extra_accounts_for_execute_cpi() {
-        let spl_token_2022_program_id = Pubkey::new_unique(); // Mock
-        let transfer_hook_program_id = Pubkey::new_unique();
-
-        let amount = 100u64;
-
-        let source_pubkey = Pubkey::new_unique();
-        let mut source_data = vec![0; 165]; // Mock
-        let mut source_lamports = 0; // Mock
-        let source_account_info = AccountInfo::new(
-            &source_pubkey,
-            false,
-            true,
-            &mut source_lamports,
-            &mut source_data,
-            &spl_token_2022_program_id,
-            false,
-            0,
-        );
-
-        let mint_pubkey = Pubkey::new_unique();
-        let mut mint_data = vec![0; 165]; // Mock
-        let mut mint_lamports = 0; // Mock
-        let mint_account_info = AccountInfo::new(
-            &mint_pubkey,
-            false,
-            true,
-            &mut mint_lamports,
-            &mut mint_data,
-            &spl_token_2022_program_id,
-            false,
-            0,
-        );
-
-        let destination_pubkey = Pubkey::new_unique();
-        let mut destination_data = vec![0; 165]; // Mock
-        let mut destination_lamports = 0; // Mock
-        let destination_account_info = AccountInfo::new(
-            &destination_pubkey,
-            false,
-            true,
-            &mut destination_lamports,
-            &mut destination_data,
-            &spl_token_2022_program_id,
-            false,
-            0,
-        );
-
-        let authority_pubkey = Pubkey::new_unique();
-        let mut authority_data = vec![]; // Mock
-        let mut authority_lamports = 0; // Mock
-        let authority_account_info = AccountInfo::new(
-            &authority_pubkey,
-            false,
-            true,
-            &mut authority_lamports,
-            &mut authority_data,
-            &system_program::ID,
-            false,
-            0,
-        );
-
-        let validate_state_pubkey =
-            get_extra_account_metas_address(&mint_pubkey, &transfer_hook_program_id);
-
-        let extra_meta_1_pubkey = EXTRA_META_1;
-        let mut extra_meta_1_data = vec![]; // Mock
-        let mut extra_meta_1_lamports = 0; // Mock
-        let extra_meta_1_account_info = AccountInfo::new(
-            &extra_meta_1_pubkey,
-            true,
-            false,
-            &mut extra_meta_1_lamports,
-            &mut extra_meta_1_data,
-            &system_program::ID,
-            false,
-            0,
-        );
-
-        let extra_meta_2_pubkey = EXTRA_META_2;
-        let mut extra_meta_2_data = vec![]; // Mock
-        let mut extra_meta_2_lamports = 0; // Mock
-        let extra_meta_2_account_info = AccountInfo::new(
-            &extra_meta_2_pubkey,
-            true,
-            false,
-            &mut extra_meta_2_lamports,
-            &mut extra_meta_2_data,
-            &system_program::ID,
-            false,
-            0,
-        );
-
-        let extra_meta_3_pubkey = Pubkey::find_program_address(
-            &[
-                &source_pubkey.to_bytes(),
-                &destination_pubkey.to_bytes(),
-                &validate_state_pubkey.to_bytes(),
-            ],
-            &transfer_hook_program_id,
-        )
-        .0;
-        let mut extra_meta_3_data = vec![]; // Mock
-        let mut extra_meta_3_lamports = 0; // Mock
-        let extra_meta_3_account_info = AccountInfo::new(
-            &extra_meta_3_pubkey,
-            false,
-            true,
-            &mut extra_meta_3_lamports,
-            &mut extra_meta_3_data,
-            &transfer_hook_program_id,
-            false,
-            0,
-        );
-
-        let extra_meta_4_pubkey = Pubkey::find_program_address(
-            &[
-                &amount.to_le_bytes(),
-                &destination_pubkey.to_bytes(),
-                &extra_meta_1_pubkey.to_bytes(),
-                &extra_meta_3_pubkey.to_bytes(),
-            ],
-            &transfer_hook_program_id,
-        )
-        .0;
-        let mut extra_meta_4_data = vec![]; // Mock
-        let mut extra_meta_4_lamports = 0; // Mock
-        let extra_meta_4_account_info = AccountInfo::new(
-            &extra_meta_4_pubkey,
-            false,
-            true,
-            &mut extra_meta_4_lamports,
-            &mut extra_meta_4_data,
-            &transfer_hook_program_id,
-            false,
-            0,
-        );
-
-        let mut validate_state_data = setup_validation_data();
-        let mut validate_state_lamports = 0; // Mock
-        let validate_state_account_info = AccountInfo::new(
-            &validate_state_pubkey,
-            false,
-            true,
-            &mut validate_state_lamports,
-            &mut validate_state_data,
-            &transfer_hook_program_id,
-            false,
-            0,
-        );
-
-        let mut transfer_hook_program_data = vec![]; // Mock
-        let mut transfer_hook_program_lamports = 0; // Mock
-        let transfer_hook_program_account_info = AccountInfo::new(
-            &transfer_hook_program_id,
-            false,
-            true,
-            &mut transfer_hook_program_lamports,
-            &mut transfer_hook_program_data,
-            &bpf_loader_upgradeable::ID,
-            false,
-            0,
-        );
-
-        let mut cpi_instruction = Instruction::new_with_bytes(
-            spl_token_2022_program_id,
-            &[],
-            vec![
-                AccountMeta::new(source_pubkey, false),
-                AccountMeta::new_readonly(mint_pubkey, false),
-                AccountMeta::new(destination_pubkey, false),
-                AccountMeta::new_readonly(authority_pubkey, true),
-            ],
-        );
-        let mut cpi_account_infos = vec![
-            source_account_info.clone(),
-            mint_account_info.clone(),
-            destination_account_info.clone(),
-            authority_account_info.clone(),
-        ];
-        let additional_account_infos = vec![
-            extra_meta_1_account_info.clone(),
-            extra_meta_2_account_info.clone(),
-            extra_meta_3_account_info.clone(),
-            extra_meta_4_account_info.clone(),
-            transfer_hook_program_account_info.clone(),
-            validate_state_account_info.clone(),
-        ];
-
-        // Fail missing validation info from additional account infos
-        let additional_account_infos_missing_infos = vec![
-            extra_meta_1_account_info.clone(),
-            extra_meta_2_account_info.clone(),
-            extra_meta_3_account_info.clone(),
-            extra_meta_4_account_info.clone(),
-            // validate state missing
-            transfer_hook_program_account_info.clone(),
-        ];
-        assert_eq!(
-            add_extra_accounts_for_execute_cpi(
-                &mut cpi_instruction,
-                &mut cpi_account_infos,
-                &transfer_hook_program_id,
-                source_account_info.clone(),
-                mint_account_info.clone(),
-                destination_account_info.clone(),
-                authority_account_info.clone(),
-                amount,
-                &additional_account_infos_missing_infos, // Missing account info
-            )
-            .unwrap_err(),
-            TransferHookError::IncorrectAccount.into()
-        );
-
-        // Fail missing program info from additional account infos
-        let additional_account_infos_missing_infos = vec![
-            extra_meta_1_account_info.clone(),
-            extra_meta_2_account_info.clone(),
-            extra_meta_3_account_info.clone(),
-            extra_meta_4_account_info.clone(),
-            validate_state_account_info.clone(),
-            // transfer hook program missing
-        ];
-        assert_eq!(
-            add_extra_accounts_for_execute_cpi(
-                &mut cpi_instruction,
-                &mut cpi_account_infos,
-                &transfer_hook_program_id,
-                source_account_info.clone(),
-                mint_account_info.clone(),
-                destination_account_info.clone(),
-                authority_account_info.clone(),
-                amount,
-                &additional_account_infos_missing_infos, // Missing account info
-            )
-            .unwrap_err(),
-            TransferHookError::IncorrectAccount.into()
-        );
-
-        // Fail missing extra meta info from additional account infos
-        let additional_account_infos_missing_infos = vec![
-            extra_meta_1_account_info.clone(),
-            extra_meta_2_account_info.clone(),
-            // extra meta 3 missing
-            extra_meta_4_account_info.clone(),
-            validate_state_account_info.clone(),
-            transfer_hook_program_account_info.clone(),
-        ];
-        assert_eq!(
-            add_extra_accounts_for_execute_cpi(
-                &mut cpi_instruction,
-                &mut cpi_account_infos,
-                &transfer_hook_program_id,
-                source_account_info.clone(),
-                mint_account_info.clone(),
-                destination_account_info.clone(),
-                authority_account_info.clone(),
-                amount,
-                &additional_account_infos_missing_infos, // Missing account info
-            )
-            .unwrap_err(),
-            AccountResolutionError::IncorrectAccount.into() // Note the error
-        );
-
-        // Success
-        add_extra_accounts_for_execute_cpi(
-            &mut cpi_instruction,
-            &mut cpi_account_infos,
-            &transfer_hook_program_id,
-            source_account_info.clone(),
-            mint_account_info.clone(),
-            destination_account_info.clone(),
-            authority_account_info.clone(),
-            amount,
-            &additional_account_infos,
-        )
-        .unwrap();
-
-        let check_metas = [
-            AccountMeta::new(source_pubkey, false),
-            AccountMeta::new_readonly(mint_pubkey, false),
-            AccountMeta::new(destination_pubkey, false),
-            AccountMeta::new_readonly(authority_pubkey, true),
-            AccountMeta::new_readonly(EXTRA_META_1, true),
-            AccountMeta::new_readonly(EXTRA_META_2, true),
-            AccountMeta::new(extra_meta_3_pubkey, false),
-            AccountMeta::new(extra_meta_4_pubkey, false),
-            AccountMeta::new_readonly(transfer_hook_program_id, false),
-            AccountMeta::new_readonly(validate_state_pubkey, false),
-        ];
-
-        let check_account_infos = vec![
-            source_account_info,
-            mint_account_info,
-            destination_account_info,
-            authority_account_info,
-            extra_meta_1_account_info,
-            extra_meta_2_account_info,
-            extra_meta_3_account_info,
-            extra_meta_4_account_info,
-            transfer_hook_program_account_info,
-            validate_state_account_info,
-        ];
-
-        assert_eq!(cpi_instruction.accounts, check_metas);
-        for (a, b) in std::iter::zip(cpi_account_infos, check_account_infos) {
-            assert_eq!(a.key, b.key);
-            assert_eq!(a.is_signer, b.is_signer);
-            assert_eq!(a.is_writable, b.is_writable);
-        }
-    }
-}
diff --git a/token/twoxtx-setup.sh b/token/twoxtx-setup.sh
deleted file mode 100755
index 813971ab0be..00000000000
--- a/token/twoxtx-setup.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-#
-# Patch in a Solana monorepo that supports 2x transactions for testing the
-# SPL Token 2022 Confidential Transfer extension
-#
-
-set -e
-
-here="$(dirname "$0")"
-cd "$here"
-
-if [[ ! -d twoxtx-solana ]]; then
-  if [[ -n $CI ]]; then
-    git config --global user.email "you@example.com"
-    git config --global user.name "Your Name"
-    git clone https://github.com/solana-labs/solana.git twoxtx-solana
-  else
-    git clone git@github.com:solana-labs/solana.git twoxtx-solana
-  fi
-fi
-
-if [[ ! -f twoxtx-solana/.twoxtx-patched ]]; then
-  git -C twoxtx-solana am -3 "$PWD"/twoxtx.patch
-  touch twoxtx-solana/.twoxtx-patched
-fi
-
-../patch.crates-io.sh twoxtx-solana
-
-exit 0
diff --git a/token/twoxtx.patch b/token/twoxtx.patch
deleted file mode 100644
index bd1ea0a9032..00000000000
--- a/token/twoxtx.patch
+++ /dev/null
@@ -1,131 +0,0 @@
-From e5f7a7a9584edd4eef3c06df2d33069b78770c4a Mon Sep 17 00:00:00 2001
-From: Jon Cinque <jon.cinque@gmail.com>
-Date: Wed, 31 Aug 2022 01:44:22 +0200
-Subject: [PATCH] Multiply packet size by 2
-
----
- ledger/src/shred.rs                  |  2 +-
- ledger/src/shred/legacy.rs           |  6 +++---
- ledger/src/shred/merkle.rs           |  2 +-
- ledger/src/shred/shred_code.rs       |  2 +-
- rpc/src/rpc.rs                       | 16 +++++++++++-----
- sdk/src/packet.rs                    |  3 ++-
- 6 files changed, 19 insertions(+), 12 deletions(-)
-
-diff --git a/ledger/src/shred.rs b/ledger/src/shred.rs
-index 0695236214..1c52b164a9 100644
---- a/ledger/src/shred.rs
-+++ b/ledger/src/shred.rs
-@@ -112,7 +112,7 @@ const OFFSET_OF_SHRED_INDEX: usize = OFFSET_OF_SHRED_SLOT + SIZE_OF_SHRED_SLOT;
- pub const DATA_SHREDS_PER_FEC_BLOCK: usize = 32;
-
- // For legacy tests and benchmarks.
--const_assert_eq!(LEGACY_SHRED_DATA_CAPACITY, 1051);
-+const_assert_eq!(LEGACY_SHRED_DATA_CAPACITY, 2283);
- pub const LEGACY_SHRED_DATA_CAPACITY: usize = legacy::ShredData::CAPACITY;
-
- // LAST_SHRED_IN_SLOT also implies DATA_COMPLETE_SHRED.
-diff --git a/ledger/src/shred/legacy.rs b/ledger/src/shred/legacy.rs
-index ca6310bdcb..c0ab2b1de4 100644
---- a/ledger/src/shred/legacy.rs
-+++ b/ledger/src/shred/legacy.rs
-@@ -17,12 +17,12 @@ use {
- // Code and data shreds have the same payload size.
- pub(super) const SIGNED_MESSAGE_RANGE: Range<usize> = SIZE_OF_SIGNATURE..ShredData::SIZE_OF_PAYLOAD;
- const_assert_eq!(ShredData::SIZE_OF_PAYLOAD, ShredCode::SIZE_OF_PAYLOAD);
--const_assert_eq!(ShredData::SIZE_OF_PAYLOAD, 1228);
--const_assert_eq!(ShredData::CAPACITY, 1051);
-+const_assert_eq!(ShredData::SIZE_OF_PAYLOAD, 2460);
-+const_assert_eq!(ShredData::CAPACITY, 2283);
-
- // ShredCode::SIZE_OF_HEADERS bytes at the end of data shreds
- // is never used and is not part of erasure coding.
--const_assert_eq!(SIZE_OF_ERASURE_ENCODED_SLICE, 1139);
-+const_assert_eq!(SIZE_OF_ERASURE_ENCODED_SLICE, 2371);
- pub(super) const SIZE_OF_ERASURE_ENCODED_SLICE: usize =
-     ShredCode::SIZE_OF_PAYLOAD - ShredCode::SIZE_OF_HEADERS;
-
-diff --git a/ledger/src/shred/merkle.rs b/ledger/src/shred/merkle.rs
-index 90b686f5c8..ff47c745d1 100644
---- a/ledger/src/shred/merkle.rs
-+++ b/ledger/src/shred/merkle.rs
-@@ -39,7 +39,7 @@ const_assert_eq!(SIZE_OF_MERKLE_ROOT, 20);
- const SIZE_OF_MERKLE_ROOT: usize = std::mem::size_of::<MerkleRoot>();
- const_assert_eq!(SIZE_OF_MERKLE_PROOF_ENTRY, 20);
- const SIZE_OF_MERKLE_PROOF_ENTRY: usize = std::mem::size_of::<MerkleProofEntry>();
--const_assert_eq!(ShredData::SIZE_OF_PAYLOAD, 1203);
-+const_assert_eq!(ShredData::SIZE_OF_PAYLOAD, 2435);
-
- // Defense against second preimage attack:
- // https://en.wikipedia.org/wiki/Merkle_tree#Second_preimage_attack
-diff --git a/ledger/src/shred/shred_code.rs b/ledger/src/shred/shred_code.rs
-index 3b01b8826d..3e3ebfbf78 100644
---- a/ledger/src/shred/shred_code.rs
-+++ b/ledger/src/shred/shred_code.rs
-@@ -17,7 +17,7 @@ const_assert_eq!(MAX_CODE_SHREDS_PER_SLOT, 32_768 * 17);
- pub(crate) const MAX_CODE_SHREDS_PER_SLOT: usize =
-     MAX_DATA_SHREDS_PER_SLOT * (ERASURE_BATCH_SIZE[1] - 1);
-
--const_assert_eq!(ShredCode::SIZE_OF_PAYLOAD, 1228);
-+const_assert_eq!(ShredCode::SIZE_OF_PAYLOAD, 2460);
-
- #[derive(Clone, Debug, Eq, PartialEq)]
- pub enum ShredCode {
-diff --git a/rpc/src/rpc.rs b/rpc/src/rpc.rs
-index 1167b21eaf..c9689f7039 100644
---- a/rpc/src/rpc.rs
-+++ b/rpc/src/rpc.rs
-@@ -4478,8 +4478,11 @@ pub mod rpc_obsolete_v1_7 {
-     }
- }
-
--const MAX_BASE58_SIZE: usize = 1683; // Golden, bump if PACKET_DATA_SIZE changes
--const MAX_BASE64_SIZE: usize = 1644; // Golden, bump if PACKET_DATA_SIZE changes
-+// These values need to be updated if PACKET_DATA_SIZE changes. The correct values can
-+// be found by hand or by simply encoding `PACKET_DATA_SIZE` bytes and checking length.
-+// `test_max_encoded_tx_goldens` ensures these values are correct.
-+const MAX_BASE58_SIZE: usize = 3365;
-+const MAX_BASE64_SIZE: usize = 3288;
- fn decode_and_deserialize<T>(
-     encoded: String,
-     encoding: TransactionBinaryEncoding,
-@@ -8773,7 +8776,7 @@ pub mod tests {
-     }
-
-     #[test]
--    fn test_worst_case_encoded_tx_goldens() {
-+    fn test_max_encoded_tx_goldens() {
-         let ff_tx = vec![0xffu8; PACKET_DATA_SIZE];
-         let tx58 = bs58::encode(&ff_tx).into_string();
-         assert_eq!(tx58.len(), MAX_BASE58_SIZE);
-@@ -8783,8 +8786,11 @@ pub mod tests {
-
-     #[test]
-     fn test_decode_and_deserialize_too_large_payloads_fail() {
--        // +2 because +1 still fits in base64 encoded worst-case
--        let too_big = PACKET_DATA_SIZE + 2;
-+        // 4 base64 digits are generated from groups of 3 bytes; however, those 4 digits
-+        // are generated even if the group only has 1 or 2 bytes.
-+        // So, we need 4 - (PACKET_DATA_SIZE % 3) extra bytes to ensure we'll spill over
-+        let extra_bytes = 4 - (PACKET_DATA_SIZE % 3);
-+        let too_big = PACKET_DATA_SIZE + extra_bytes;
-         let tx_ser = vec![0xffu8; too_big];
-
-         let tx58 = bs58::encode(&tx_ser).into_string();
-diff --git a/sdk/src/packet.rs b/sdk/src/packet.rs
-index 08389860f9..12714028d7 100644
---- a/sdk/src/packet.rs
-+++ b/sdk/src/packet.rs
-@@ -15,7 +15,8 @@ static_assertions::const_assert_eq!(PACKET_DATA_SIZE, 1232);
- ///   1280 is IPv6 minimum MTU
- ///   40 bytes is the size of the IPv6 header
- ///   8 bytes is the size of the fragment header
--pub const PACKET_DATA_SIZE: usize = 1280 - 40 - 8;
-+/// Double the minimum to support larger than MTU transactions
-+pub const PACKET_DATA_SIZE: usize = 2 * (1280 - 40 - 8);
-
- bitflags! {
-     #[repr(C)]
---
-2.38.1
-
diff --git a/token/zk-token-protocol-paper/part1.pdf b/token/zk-token-protocol-paper/part1.pdf
deleted file mode 100644
index 41384d32d03..00000000000
Binary files a/token/zk-token-protocol-paper/part1.pdf and /dev/null differ
diff --git a/token/zk-token-protocol-paper/part2.pdf b/token/zk-token-protocol-paper/part2.pdf
deleted file mode 100644
index 09ed0e81232..00000000000
Binary files a/token/zk-token-protocol-paper/part2.pdf and /dev/null differ
diff --git a/update-solana-dependencies.sh b/update-solana-dependencies.sh
index 8ada72c6634..04d5b3afc65 100755
--- a/update-solana-dependencies.sh
+++ b/update-solana-dependencies.sh
@@ -21,26 +21,32 @@ while IFS='' read -r line; do tomls+=("$line"); done < <(find . -name Cargo.toml
 
 crates=(
   solana-account-decoder
+  solana-account-decoder-client-types
   solana-banks-client
   solana-banks-interface
   solana-banks-server
   solana-bloom
   solana-bucket-map
+  solana-builtins-default-costs
   solana-clap-utils
   solana-clap-v3-utils
   solana-cli-config
   solana-cli-output
   solana-client
+  solana-compute-budget
   solana-connection-cache
   solana-core
   solana-entry
   solana-faucet
+  solana-fee
   solana-frozen-abi
   solana-frozen-abi-macro
-  solana-geyser-plugin-interface
+  agave-geyser-plugin-interface
   solana-geyser-plugin-manager
   solana-gossip
+  solana-lattice-hash
   solana-ledger
+  solana-log-collector
   solana-logger
   solana-measure
   solana-merkle-tree
@@ -55,7 +61,9 @@ crates=(
   solana-compute-budget-program
   solana-config-program
   solana-stake-program
+  solana-system-program
   solana-vote-program
+  solana-zk-elgamal-proof-program
   solana-zk-token-proof-program
   solana-pubsub-client
   solana-quic-client
@@ -66,6 +74,7 @@ crates=(
   solana-rpc-client-api
   solana-rpc-client-nonce-utils
   solana-runtime
+  solana-runtime-transaction
   solana-sdk
   solana-sdk-macro
   solana-program
@@ -73,13 +82,58 @@ crates=(
   solana-storage-bigtable
   solana-storage-proto
   solana-streamer
+  solana-svm-rent-collector
+  solana-svm-transaction
   solana-test-validator
   solana-thin-client
   solana-tpu-client
   solana-transaction-status
+  solana-transaction-status-client-types
   solana-udp-client
   solana-version
   solana-zk-token-sdk
+  solana-zk-sdk
+  solana-bn254
+  solana-curve25519
+  solana-secp256k1-recover
+  solana-account
+  solana-account-info
+  solana-atomic-u64
+  solana-bincode
+  solana-borsh
+  solana-clock
+  solana-cpi
+  solana-decode-error
+  solana-define-syscall
+  solana-derivation-path
+  solana-epoch-schedule
+  solana-feature-set
+  solana-fee-calculator
+  solana-hash
+  solana-inflation
+  solana-instruction
+  solana-last-restart-slot
+  solana-msg
+  solana-native-token
+  solana-packet
+  solana-precompile-error
+  solana-program-entrypoint
+  solana-program-error
+  solana-program-memory
+  solana-program-option
+  solana-program-pack
+  solana-pubkey
+  solana-rent
+  solana-sanitize
+  solana-serde-varint
+  solana-serialize-utils
+  solana-sha256-hasher
+  solana-short-vec
+  solana-signature
+  solana-slot-hashes
+  solana-stable-layout
+  solana-timings
+  solana-transaction-error
 )
 
 set -x
diff --git a/utils/test-client/Cargo.toml b/utils/test-client/Cargo.toml
index c2ac24f44a4..12f53134e6b 100644
--- a/utils/test-client/Cargo.toml
+++ b/utils/test-client/Cargo.toml
@@ -8,7 +8,7 @@ edition = "2021"
 # Used to ensure that SPL programs are buildable by external clients
 
 [dependencies]
-solana-sdk = ">=1.18.11,<=2"
-spl-memo = { path = "../../memo/program", features = [ "no-entrypoint" ] }
-spl-token = { path = "../../token/program", features = [ "no-entrypoint" ] }
+solana-sdk = "2.1.0"
+spl-memo = { version = "6.0.0", features = [ "no-entrypoint" ] }
+spl-token = { version = "7.0.0", features = [ "no-entrypoint" ] }
 spl-token-swap = { path = "../../token-swap/program", features = [ "no-entrypoint" ] }