diff --git a/.env b/.env
index d2ae86f..9d06cc5 100644
--- a/.env
+++ b/.env
@@ -1 +1 @@
-versions_for_test="1.16.13"
+versions_for_test="1.16.14"
diff --git a/Cargo.lock b/Cargo.lock
index cdfabc4..59cb224 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2349,9 +2349,9 @@ dependencies = [
 
 [[package]]
 name = "solana-account-decoder"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b83daa56035885dac1a47f5bd3d4e02379e3fc5915b2c3ce978a9af9eeecf07d"
+checksum = "f0ada16ccd5ca6884ae28b716211c4f09d22225a9ebde14eccd4f605cc321e42"
 dependencies = [
  "Inflector",
  "base64 0.21.4",
@@ -2373,9 +2373,9 @@ dependencies = [
 
 [[package]]
 name = "solana-address-lookup-table-program"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dd3f3e85d67e559985fbdc6b5b4d5dd9c8462b78e6079c3b465496c1f3c55d6"
+checksum = "248b435722d18100b70bb8f09fd38b8a8c46031a0de86f6b31768f64cf4092c5"
 dependencies = [
  "bincode",
  "bytemuck",
@@ -2394,9 +2394,9 @@ dependencies = [
 
 [[package]]
 name = "solana-config-program"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a35e4cc9f2996a2ef95aac398443fc4a110ef585521e11a7685b3591648b7cf"
+checksum = "e0622d8798d060c84883572483f214b0d5c1640450e4322483cfe2e72823a6d7"
 dependencies = [
  "bincode",
  "chrono",
@@ -2408,9 +2408,9 @@ dependencies = [
 
 [[package]]
 name = "solana-frozen-abi"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35b9e2169fd13394af838b13f047067c35ce69372aea0fb46e026405b5e931f9"
+checksum = "0e74d294241df12a73a229e38a819e810d54234da494c3d43f8a1a828631047d"
 dependencies = [
  "ahash 0.8.3",
  "blake3",
@@ -2441,9 +2441,9 @@ dependencies = [
 
 [[package]]
 name = "solana-frozen-abi-macro"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db08ab0af4007dc0954b900aa5febc0c0ae50d9f9f598be27263c3195d90240b"
+checksum = "4dabde7fbd88a68eb083ae9d6d5f6855b7ba1bfc45d200c786b1b448ac49da5f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2453,9 +2453,9 @@ dependencies = [
 
 [[package]]
 name = "solana-geyser-plugin-interface"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c09d7686f1f891dc1788378efd610e2f2c2515210ccafd173e490617a5de23a3"
+checksum = "908cad0de1330b6b05d6cb6a9f5004df22a9fe46529d6bf6839835ba345ef966"
 dependencies = [
  "log",
  "solana-sdk",
@@ -2487,9 +2487,9 @@ dependencies = [
 
 [[package]]
 name = "solana-logger"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf8a48e734f78a44399516f7c130c114b455911e351f001abc0d96e7c5694efa"
+checksum = "24dc0037a389d782c8de3c6f509b74efa1d60523ef9e5561cefe41f1a354fee0"
 dependencies = [
  "env_logger",
  "lazy_static",
@@ -2498,9 +2498,9 @@ dependencies = [
 
 [[package]]
 name = "solana-measure"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3529d2ff63ceedd3707c51188aacb9e3c142118de3f55447c40584a78223ffd"
+checksum = "19563c27f12801e0e65b42d0f216db1d910dfeaad88d8f1335dd6369697eda60"
 dependencies = [
  "log",
  "solana-sdk",
@@ -2508,9 +2508,9 @@ dependencies = [
 
 [[package]]
 name = "solana-metrics"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4792f29de5378a13c51be3fa9fdd526a20550b5ffabd7d1a57a4e49468e17d90"
+checksum = "7f74c557e821c7ff48c9b4ef4ab3a296918d7fb745e3f2e820ebdb38e8e3555b"
 dependencies = [
  "crossbeam-channel",
  "gethostname",
@@ -2522,9 +2522,9 @@ dependencies = [
 
 [[package]]
 name = "solana-program"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f17a1fbcf1e94e282db16153d323b446d6386ac99f597f78e76332265829336"
+checksum = "3a2faeb9c89b354b547a229e3b39fa8fd6d11c78362ba8580f0c4721739725b6"
 dependencies = [
  "ark-bn254",
  "ark-ec",
@@ -2577,9 +2577,9 @@ dependencies = [
 
 [[package]]
 name = "solana-program-runtime"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ff9f0c8043b2e7921e25a3fee88fa253b8cb5dbab1e521a4d83e78e8874c551"
+checksum = "9f65907a405764cda63be89335ffd2138ade18f065e5cae09d20adab7fb09502"
 dependencies = [
  "base64 0.21.4",
  "bincode",
@@ -2605,9 +2605,9 @@ dependencies = [
 
 [[package]]
 name = "solana-sdk"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74a01f25b9f4022fc222c21c589ef7943027fb0fa2b9f6ae943fc4a65c2c01a2"
+checksum = "57f4046d0d487e3d79be809ff29c63c1484793956e6ccbc5d3307b0aafbf989d"
 dependencies = [
  "assert_matches",
  "base64 0.21.4",
@@ -2658,9 +2658,9 @@ dependencies = [
 
 [[package]]
 name = "solana-sdk-macro"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75b33716470fa4a65a23ddc2d4abcb8d28532c6e3ae3f04f4fe79b5e1f8c247"
+checksum = "760fdfd4b7edb02fd9173a6dcec899ffae06ac21b66b65f8c7c5f3d17b12fa64"
 dependencies = [
  "bs58",
  "proc-macro2",
@@ -2671,9 +2671,9 @@ dependencies = [
 
 [[package]]
 name = "solana-transaction-status"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9266f75afa4163c9a5f29f1066f907e87482858749942380d6538af567b44c7"
+checksum = "8bdf7379a72c051d7879f1c36cfdab5fed0653a2a613718bc5d343e44e603401"
 dependencies = [
  "Inflector",
  "base64 0.21.4",
@@ -2697,9 +2697,9 @@ dependencies = [
 
 [[package]]
 name = "solana-zk-token-sdk"
-version = "1.16.13"
+version = "1.16.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1669c9d223d850cd96cad69d3ba1a4234bc3e2f83ac837fbdbc0ce774dac7b92"
+checksum = "3bdec366a15133a70a8dfc4f027b5d0f508bd7cb46af11971076c9ebaf9ede2d"
 dependencies = [
  "aes-gcm-siv",
  "base64 0.21.4",
@@ -2726,9 +2726,9 @@ dependencies = [
 
 [[package]]
 name = "solana_rbpf"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3082ec3a1d4ef7879eb5b84916d5acde057abd59733eec3647e0ab8885283ef"
+checksum = "17d4ba1e58947346e360fabde0697029d36ba83c42f669199b16a8931313cf29"
 dependencies = [
  "byteorder",
  "combine",
diff --git a/Cargo.toml b/Cargo.toml
index 98e5f1f..4893356 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,16 +12,16 @@ keywords = ["solana", "geyser", "plugin", "solana-geyser-plugin"]
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-solana-geyser-plugin-interface = { version = "=1.16.13" }
-solana-logger = { version = "=1.16.13" }
+solana-geyser-plugin-interface = { version = "=1.16.14" }
+solana-logger = { version = "=1.16.14" }
 log = "0.4.17"
 bs58 = "0.4.0"
 flatbuffers = "23.1.21"
 parking_lot = "0.12.0"
-solana-sdk = { version = "=1.16.13" }
-solana-transaction-status = { version = "=1.16.13" }
-solana-program = { version = "=1.16.13" }
-solana-metrics = { version = "=1.16.13" }
+solana-sdk = { version = "=1.16.14" }
+solana-transaction-status = { version = "=1.16.14" }
+solana-program = { version = "=1.16.14" }
+solana-metrics = { version = "=1.16.14" }
 serde = { version = "1.0.133" }
 serde_json = "1.0.75"
 anyhow = "1.0.52"
diff --git a/src/flatbuffer/extractors.rs b/src/flatbuffer/extractors.rs
index 30404fa..b5c0484 100644
--- a/src/flatbuffer/extractors.rs
+++ b/src/flatbuffer/extractors.rs
@@ -2,15 +2,15 @@ use crate::errors::GeyserError;
 use crate::flatbuffer::common_generated::common::{Reward, RewardArgs, RewardType};
 use crate::flatbuffer::transaction_info_generated;
 use crate::flatbuffer::transaction_info_generated::transaction_info::{
-    CompiledInstruction, CompiledInstructionArgs, InnerByte, InnerByteArgs, InstructionError,
+    CompiledInstruction, CompiledInstructionArgs, InnerByte, InnerByteArgs, InnerInstructionV2,
+    InnerInstructionV2Args, InnerInstructionsV2, InnerInstructionsV2Args, InstructionError,
     InstructionErrorArgs, InstructionErrorData, InstructionErrorDataArgs,
     InstructionErrorInnerData, InstructionErrorType, LoadedAddressesString,
-    LoadedAddressesStringArgs, NewInnerInstruction, NewInnerInstructionArgs, NewInnerInstructions,
-    NewInnerInstructionsArgs, StringValue, StringValueArgs, TransactionError, TransactionErrorArgs,
-    TransactionErrorData, TransactionErrorType, TransactionReturnData, TransactionReturnDataArgs,
-    TransactionStatusMeta, TransactionStatusMetaArgs, TransactionTokenBalance,
-    TransactionTokenBalanceArgs, UiTokenAmount, UiTokenAmountArgs, UiTokenAmountPtr,
-    UiTokenAmountPtrArgs, Uint32Value, Uint32ValueArgs,
+    LoadedAddressesStringArgs, StringValue, StringValueArgs, TransactionError,
+    TransactionErrorArgs, TransactionErrorData, TransactionErrorType, TransactionReturnData,
+    TransactionReturnDataArgs, TransactionStatusMeta, TransactionStatusMetaArgs,
+    TransactionTokenBalance, TransactionTokenBalanceArgs, UiTokenAmount, UiTokenAmountArgs,
+    UiTokenAmountPtr, UiTokenAmountPtrArgs, Uint32Value, Uint32ValueArgs,
 };
 use flatbuffers::{FlatBufferBuilder, ForwardsUOffset, Vector, WIPOffset};
 use solana_transaction_status::{Rewards, UiReturnDataEncoding, UiTransactionReturnData};
@@ -28,8 +28,7 @@ pub struct TxMetaArgs<'a> {
         Option<WIPOffset<Vector<'a, ForwardsUOffset<UiTokenAmountPtr<'a>>>>>,
     pub post_token_balances_ptr:
         Option<WIPOffset<Vector<'a, ForwardsUOffset<UiTokenAmountPtr<'a>>>>>,
-    pub inner_instructions:
-        Option<WIPOffset<Vector<'a, ForwardsUOffset<NewInnerInstructions<'a>>>>>,
+    pub inner_instructions: Option<WIPOffset<Vector<'a, ForwardsUOffset<InnerInstructionsV2<'a>>>>>,
     pub return_data: Option<WIPOffset<TransactionReturnData<'a>>>,
 }
 
@@ -158,7 +157,7 @@ fn extract_meta<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
 fn extract_inner_instructions<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
     inner_instructions: &'args Option<Vec<solana_transaction_status::InnerInstructions>>,
     builder: &'mut_bldr mut FlatBufferBuilder<'bldr>,
-) -> Option<WIPOffset<Vector<'bldr, ForwardsUOffset<NewInnerInstructions<'bldr>>>>> {
+) -> Option<WIPOffset<Vector<'bldr, ForwardsUOffset<InnerInstructionsV2<'bldr>>>>> {
     if inner_instructions.is_none() {
         return None;
     }
@@ -181,9 +180,9 @@ fn extract_inner_instructions<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
                 },
             );
 
-            inner_instruction_vec.push(NewInnerInstruction::create(
+            inner_instruction_vec.push(InnerInstructionV2::create(
                 builder,
-                &NewInnerInstructionArgs {
+                &InnerInstructionV2Args {
                     instruction: Some(compiled_instruction),
                     stack_height: instruction.stack_height,
                 },
@@ -191,9 +190,9 @@ fn extract_inner_instructions<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
         }
         let instructions = Some(builder.create_vector(inner_instruction_vec.as_ref()));
 
-        inner_instructions_vec.push(NewInnerInstructions::create(
+        inner_instructions_vec.push(InnerInstructionsV2::create(
             builder,
-            &NewInnerInstructionsArgs {
+            &InnerInstructionsV2Args {
                 index: inner_instruction.index,
                 instructions,
             },
@@ -1240,5 +1239,15 @@ fn extract_tx_status<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
                 },
             ))
         }
+        solana_sdk::transaction::TransactionError::UnbalancedTransaction => {
+            Some(TransactionError::create(
+                builder,
+                &TransactionErrorArgs {
+                    err_type: TransactionErrorType::UnbalancedTransaction,
+                    err_data_type: Default::default(),
+                    err_data: None,
+                },
+            ))
+        }
     }
 }
diff --git a/src/flatbuffer/transaction_info.fbs b/src/flatbuffer/transaction_info.fbs
index 89dbea8..d318158 100644
--- a/src/flatbuffer/transaction_info.fbs
+++ b/src/flatbuffer/transaction_info.fbs
@@ -19,7 +19,7 @@ table TransactionInfo {
   loaded_addresses_string: LoadedAddressesString;
   pre_token_balances_ptr: [UiTokenAmountPtr];
   post_token_balances_ptr: [UiTokenAmountPtr];
-  inner_instructions: [NewInnerInstructions];
+  inner_instructions: [InnerInstructionsV2];
 }
 
 table LoadedAddresses {
@@ -73,7 +73,8 @@ enum TransactionErrorType: uint8 {
     InsufficientFundsForRent,
     MaxLoadedAccountsDataSizeExceeded,
     InvalidLoadedAccountsDataSizeLimit,
-    ResanitizationNeeded
+    ResanitizationNeeded,
+    UnbalancedTransaction
 }
 
 enum InstructionErrorType: uint8 {
@@ -192,12 +193,12 @@ table TransactionStatusMeta {
     rewards: [Common.Reward];
 }
 
-table NewInnerInstructions {
+table InnerInstructionsV2 {
     index: uint8;
-    instructions: [NewInnerInstruction];
+    instructions: [InnerInstructionV2];
 }
 
-table NewInnerInstruction {
+table InnerInstructionV2 {
     instruction: CompiledInstruction;
     stack_height: uint32 = null;
 }
diff --git a/src/flatbuffer/transaction_info_generated.rs b/src/flatbuffer/transaction_info_generated.rs
index fc7d215..5fa3dba 100644
--- a/src/flatbuffer/transaction_info_generated.rs
+++ b/src/flatbuffer/transaction_info_generated.rs
@@ -23,13 +23,13 @@ pub mod transaction_info {
         since = "2.0.0",
         note = "Use associated constants instead. This will no longer be generated in 2021."
     )]
-    pub const ENUM_MAX_TRANSACTION_ERROR_TYPE: u8 = 34;
+    pub const ENUM_MAX_TRANSACTION_ERROR_TYPE: u8 = 35;
     #[deprecated(
         since = "2.0.0",
         note = "Use associated constants instead. This will no longer be generated in 2021."
     )]
     #[allow(non_camel_case_types)]
-    pub const ENUM_VALUES_TRANSACTION_ERROR_TYPE: [TransactionErrorType; 35] = [
+    pub const ENUM_VALUES_TRANSACTION_ERROR_TYPE: [TransactionErrorType; 36] = [
         TransactionErrorType::AccountInUse,
         TransactionErrorType::AccountLoadedTwice,
         TransactionErrorType::AccountNotFound,
@@ -65,6 +65,7 @@ pub mod transaction_info {
         TransactionErrorType::MaxLoadedAccountsDataSizeExceeded,
         TransactionErrorType::InvalidLoadedAccountsDataSizeLimit,
         TransactionErrorType::ResanitizationNeeded,
+        TransactionErrorType::UnbalancedTransaction,
     ];
 
     #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -107,9 +108,10 @@ pub mod transaction_info {
         pub const MaxLoadedAccountsDataSizeExceeded: Self = Self(32);
         pub const InvalidLoadedAccountsDataSizeLimit: Self = Self(33);
         pub const ResanitizationNeeded: Self = Self(34);
+        pub const UnbalancedTransaction: Self = Self(35);
 
         pub const ENUM_MIN: u8 = 0;
-        pub const ENUM_MAX: u8 = 34;
+        pub const ENUM_MAX: u8 = 35;
         pub const ENUM_VALUES: &'static [Self] = &[
             Self::AccountInUse,
             Self::AccountLoadedTwice,
@@ -146,6 +148,7 @@ pub mod transaction_info {
             Self::MaxLoadedAccountsDataSizeExceeded,
             Self::InvalidLoadedAccountsDataSizeLimit,
             Self::ResanitizationNeeded,
+            Self::UnbalancedTransaction,
         ];
         /// Returns the variant's name or "" if unknown.
         pub fn variant_name(self) -> Option<&'static str> {
@@ -189,6 +192,7 @@ pub mod transaction_info {
                     Some("InvalidLoadedAccountsDataSizeLimit")
                 }
                 Self::ResanitizationNeeded => Some("ResanitizationNeeded"),
+                Self::UnbalancedTransaction => Some("UnbalancedTransaction"),
                 _ => None,
             }
         }
@@ -1128,14 +1132,14 @@ pub mod transaction_info {
         #[inline]
         pub fn inner_instructions(
             &self,
-        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstructions<'a>>>>
+        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionsV2<'a>>>>
         {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab.get::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstructions>>,
+                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionsV2>>,
                 >>(TransactionInfo::VT_INNER_INSTRUCTIONS, None)
             }
         }
@@ -1214,7 +1218,7 @@ pub mod transaction_info {
                     false,
                 )?
                 .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<NewInnerInstructions>>,
+                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<InnerInstructionsV2>>,
                 >>("inner_instructions", Self::VT_INNER_INSTRUCTIONS, false)?
                 .finish();
             Ok(())
@@ -1253,7 +1257,7 @@ pub mod transaction_info {
         >,
         pub inner_instructions: Option<
             flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstructions<'a>>>,
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionsV2<'a>>>,
             >,
         >,
     }
@@ -1435,7 +1439,7 @@ pub mod transaction_info {
         pub fn add_inner_instructions(
             &mut self,
             inner_instructions: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<NewInnerInstructions<'b>>>,
+                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<InnerInstructionsV2<'b>>>,
             >,
         ) {
             self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
@@ -3483,15 +3487,15 @@ pub mod transaction_info {
             ds.finish()
         }
     }
-    pub enum NewInnerInstructionsOffset {}
+    pub enum InnerInstructionsV2Offset {}
     #[derive(Copy, Clone, PartialEq)]
 
-    pub struct NewInnerInstructions<'a> {
+    pub struct InnerInstructionsV2<'a> {
         pub _tab: flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for NewInnerInstructions<'a> {
-        type Inner = NewInnerInstructions<'a>;
+    impl<'a> flatbuffers::Follow<'a> for InnerInstructionsV2<'a> {
+        type Inner = InnerInstructionsV2<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
@@ -3500,20 +3504,20 @@ pub mod transaction_info {
         }
     }
 
-    impl<'a> NewInnerInstructions<'a> {
+    impl<'a> InnerInstructionsV2<'a> {
         pub const VT_INDEX: flatbuffers::VOffsetT = 4;
         pub const VT_INSTRUCTIONS: flatbuffers::VOffsetT = 6;
 
         #[inline]
         pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-            NewInnerInstructions { _tab: table }
+            InnerInstructionsV2 { _tab: table }
         }
         #[allow(unused_mut)]
         pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
             _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
-            args: &'args NewInnerInstructionsArgs<'args>,
-        ) -> flatbuffers::WIPOffset<NewInnerInstructions<'bldr>> {
-            let mut builder = NewInnerInstructionsBuilder::new(_fbb);
+            args: &'args InnerInstructionsV2Args<'args>,
+        ) -> flatbuffers::WIPOffset<InnerInstructionsV2<'bldr>> {
+            let mut builder = InnerInstructionsV2Builder::new(_fbb);
             if let Some(x) = args.instructions {
                 builder.add_instructions(x);
             }
@@ -3528,27 +3532,27 @@ pub mod transaction_info {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<u8>(NewInnerInstructions::VT_INDEX, Some(0))
+                    .get::<u8>(InnerInstructionsV2::VT_INDEX, Some(0))
                     .unwrap()
             }
         }
         #[inline]
         pub fn instructions(
             &self,
-        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstruction<'a>>>>
+        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionV2<'a>>>>
         {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab.get::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstruction>>,
-                >>(NewInnerInstructions::VT_INSTRUCTIONS, None)
+                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionV2>>,
+                >>(InnerInstructionsV2::VT_INSTRUCTIONS, None)
             }
         }
     }
 
-    impl flatbuffers::Verifiable for NewInnerInstructions<'_> {
+    impl flatbuffers::Verifiable for InnerInstructionsV2<'_> {
         #[inline]
         fn run_verifier(
             v: &mut flatbuffers::Verifier,
@@ -3558,86 +3562,86 @@ pub mod transaction_info {
             v.visit_table(pos)?
                 .visit_field::<u8>("index", Self::VT_INDEX, false)?
                 .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<NewInnerInstruction>>,
+                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<InnerInstructionV2>>,
                 >>("instructions", Self::VT_INSTRUCTIONS, false)?
                 .finish();
             Ok(())
         }
     }
-    pub struct NewInnerInstructionsArgs<'a> {
+    pub struct InnerInstructionsV2Args<'a> {
         pub index: u8,
         pub instructions: Option<
             flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<NewInnerInstruction<'a>>>,
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InnerInstructionV2<'a>>>,
             >,
         >,
     }
-    impl<'a> Default for NewInnerInstructionsArgs<'a> {
+    impl<'a> Default for InnerInstructionsV2Args<'a> {
         #[inline]
         fn default() -> Self {
-            NewInnerInstructionsArgs {
+            InnerInstructionsV2Args {
                 index: 0,
                 instructions: None,
             }
         }
     }
 
-    pub struct NewInnerInstructionsBuilder<'a: 'b, 'b> {
+    pub struct InnerInstructionsV2Builder<'a: 'b, 'b> {
         fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
         start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
     }
-    impl<'a: 'b, 'b> NewInnerInstructionsBuilder<'a, 'b> {
+    impl<'a: 'b, 'b> InnerInstructionsV2Builder<'a, 'b> {
         #[inline]
         pub fn add_index(&mut self, index: u8) {
             self.fbb_
-                .push_slot::<u8>(NewInnerInstructions::VT_INDEX, index, 0);
+                .push_slot::<u8>(InnerInstructionsV2::VT_INDEX, index, 0);
         }
         #[inline]
         pub fn add_instructions(
             &mut self,
             instructions: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<NewInnerInstruction<'b>>>,
+                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<InnerInstructionV2<'b>>>,
             >,
         ) {
             self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                NewInnerInstructions::VT_INSTRUCTIONS,
+                InnerInstructionsV2::VT_INSTRUCTIONS,
                 instructions,
             );
         }
         #[inline]
         pub fn new(
             _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-        ) -> NewInnerInstructionsBuilder<'a, 'b> {
+        ) -> InnerInstructionsV2Builder<'a, 'b> {
             let start = _fbb.start_table();
-            NewInnerInstructionsBuilder {
+            InnerInstructionsV2Builder {
                 fbb_: _fbb,
                 start_: start,
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<NewInnerInstructions<'a>> {
+        pub fn finish(self) -> flatbuffers::WIPOffset<InnerInstructionsV2<'a>> {
             let o = self.fbb_.end_table(self.start_);
             flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for NewInnerInstructions<'_> {
+    impl core::fmt::Debug for InnerInstructionsV2<'_> {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            let mut ds = f.debug_struct("NewInnerInstructions");
+            let mut ds = f.debug_struct("InnerInstructionsV2");
             ds.field("index", &self.index());
             ds.field("instructions", &self.instructions());
             ds.finish()
         }
     }
-    pub enum NewInnerInstructionOffset {}
+    pub enum InnerInstructionV2Offset {}
     #[derive(Copy, Clone, PartialEq)]
 
-    pub struct NewInnerInstruction<'a> {
+    pub struct InnerInstructionV2<'a> {
         pub _tab: flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for NewInnerInstruction<'a> {
-        type Inner = NewInnerInstruction<'a>;
+    impl<'a> flatbuffers::Follow<'a> for InnerInstructionV2<'a> {
+        type Inner = InnerInstructionV2<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
@@ -3646,20 +3650,20 @@ pub mod transaction_info {
         }
     }
 
-    impl<'a> NewInnerInstruction<'a> {
+    impl<'a> InnerInstructionV2<'a> {
         pub const VT_INSTRUCTION: flatbuffers::VOffsetT = 4;
         pub const VT_STACK_HEIGHT: flatbuffers::VOffsetT = 6;
 
         #[inline]
         pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-            NewInnerInstruction { _tab: table }
+            InnerInstructionV2 { _tab: table }
         }
         #[allow(unused_mut)]
         pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
             _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
-            args: &'args NewInnerInstructionArgs<'args>,
-        ) -> flatbuffers::WIPOffset<NewInnerInstruction<'bldr>> {
-            let mut builder = NewInnerInstructionBuilder::new(_fbb);
+            args: &'args InnerInstructionV2Args<'args>,
+        ) -> flatbuffers::WIPOffset<InnerInstructionV2<'bldr>> {
+            let mut builder = InnerInstructionV2Builder::new(_fbb);
             if let Some(x) = args.stack_height {
                 builder.add_stack_height(x);
             }
@@ -3677,7 +3681,7 @@ pub mod transaction_info {
             unsafe {
                 self._tab
                     .get::<flatbuffers::ForwardsUOffset<CompiledInstruction>>(
-                        NewInnerInstruction::VT_INSTRUCTION,
+                        InnerInstructionV2::VT_INSTRUCTION,
                         None,
                     )
             }
@@ -3689,12 +3693,12 @@ pub mod transaction_info {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<u32>(NewInnerInstruction::VT_STACK_HEIGHT, None)
+                    .get::<u32>(InnerInstructionV2::VT_STACK_HEIGHT, None)
             }
         }
     }
 
-    impl flatbuffers::Verifiable for NewInnerInstruction<'_> {
+    impl flatbuffers::Verifiable for InnerInstructionV2<'_> {
         #[inline]
         fn run_verifier(
             v: &mut flatbuffers::Verifier,
@@ -3712,25 +3716,25 @@ pub mod transaction_info {
             Ok(())
         }
     }
-    pub struct NewInnerInstructionArgs<'a> {
+    pub struct InnerInstructionV2Args<'a> {
         pub instruction: Option<flatbuffers::WIPOffset<CompiledInstruction<'a>>>,
         pub stack_height: Option<u32>,
     }
-    impl<'a> Default for NewInnerInstructionArgs<'a> {
+    impl<'a> Default for InnerInstructionV2Args<'a> {
         #[inline]
         fn default() -> Self {
-            NewInnerInstructionArgs {
+            InnerInstructionV2Args {
                 instruction: None,
                 stack_height: None,
             }
         }
     }
 
-    pub struct NewInnerInstructionBuilder<'a: 'b, 'b> {
+    pub struct InnerInstructionV2Builder<'a: 'b, 'b> {
         fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
         start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
     }
-    impl<'a: 'b, 'b> NewInnerInstructionBuilder<'a, 'b> {
+    impl<'a: 'b, 'b> InnerInstructionV2Builder<'a, 'b> {
         #[inline]
         pub fn add_instruction(
             &mut self,
@@ -3738,35 +3742,35 @@ pub mod transaction_info {
         ) {
             self.fbb_
                 .push_slot_always::<flatbuffers::WIPOffset<CompiledInstruction>>(
-                    NewInnerInstruction::VT_INSTRUCTION,
+                    InnerInstructionV2::VT_INSTRUCTION,
                     instruction,
                 );
         }
         #[inline]
         pub fn add_stack_height(&mut self, stack_height: u32) {
             self.fbb_
-                .push_slot_always::<u32>(NewInnerInstruction::VT_STACK_HEIGHT, stack_height);
+                .push_slot_always::<u32>(InnerInstructionV2::VT_STACK_HEIGHT, stack_height);
         }
         #[inline]
         pub fn new(
             _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-        ) -> NewInnerInstructionBuilder<'a, 'b> {
+        ) -> InnerInstructionV2Builder<'a, 'b> {
             let start = _fbb.start_table();
-            NewInnerInstructionBuilder {
+            InnerInstructionV2Builder {
                 fbb_: _fbb,
                 start_: start,
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<NewInnerInstruction<'a>> {
+        pub fn finish(self) -> flatbuffers::WIPOffset<InnerInstructionV2<'a>> {
             let o = self.fbb_.end_table(self.start_);
             flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for NewInnerInstruction<'_> {
+    impl core::fmt::Debug for InnerInstructionV2<'_> {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            let mut ds = f.debug_struct("NewInnerInstruction");
+            let mut ds = f.debug_struct("InnerInstructionV2");
             ds.field("instruction", &self.instruction());
             ds.field("stack_height", &self.stack_height());
             ds.finish()