@bench.games/opportunity-markets 0.1.24 → 0.1.25

package/dist/browser/index.js

@@ -186,7 +186,7 @@ async function fetchAllMaybeCentralState(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists3,
   assertAccountsExist as assertAccountsExist3,
-  combineCodec as combineCodec56,
+  combineCodec as combineCodec57,
   decodeAccount as decodeAccount3,
   fetchEncodedAccount as fetchEncodedAccount3,
   fetchEncodedAccounts as fetchEncodedAccounts3,
@@ -194,8 +194,8 @@ import {
   fixEncoderSize as fixEncoderSize3,
   getBytesDecoder as getBytesDecoder3,
   getBytesEncoder as getBytesEncoder3,
-  getStructDecoder as getStructDecoder50,
-  getStructEncoder as getStructEncoder50,
+  getStructDecoder as getStructDecoder51,
+  getStructEncoder as getStructEncoder51,
   getU8Decoder as getU8Decoder21,
   getU8Encoder as getU8Encoder21,
   transformEncoder as transformEncoder3
@@ -788,155 +788,184 @@ function getEncryptedTokensUnwrappedEventCodec() {
   );
 }
 
-// src/generated/types/encryptedTokensWrappedEvent.ts
+// src/generated/types/encryptedTokensWrappedError.ts
 import {
   combineCodec as combineCodec16,
   getAddressDecoder as getAddressDecoder5,
   getAddressEncoder as getAddressEncoder5,
-  getArrayDecoder as getArrayDecoder7,
-  getArrayEncoder as getArrayEncoder7,
   getI64Decoder as getI64Decoder4,
   getI64Encoder as getI64Encoder4,
   getStructDecoder as getStructDecoder15,
-  getStructEncoder as getStructEncoder15,
-  getU128Decoder as getU128Decoder5,
-  getU128Encoder as getU128Encoder5,
-  getU64Decoder as getU64Decoder3,
-  getU64Encoder as getU64Encoder3,
-  getU8Decoder as getU8Decoder8,
-  getU8Encoder as getU8Encoder8
+  getStructEncoder as getStructEncoder15
 } from "@solana/kit";
-function getEncryptedTokensWrappedEventEncoder() {
+function getEncryptedTokensWrappedErrorEncoder() {
   return getStructEncoder15([
-    ["encryptedTokenAccount", getAddressEncoder5()],
     ["user", getAddressEncoder5()],
-    ["depositAmount", getU64Encoder3()],
-    ["encryptedNewBalance", getArrayEncoder7(getU8Encoder8(), { size: 32 })],
-    ["nonce", getU128Encoder5()],
     ["timestamp", getI64Encoder4()]
   ]);
 }
-function getEncryptedTokensWrappedEventDecoder() {
+function getEncryptedTokensWrappedErrorDecoder() {
   return getStructDecoder15([
-    ["encryptedTokenAccount", getAddressDecoder5()],
     ["user", getAddressDecoder5()],
-    ["depositAmount", getU64Decoder3()],
-    ["encryptedNewBalance", getArrayDecoder7(getU8Decoder8(), { size: 32 })],
-    ["nonce", getU128Decoder5()],
     ["timestamp", getI64Decoder4()]
   ]);
 }
-function getEncryptedTokensWrappedEventCodec() {
+function getEncryptedTokensWrappedErrorCodec() {
   return combineCodec16(
-    getEncryptedTokensWrappedEventEncoder(),
-    getEncryptedTokensWrappedEventDecoder()
+    getEncryptedTokensWrappedErrorEncoder(),
+    getEncryptedTokensWrappedErrorDecoder()
   );
 }
 
-// src/generated/types/ephemeralAccountClosedError.ts
+// src/generated/types/encryptedTokensWrappedEvent.ts
 import {
   combineCodec as combineCodec17,
   getAddressDecoder as getAddressDecoder6,
   getAddressEncoder as getAddressEncoder6,
+  getArrayDecoder as getArrayDecoder7,
+  getArrayEncoder as getArrayEncoder7,
   getI64Decoder as getI64Decoder5,
   getI64Encoder as getI64Encoder5,
   getStructDecoder as getStructDecoder16,
-  getStructEncoder as getStructEncoder16
+  getStructEncoder as getStructEncoder16,
+  getU128Decoder as getU128Decoder5,
+  getU128Encoder as getU128Encoder5,
+  getU64Decoder as getU64Decoder3,
+  getU64Encoder as getU64Encoder3,
+  getU8Decoder as getU8Decoder8,
+  getU8Encoder as getU8Encoder8
 } from "@solana/kit";
-function getEphemeralAccountClosedErrorEncoder() {
+function getEncryptedTokensWrappedEventEncoder() {
   return getStructEncoder16([
+    ["encryptedTokenAccount", getAddressEncoder6()],
     ["user", getAddressEncoder6()],
+    ["depositAmount", getU64Encoder3()],
+    ["encryptedNewBalance", getArrayEncoder7(getU8Encoder8(), { size: 32 })],
+    ["nonce", getU128Encoder5()],
     ["timestamp", getI64Encoder5()]
   ]);
 }
-function getEphemeralAccountClosedErrorDecoder() {
+function getEncryptedTokensWrappedEventDecoder() {
   return getStructDecoder16([
+    ["encryptedTokenAccount", getAddressDecoder6()],
     ["user", getAddressDecoder6()],
+    ["depositAmount", getU64Decoder3()],
+    ["encryptedNewBalance", getArrayDecoder7(getU8Decoder8(), { size: 32 })],
+    ["nonce", getU128Decoder5()],
     ["timestamp", getI64Decoder5()]
   ]);
 }
-function getEphemeralAccountClosedErrorCodec() {
+function getEncryptedTokensWrappedEventCodec() {
   return combineCodec17(
-    getEphemeralAccountClosedErrorEncoder(),
-    getEphemeralAccountClosedErrorDecoder()
+    getEncryptedTokensWrappedEventEncoder(),
+    getEncryptedTokensWrappedEventDecoder()
   );
 }
 
-// src/generated/types/ephemeralAccountClosedEvent.ts
+// src/generated/types/ephemeralAccountClosedError.ts
 import {
   combineCodec as combineCodec18,
   getAddressDecoder as getAddressDecoder7,
   getAddressEncoder as getAddressEncoder7,
-  getArrayDecoder as getArrayDecoder8,
-  getArrayEncoder as getArrayEncoder8,
   getI64Decoder as getI64Decoder6,
   getI64Encoder as getI64Encoder6,
   getStructDecoder as getStructDecoder17,
-  getStructEncoder as getStructEncoder17,
-  getU128Decoder as getU128Decoder6,
-  getU128Encoder as getU128Encoder6,
-  getU8Decoder as getU8Decoder9,
-  getU8Encoder as getU8Encoder9
+  getStructEncoder as getStructEncoder17
 } from "@solana/kit";
-function getEphemeralAccountClosedEventEncoder() {
+function getEphemeralAccountClosedErrorEncoder() {
   return getStructEncoder17([
     ["user", getAddressEncoder7()],
-    ["encryptedTokenAccount", getAddressEncoder7()],
-    ["encryptedNewBalance", getArrayEncoder8(getU8Encoder9(), { size: 32 })],
-    ["nonce", getU128Encoder6()],
     ["timestamp", getI64Encoder6()]
   ]);
 }
-function getEphemeralAccountClosedEventDecoder() {
+function getEphemeralAccountClosedErrorDecoder() {
   return getStructDecoder17([
     ["user", getAddressDecoder7()],
-    ["encryptedTokenAccount", getAddressDecoder7()],
-    ["encryptedNewBalance", getArrayDecoder8(getU8Decoder9(), { size: 32 })],
-    ["nonce", getU128Decoder6()],
     ["timestamp", getI64Decoder6()]
   ]);
 }
-function getEphemeralAccountClosedEventCodec() {
+function getEphemeralAccountClosedErrorCodec() {
   return combineCodec18(
-    getEphemeralAccountClosedEventEncoder(),
-    getEphemeralAccountClosedEventDecoder()
+    getEphemeralAccountClosedErrorEncoder(),
+    getEphemeralAccountClosedErrorDecoder()
   );
 }
 
-// src/generated/types/ephemeralEncryptedTokenAccountInitializedEvent.ts
+// src/generated/types/ephemeralAccountClosedEvent.ts
 import {
   combineCodec as combineCodec19,
   getAddressDecoder as getAddressDecoder8,
   getAddressEncoder as getAddressEncoder8,
+  getArrayDecoder as getArrayDecoder8,
+  getArrayEncoder as getArrayEncoder8,
   getI64Decoder as getI64Decoder7,
   getI64Encoder as getI64Encoder7,
   getStructDecoder as getStructDecoder18,
   getStructEncoder as getStructEncoder18,
-  getU64Decoder as getU64Decoder4,
-  getU64Encoder as getU64Encoder4
+  getU128Decoder as getU128Decoder6,
+  getU128Encoder as getU128Encoder6,
+  getU8Decoder as getU8Decoder9,
+  getU8Encoder as getU8Encoder9
 } from "@solana/kit";
-function getEphemeralEncryptedTokenAccountInitializedEventEncoder() {
+function getEphemeralAccountClosedEventEncoder() {
   return getStructEncoder18([
+    ["user", getAddressEncoder8()],
     ["encryptedTokenAccount", getAddressEncoder8()],
-    ["owner", getAddressEncoder8()],
-    ["tokenMint", getAddressEncoder8()],
-    ["index", getU64Encoder4()],
-    ["rentPayer", getAddressEncoder8()],
+    ["encryptedNewBalance", getArrayEncoder8(getU8Encoder9(), { size: 32 })],
+    ["nonce", getU128Encoder6()],
     ["timestamp", getI64Encoder7()]
   ]);
 }
-function getEphemeralEncryptedTokenAccountInitializedEventDecoder() {
+function getEphemeralAccountClosedEventDecoder() {
   return getStructDecoder18([
+    ["user", getAddressDecoder8()],
     ["encryptedTokenAccount", getAddressDecoder8()],
-    ["owner", getAddressDecoder8()],
-    ["tokenMint", getAddressDecoder8()],
-    ["index", getU64Decoder4()],
-    ["rentPayer", getAddressDecoder8()],
+    ["encryptedNewBalance", getArrayDecoder8(getU8Decoder9(), { size: 32 })],
+    ["nonce", getU128Decoder6()],
     ["timestamp", getI64Decoder7()]
   ]);
 }
-function getEphemeralEncryptedTokenAccountInitializedEventCodec() {
+function getEphemeralAccountClosedEventCodec() {
   return combineCodec19(
+    getEphemeralAccountClosedEventEncoder(),
+    getEphemeralAccountClosedEventDecoder()
+  );
+}
+
+// src/generated/types/ephemeralEncryptedTokenAccountInitializedEvent.ts
+import {
+  combineCodec as combineCodec20,
+  getAddressDecoder as getAddressDecoder9,
+  getAddressEncoder as getAddressEncoder9,
+  getI64Decoder as getI64Decoder8,
+  getI64Encoder as getI64Encoder8,
+  getStructDecoder as getStructDecoder19,
+  getStructEncoder as getStructEncoder19,
+  getU64Decoder as getU64Decoder4,
+  getU64Encoder as getU64Encoder4
+} from "@solana/kit";
+function getEphemeralEncryptedTokenAccountInitializedEventEncoder() {
+  return getStructEncoder19([
+    ["encryptedTokenAccount", getAddressEncoder9()],
+    ["owner", getAddressEncoder9()],
+    ["tokenMint", getAddressEncoder9()],
+    ["index", getU64Encoder4()],
+    ["rentPayer", getAddressEncoder9()],
+    ["timestamp", getI64Encoder8()]
+  ]);
+}
+function getEphemeralEncryptedTokenAccountInitializedEventDecoder() {
+  return getStructDecoder19([
+    ["encryptedTokenAccount", getAddressDecoder9()],
+    ["owner", getAddressDecoder9()],
+    ["tokenMint", getAddressDecoder9()],
+    ["index", getU64Decoder4()],
+    ["rentPayer", getAddressDecoder9()],
+    ["timestamp", getI64Decoder8()]
+  ]);
+}
+function getEphemeralEncryptedTokenAccountInitializedEventCodec() {
+  return combineCodec20(
     getEphemeralEncryptedTokenAccountInitializedEventEncoder(),
     getEphemeralEncryptedTokenAccountInitializedEventDecoder()
   );
@@ -944,7 +973,7 @@ function getEphemeralEncryptedTokenAccountInitializedEventCodec() {
 
 // src/generated/types/epoch.ts
 import {
-  combineCodec as combineCodec20,
+  combineCodec as combineCodec21,
   getTupleDecoder as getTupleDecoder3,
   getTupleEncoder as getTupleEncoder3,
   getU64Decoder as getU64Decoder5,
@@ -957,41 +986,41 @@ function getEpochDecoder() {
   return getTupleDecoder3([getU64Decoder5()]);
 }
 function getEpochCodec() {
-  return combineCodec20(getEpochEncoder(), getEpochDecoder());
+  return combineCodec21(getEpochEncoder(), getEpochDecoder());
 }
 
 // src/generated/types/feesClaimedEvent.ts
 import {
-  combineCodec as combineCodec21,
-  getAddressDecoder as getAddressDecoder9,
-  getAddressEncoder as getAddressEncoder9,
-  getI64Decoder as getI64Decoder8,
-  getI64Encoder as getI64Encoder8,
-  getStructDecoder as getStructDecoder19,
-  getStructEncoder as getStructEncoder19,
+  combineCodec as combineCodec22,
+  getAddressDecoder as getAddressDecoder10,
+  getAddressEncoder as getAddressEncoder10,
+  getI64Decoder as getI64Decoder9,
+  getI64Encoder as getI64Encoder9,
+  getStructDecoder as getStructDecoder20,
+  getStructEncoder as getStructEncoder20,
   getU64Decoder as getU64Decoder6,
   getU64Encoder as getU64Encoder6
 } from "@solana/kit";
 function getFeesClaimedEventEncoder() {
-  return getStructEncoder19([
-    ["tokenVault", getAddressEncoder9()],
-    ["mint", getAddressEncoder9()],
-    ["feeRecipient", getAddressEncoder9()],
+  return getStructEncoder20([
+    ["tokenVault", getAddressEncoder10()],
+    ["mint", getAddressEncoder10()],
+    ["feeRecipient", getAddressEncoder10()],
     ["amount", getU64Encoder6()],
-    ["timestamp", getI64Encoder8()]
+    ["timestamp", getI64Encoder9()]
   ]);
 }
 function getFeesClaimedEventDecoder() {
-  return getStructDecoder19([
-    ["tokenVault", getAddressDecoder9()],
-    ["mint", getAddressDecoder9()],
-    ["feeRecipient", getAddressDecoder9()],
+  return getStructDecoder20([
+    ["tokenVault", getAddressDecoder10()],
+    ["mint", getAddressDecoder10()],
+    ["feeRecipient", getAddressDecoder10()],
     ["amount", getU64Decoder6()],
-    ["timestamp", getI64Decoder8()]
+    ["timestamp", getI64Decoder9()]
   ]);
 }
 function getFeesClaimedEventCodec() {
-  return combineCodec21(
+  return combineCodec22(
     getFeesClaimedEventEncoder(),
     getFeesClaimedEventDecoder()
   );
@@ -999,7 +1028,7 @@ function getFeesClaimedEventCodec() {
 
 // src/generated/types/localCircuitSource.ts
 import {
-  combineCodec as combineCodec22,
+  combineCodec as combineCodec23,
   getEnumDecoder,
   getEnumEncoder
 } from "@solana/kit";
@@ -1016,7 +1045,7 @@ function getLocalCircuitSourceDecoder() {
   return getEnumDecoder(LocalCircuitSource);
 }
 function getLocalCircuitSourceCodec() {
-  return combineCodec22(
+  return combineCodec23(
     getLocalCircuitSourceEncoder(),
     getLocalCircuitSourceDecoder()
   );
@@ -1024,54 +1053,54 @@ function getLocalCircuitSourceCodec() {
 
 // src/generated/types/marketCreatedEvent.ts
 import {
-  combineCodec as combineCodec23,
-  getAddressDecoder as getAddressDecoder10,
-  getAddressEncoder as getAddressEncoder10,
+  combineCodec as combineCodec24,
+  getAddressDecoder as getAddressDecoder11,
+  getAddressEncoder as getAddressEncoder11,
   getArrayDecoder as getArrayDecoder9,
   getArrayEncoder as getArrayEncoder9,
   getBooleanDecoder as getBooleanDecoder3,
   getBooleanEncoder as getBooleanEncoder3,
-  getI64Decoder as getI64Decoder9,
-  getI64Encoder as getI64Encoder9,
+  getI64Decoder as getI64Decoder10,
+  getI64Encoder as getI64Encoder10,
   getOptionDecoder,
   getOptionEncoder,
-  getStructDecoder as getStructDecoder20,
-  getStructEncoder as getStructEncoder20,
+  getStructDecoder as getStructDecoder21,
+  getStructEncoder as getStructEncoder21,
   getU64Decoder as getU64Decoder7,
   getU64Encoder as getU64Encoder7,
   getU8Decoder as getU8Decoder10,
   getU8Encoder as getU8Encoder10
 } from "@solana/kit";
 function getMarketCreatedEventEncoder() {
-  return getStructEncoder20([
-    ["market", getAddressEncoder10()],
-    ["creator", getAddressEncoder10()],
+  return getStructEncoder21([
+    ["market", getAddressEncoder11()],
+    ["creator", getAddressEncoder11()],
     ["index", getU64Encoder7()],
     ["timeToStake", getU64Encoder7()],
     ["timeToReveal", getU64Encoder7()],
-    ["marketAuthority", getOptionEncoder(getAddressEncoder10())],
+    ["marketAuthority", getOptionEncoder(getAddressEncoder11())],
     ["authorizedReaderPubkey", getArrayEncoder9(getU8Encoder10(), { size: 32 })],
     ["unstakeDelaySeconds", getU64Encoder7()],
     ["allowClosingEarly", getBooleanEncoder3()],
-    ["timestamp", getI64Encoder9()]
+    ["timestamp", getI64Encoder10()]
   ]);
 }
 function getMarketCreatedEventDecoder() {
-  return getStructDecoder20([
-    ["market", getAddressDecoder10()],
-    ["creator", getAddressDecoder10()],
+  return getStructDecoder21([
+    ["market", getAddressDecoder11()],
+    ["creator", getAddressDecoder11()],
     ["index", getU64Decoder7()],
     ["timeToStake", getU64Decoder7()],
     ["timeToReveal", getU64Decoder7()],
-    ["marketAuthority", getOptionDecoder(getAddressDecoder10())],
+    ["marketAuthority", getOptionDecoder(getAddressDecoder11())],
     ["authorizedReaderPubkey", getArrayDecoder9(getU8Decoder10(), { size: 32 })],
     ["unstakeDelaySeconds", getU64Decoder7()],
     ["allowClosingEarly", getBooleanDecoder3()],
-    ["timestamp", getI64Decoder9()]
+    ["timestamp", getI64Decoder10()]
   ]);
 }
 function getMarketCreatedEventCodec() {
-  return combineCodec23(
+  return combineCodec24(
     getMarketCreatedEventEncoder(),
     getMarketCreatedEventDecoder()
   );
@@ -1079,34 +1108,34 @@ function getMarketCreatedEventCodec() {
 
 // src/generated/types/marketOpenedEvent.ts
 import {
-  combineCodec as combineCodec24,
-  getAddressDecoder as getAddressDecoder11,
-  getAddressEncoder as getAddressEncoder11,
-  getI64Decoder as getI64Decoder10,
-  getI64Encoder as getI64Encoder10,
-  getStructDecoder as getStructDecoder21,
-  getStructEncoder as getStructEncoder21,
+  combineCodec as combineCodec25,
+  getAddressDecoder as getAddressDecoder12,
+  getAddressEncoder as getAddressEncoder12,
+  getI64Decoder as getI64Decoder11,
+  getI64Encoder as getI64Encoder11,
+  getStructDecoder as getStructDecoder22,
+  getStructEncoder as getStructEncoder22,
   getU64Decoder as getU64Decoder8,
   getU64Encoder as getU64Encoder8
 } from "@solana/kit";
 function getMarketOpenedEventEncoder() {
-  return getStructEncoder21([
-    ["market", getAddressEncoder11()],
-    ["creator", getAddressEncoder11()],
+  return getStructEncoder22([
+    ["market", getAddressEncoder12()],
+    ["creator", getAddressEncoder12()],
     ["openTimestamp", getU64Encoder8()],
-    ["timestamp", getI64Encoder10()]
+    ["timestamp", getI64Encoder11()]
   ]);
 }
 function getMarketOpenedEventDecoder() {
-  return getStructDecoder21([
-    ["market", getAddressDecoder11()],
-    ["creator", getAddressDecoder11()],
+  return getStructDecoder22([
+    ["market", getAddressDecoder12()],
+    ["creator", getAddressDecoder12()],
     ["openTimestamp", getU64Decoder8()],
-    ["timestamp", getI64Decoder10()]
+    ["timestamp", getI64Decoder11()]
   ]);
 }
 function getMarketOpenedEventCodec() {
-  return combineCodec24(
+  return combineCodec25(
     getMarketOpenedEventEncoder(),
     getMarketOpenedEventDecoder()
   );
@@ -1116,15 +1145,15 @@ function getMarketOpenedEventCodec() {
 import {
   addDecoderSizePrefix,
   addEncoderSizePrefix,
-  combineCodec as combineCodec25,
-  getAddressDecoder as getAddressDecoder12,
-  getAddressEncoder as getAddressEncoder12,
+  combineCodec as combineCodec26,
+  getAddressDecoder as getAddressDecoder13,
+  getAddressEncoder as getAddressEncoder13,
   getBooleanDecoder as getBooleanDecoder4,
   getBooleanEncoder as getBooleanEncoder4,
-  getI64Decoder as getI64Decoder11,
-  getI64Encoder as getI64Encoder11,
-  getStructDecoder as getStructDecoder22,
-  getStructEncoder as getStructEncoder22,
+  getI64Decoder as getI64Decoder12,
+  getI64Encoder as getI64Encoder12,
+  getStructDecoder as getStructDecoder23,
+  getStructEncoder as getStructEncoder23,
   getU16Decoder as getU16Decoder2,
   getU16Encoder as getU16Encoder2,
   getU32Decoder as getU32Decoder2,
@@ -1133,29 +1162,29 @@ import {
   getUtf8Encoder
 } from "@solana/kit";
 function getMarketOptionCreatedEventEncoder() {
-  return getStructEncoder22([
-    ["option", getAddressEncoder12()],
-    ["market", getAddressEncoder12()],
-    ["creator", getAddressEncoder12()],
+  return getStructEncoder23([
+    ["option", getAddressEncoder13()],
+    ["market", getAddressEncoder13()],
+    ["creator", getAddressEncoder13()],
     ["byMarketCreator", getBooleanEncoder4()],
     ["index", getU16Encoder2()],
     ["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder2())],
-    ["timestamp", getI64Encoder11()]
+    ["timestamp", getI64Encoder12()]
   ]);
 }
 function getMarketOptionCreatedEventDecoder() {
-  return getStructDecoder22([
-    ["option", getAddressDecoder12()],
-    ["market", getAddressDecoder12()],
-    ["creator", getAddressDecoder12()],
+  return getStructDecoder23([
+    ["option", getAddressDecoder13()],
+    ["market", getAddressDecoder13()],
+    ["creator", getAddressDecoder13()],
     ["byMarketCreator", getBooleanDecoder4()],
     ["index", getU16Decoder2()],
     ["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder2())],
-    ["timestamp", getI64Decoder11()]
+    ["timestamp", getI64Decoder12()]
   ]);
 }
 function getMarketOptionCreatedEventCodec() {
-  return combineCodec25(
+  return combineCodec26(
     getMarketOptionCreatedEventEncoder(),
     getMarketOptionCreatedEventDecoder()
   );
@@ -1163,7 +1192,7 @@ function getMarketOptionCreatedEventCodec() {
 
 // src/generated/types/mxeStatus.ts
 import {
-  combineCodec as combineCodec26,
+  combineCodec as combineCodec27,
   getEnumDecoder as getEnumDecoder2,
   getEnumEncoder as getEnumEncoder2
 } from "@solana/kit";
@@ -1179,42 +1208,42 @@ function getMxeStatusDecoder() {
   return getEnumDecoder2(MxeStatus);
 }
 function getMxeStatusCodec() {
-  return combineCodec26(getMxeStatusEncoder(), getMxeStatusDecoder());
+  return combineCodec27(getMxeStatusEncoder(), getMxeStatusDecoder());
 }
 
 // src/generated/types/nodeMetadata.ts
 import {
-  combineCodec as combineCodec27,
+  combineCodec as combineCodec28,
   getArrayDecoder as getArrayDecoder10,
   getArrayEncoder as getArrayEncoder10,
-  getStructDecoder as getStructDecoder23,
-  getStructEncoder as getStructEncoder23,
+  getStructDecoder as getStructDecoder24,
+  getStructEncoder as getStructEncoder24,
   getU8Decoder as getU8Decoder11,
   getU8Encoder as getU8Encoder11
 } from "@solana/kit";
 function getNodeMetadataEncoder() {
-  return getStructEncoder23([
+  return getStructEncoder24([
     ["ip", getArrayEncoder10(getU8Encoder11(), { size: 4 })],
     ["peerId", getArrayEncoder10(getU8Encoder11(), { size: 32 })],
     ["location", getU8Encoder11()]
   ]);
 }
 function getNodeMetadataDecoder() {
-  return getStructDecoder23([
+  return getStructDecoder24([
     ["ip", getArrayDecoder10(getU8Decoder11(), { size: 4 })],
     ["peerId", getArrayDecoder10(getU8Decoder11(), { size: 32 })],
     ["location", getU8Decoder11()]
   ]);
 }
 function getNodeMetadataCodec() {
-  return combineCodec27(getNodeMetadataEncoder(), getNodeMetadataDecoder());
+  return combineCodec28(getNodeMetadataEncoder(), getNodeMetadataDecoder());
 }
 
 // src/generated/types/nodeRef.ts
 import {
-  combineCodec as combineCodec28,
-  getStructDecoder as getStructDecoder24,
-  getStructEncoder as getStructEncoder24,
+  combineCodec as combineCodec29,
+  getStructDecoder as getStructDecoder25,
+  getStructEncoder as getStructEncoder25,
   getU32Decoder as getU32Decoder3,
   getU32Encoder as getU32Encoder3,
   getU64Decoder as getU64Decoder9,
@@ -1223,32 +1252,32 @@ import {
   getU8Encoder as getU8Encoder12
 } from "@solana/kit";
 function getNodeRefEncoder() {
-  return getStructEncoder24([
+  return getStructEncoder25([
     ["offset", getU32Encoder3()],
     ["currentTotalRewards", getU64Encoder9()],
     ["vote", getU8Encoder12()]
   ]);
 }
 function getNodeRefDecoder() {
-  return getStructDecoder24([
+  return getStructDecoder25([
     ["offset", getU32Decoder3()],
     ["currentTotalRewards", getU64Decoder9()],
     ["vote", getU8Decoder12()]
   ]);
 }
 function getNodeRefCodec() {
-  return combineCodec28(getNodeRefEncoder(), getNodeRefDecoder());
+  return combineCodec29(getNodeRefEncoder(), getNodeRefDecoder());
 }
 
 // src/generated/types/offChainCircuitSource.ts
 import {
   addDecoderSizePrefix as addDecoderSizePrefix2,
   addEncoderSizePrefix as addEncoderSizePrefix2,
-  combineCodec as combineCodec29,
+  combineCodec as combineCodec30,
   getArrayDecoder as getArrayDecoder11,
   getArrayEncoder as getArrayEncoder11,
-  getStructDecoder as getStructDecoder25,
-  getStructEncoder as getStructEncoder25,
+  getStructDecoder as getStructDecoder26,
+  getStructEncoder as getStructEncoder26,
   getU32Decoder as getU32Decoder4,
   getU32Encoder as getU32Encoder4,
   getU8Decoder as getU8Decoder13,
@@ -1257,19 +1286,19 @@ import {
   getUtf8Encoder as getUtf8Encoder2
 } from "@solana/kit";
 function getOffChainCircuitSourceEncoder() {
-  return getStructEncoder25([
+  return getStructEncoder26([
     ["source", addEncoderSizePrefix2(getUtf8Encoder2(), getU32Encoder4())],
     ["hash", getArrayEncoder11(getU8Encoder13(), { size: 32 })]
   ]);
 }
 function getOffChainCircuitSourceDecoder() {
-  return getStructDecoder25([
+  return getStructDecoder26([
     ["source", addDecoderSizePrefix2(getUtf8Decoder2(), getU32Decoder4())],
     ["hash", getArrayDecoder11(getU8Decoder13(), { size: 32 })]
   ]);
 }
 function getOffChainCircuitSourceCodec() {
-  return combineCodec29(
+  return combineCodec30(
     getOffChainCircuitSourceEncoder(),
     getOffChainCircuitSourceDecoder()
   );
@@ -1277,28 +1306,28 @@ function getOffChainCircuitSourceCodec() {
 
 // src/generated/types/onChainCircuitSource.ts
 import {
-  combineCodec as combineCodec30,
-  getAddressDecoder as getAddressDecoder13,
-  getAddressEncoder as getAddressEncoder13,
+  combineCodec as combineCodec31,
+  getAddressDecoder as getAddressDecoder14,
+  getAddressEncoder as getAddressEncoder14,
   getBooleanDecoder as getBooleanDecoder5,
   getBooleanEncoder as getBooleanEncoder5,
-  getStructDecoder as getStructDecoder26,
-  getStructEncoder as getStructEncoder26
+  getStructDecoder as getStructDecoder27,
+  getStructEncoder as getStructEncoder27
 } from "@solana/kit";
 function getOnChainCircuitSourceEncoder() {
-  return getStructEncoder26([
+  return getStructEncoder27([
     ["isCompleted", getBooleanEncoder5()],
-    ["uploadAuth", getAddressEncoder13()]
+    ["uploadAuth", getAddressEncoder14()]
   ]);
 }
 function getOnChainCircuitSourceDecoder() {
-  return getStructDecoder26([
+  return getStructDecoder27([
     ["isCompleted", getBooleanDecoder5()],
-    ["uploadAuth", getAddressDecoder13()]
+    ["uploadAuth", getAddressDecoder14()]
   ]);
 }
 function getOnChainCircuitSourceCodec() {
-  return combineCodec30(
+  return combineCodec31(
     getOnChainCircuitSourceEncoder(),
     getOnChainCircuitSourceDecoder()
   );
@@ -1306,7 +1335,7 @@ function getOnChainCircuitSourceCodec() {
 
 // src/generated/types/output.ts
 import {
-  combineCodec as combineCodec31,
+  combineCodec as combineCodec32,
   getEnumDecoder as getEnumDecoder3,
   getEnumEncoder as getEnumEncoder3
 } from "@solana/kit";
@@ -1335,12 +1364,12 @@ function getOutputDecoder() {
   return getEnumDecoder3(Output);
 }
 function getOutputCodec() {
-  return combineCodec31(getOutputEncoder(), getOutputDecoder());
+  return combineCodec32(getOutputEncoder(), getOutputDecoder());
 }
 
 // src/generated/types/parameter.ts
 import {
-  combineCodec as combineCodec32,
+  combineCodec as combineCodec33,
   getEnumDecoder as getEnumDecoder4,
   getEnumEncoder as getEnumEncoder4
 } from "@solana/kit";
@@ -1370,39 +1399,39 @@ function getParameterDecoder() {
   return getEnumDecoder4(Parameter);
 }
 function getParameterCodec() {
-  return combineCodec32(getParameterEncoder(), getParameterDecoder());
+  return combineCodec33(getParameterEncoder(), getParameterDecoder());
 }
 
 // src/generated/types/pendingDepositClaimedEvent.ts
 import {
-  combineCodec as combineCodec33,
-  getAddressDecoder as getAddressDecoder14,
-  getAddressEncoder as getAddressEncoder14,
-  getI64Decoder as getI64Decoder12,
-  getI64Encoder as getI64Encoder12,
-  getStructDecoder as getStructDecoder27,
-  getStructEncoder as getStructEncoder27,
+  combineCodec as combineCodec34,
+  getAddressDecoder as getAddressDecoder15,
+  getAddressEncoder as getAddressEncoder15,
+  getI64Decoder as getI64Decoder13,
+  getI64Encoder as getI64Encoder13,
+  getStructDecoder as getStructDecoder28,
+  getStructEncoder as getStructEncoder28,
   getU64Decoder as getU64Decoder10,
   getU64Encoder as getU64Encoder10
 } from "@solana/kit";
 function getPendingDepositClaimedEventEncoder() {
-  return getStructEncoder27([
-    ["user", getAddressEncoder14()],
-    ["encryptedTokenAccount", getAddressEncoder14()],
+  return getStructEncoder28([
+    ["user", getAddressEncoder15()],
+    ["encryptedTokenAccount", getAddressEncoder15()],
     ["amount", getU64Encoder10()],
-    ["timestamp", getI64Encoder12()]
+    ["timestamp", getI64Encoder13()]
   ]);
 }
 function getPendingDepositClaimedEventDecoder() {
-  return getStructDecoder27([
-    ["user", getAddressDecoder14()],
-    ["encryptedTokenAccount", getAddressDecoder14()],
+  return getStructDecoder28([
+    ["user", getAddressDecoder15()],
+    ["encryptedTokenAccount", getAddressDecoder15()],
     ["amount", getU64Decoder10()],
-    ["timestamp", getI64Decoder12()]
+    ["timestamp", getI64Decoder13()]
   ]);
 }
 function getPendingDepositClaimedEventCodec() {
-  return combineCodec33(
+  return combineCodec34(
     getPendingDepositClaimedEventEncoder(),
     getPendingDepositClaimedEventDecoder()
   );
@@ -1410,34 +1439,34 @@ function getPendingDepositClaimedEventCodec() {
 
 // src/generated/types/revealPeriodExtendedEvent.ts
 import {
-  combineCodec as combineCodec34,
-  getAddressDecoder as getAddressDecoder15,
-  getAddressEncoder as getAddressEncoder15,
-  getI64Decoder as getI64Decoder13,
-  getI64Encoder as getI64Encoder13,
-  getStructDecoder as getStructDecoder28,
-  getStructEncoder as getStructEncoder28,
+  combineCodec as combineCodec35,
+  getAddressDecoder as getAddressDecoder16,
+  getAddressEncoder as getAddressEncoder16,
+  getI64Decoder as getI64Decoder14,
+  getI64Encoder as getI64Encoder14,
+  getStructDecoder as getStructDecoder29,
+  getStructEncoder as getStructEncoder29,
   getU64Decoder as getU64Decoder11,
   getU64Encoder as getU64Encoder11
 } from "@solana/kit";
 function getRevealPeriodExtendedEventEncoder() {
-  return getStructEncoder28([
-    ["market", getAddressEncoder15()],
-    ["authority", getAddressEncoder15()],
+  return getStructEncoder29([
+    ["market", getAddressEncoder16()],
+    ["authority", getAddressEncoder16()],
     ["newTimeToReveal", getU64Encoder11()],
-    ["timestamp", getI64Encoder13()]
+    ["timestamp", getI64Encoder14()]
   ]);
 }
 function getRevealPeriodExtendedEventDecoder() {
-  return getStructDecoder28([
-    ["market", getAddressDecoder15()],
-    ["authority", getAddressDecoder15()],
+  return getStructDecoder29([
+    ["market", getAddressDecoder16()],
+    ["authority", getAddressDecoder16()],
     ["newTimeToReveal", getU64Decoder11()],
-    ["timestamp", getI64Decoder13()]
+    ["timestamp", getI64Decoder14()]
   ]);
 }
 function getRevealPeriodExtendedEventCodec() {
-  return combineCodec34(
+  return combineCodec35(
     getRevealPeriodExtendedEventEncoder(),
     getRevealPeriodExtendedEventDecoder()
   );
@@ -1445,18 +1474,18 @@ function getRevealPeriodExtendedEventCodec() {
 
 // src/generated/types/revealSharesOutput.ts
 import {
-  combineCodec as combineCodec35,
-  getStructDecoder as getStructDecoder29,
-  getStructEncoder as getStructEncoder29
+  combineCodec as combineCodec36,
+  getStructDecoder as getStructDecoder30,
+  getStructEncoder as getStructEncoder30
 } from "@solana/kit";
 function getRevealSharesOutputEncoder() {
-  return getStructEncoder29([["field0", getRevealSharesOutputStruct0Encoder()]]);
+  return getStructEncoder30([["field0", getRevealSharesOutputStruct0Encoder()]]);
 }
 function getRevealSharesOutputDecoder() {
-  return getStructDecoder29([["field0", getRevealSharesOutputStruct0Decoder()]]);
+  return getStructDecoder30([["field0", getRevealSharesOutputStruct0Decoder()]]);
 }
 function getRevealSharesOutputCodec() {
-  return combineCodec35(
+  return combineCodec36(
     getRevealSharesOutputEncoder(),
     getRevealSharesOutputDecoder()
   );
@@ -1464,11 +1493,11 @@ function getRevealSharesOutputCodec() {
 
 // src/generated/types/revealSharesOutputStruct0.ts
 import {
-  combineCodec as combineCodec36,
+  combineCodec as combineCodec37,
   getArrayDecoder as getArrayDecoder12,
   getArrayEncoder as getArrayEncoder12,
-  getStructDecoder as getStructDecoder30,
-  getStructEncoder as getStructEncoder30,
+  getStructDecoder as getStructDecoder31,
+  getStructEncoder as getStructEncoder31,
   getU128Decoder as getU128Decoder7,
   getU128Encoder as getU128Encoder7,
   getU16Decoder as getU16Decoder3,
@@ -1479,12 +1508,12 @@ import {
   getU8Encoder as getU8Encoder14
 } from "@solana/kit";
 function getRevealSharesOutputStruct0Encoder() {
-  return getStructEncoder30([
+  return getStructEncoder31([
     ["field0", getU64Encoder12()],
     ["field1", getU16Encoder3()],
     [
       "field2",
-      getStructEncoder30([
+      getStructEncoder31([
         ["encryptionKey", getArrayEncoder12(getU8Encoder14(), { size: 32 })],
         ["nonce", getU128Encoder7()],
         [
@@ -1498,12 +1527,12 @@ function getRevealSharesOutputStruct0Encoder() {
   ]);
 }
 function getRevealSharesOutputStruct0Decoder() {
-  return getStructDecoder30([
+  return getStructDecoder31([
     ["field0", getU64Decoder12()],
     ["field1", getU16Decoder3()],
     [
       "field2",
-      getStructDecoder30([
+      getStructDecoder31([
         ["encryptionKey", getArrayDecoder12(getU8Decoder14(), { size: 32 })],
         ["nonce", getU128Decoder7()],
         [
@@ -1517,7 +1546,7 @@ function getRevealSharesOutputStruct0Decoder() {
   ]);
 }
 function getRevealSharesOutputStruct0Codec() {
-  return combineCodec36(
+  return combineCodec37(
     getRevealSharesOutputStruct0Encoder(),
     getRevealSharesOutputStruct0Decoder()
   );
@@ -1525,48 +1554,48 @@ function getRevealSharesOutputStruct0Codec() {
 
 // src/generated/types/rewardClaimedEvent.ts
 import {
-  combineCodec as combineCodec37,
-  getAddressDecoder as getAddressDecoder16,
-  getAddressEncoder as getAddressEncoder16,
-  getI64Decoder as getI64Decoder14,
-  getI64Encoder as getI64Encoder14,
-  getStructDecoder as getStructDecoder31,
-  getStructEncoder as getStructEncoder31,
+  combineCodec as combineCodec38,
+  getAddressDecoder as getAddressDecoder17,
+  getAddressEncoder as getAddressEncoder17,
+  getI64Decoder as getI64Decoder15,
+  getI64Encoder as getI64Encoder15,
+  getStructDecoder as getStructDecoder32,
+  getStructEncoder as getStructEncoder32,
   getU16Decoder as getU16Decoder4,
   getU16Encoder as getU16Encoder4,
   getU64Decoder as getU64Decoder13,
   getU64Encoder as getU64Encoder13
 } from "@solana/kit";
 function getRewardClaimedEventEncoder() {
-  return getStructEncoder31([
-    ["owner", getAddressEncoder16()],
-    ["market", getAddressEncoder16()],
-    ["shareAccount", getAddressEncoder16()],
+  return getStructEncoder32([
+    ["owner", getAddressEncoder17()],
+    ["market", getAddressEncoder17()],
+    ["shareAccount", getAddressEncoder17()],
     ["option", getU16Encoder4()],
     ["rewardAmount", getU64Encoder13()],
     ["stakedAtTimestamp", getU64Encoder13()],
     ["unstakedAtTimestamp", getU64Encoder13()],
     ["revealedScore", getU64Encoder13()],
     ["revealedAmount", getU64Encoder13()],
-    ["timestamp", getI64Encoder14()]
+    ["timestamp", getI64Encoder15()]
   ]);
 }
 function getRewardClaimedEventDecoder() {
-  return getStructDecoder31([
-    ["owner", getAddressDecoder16()],
-    ["market", getAddressDecoder16()],
-    ["shareAccount", getAddressDecoder16()],
+  return getStructDecoder32([
+    ["owner", getAddressDecoder17()],
+    ["market", getAddressDecoder17()],
+    ["shareAccount", getAddressDecoder17()],
     ["option", getU16Decoder4()],
     ["rewardAmount", getU64Decoder13()],
     ["stakedAtTimestamp", getU64Decoder13()],
     ["unstakedAtTimestamp", getU64Decoder13()],
     ["revealedScore", getU64Decoder13()],
     ["revealedAmount", getU64Decoder13()],
-    ["timestamp", getI64Decoder14()]
+    ["timestamp", getI64Decoder15()]
   ]);
 }
 function getRewardClaimedEventCodec() {
-  return combineCodec37(
+  return combineCodec38(
     getRewardClaimedEventEncoder(),
     getRewardClaimedEventDecoder()
   );
@@ -1574,36 +1603,36 @@ function getRewardClaimedEventCodec() {
 
 // src/generated/types/rewardPoolIncreasedEvent.ts
 import {
-  combineCodec as combineCodec38,
-  getAddressDecoder as getAddressDecoder17,
-  getAddressEncoder as getAddressEncoder17,
-  getI64Decoder as getI64Decoder15,
-  getI64Encoder as getI64Encoder15,
-  getStructDecoder as getStructDecoder32,
-  getStructEncoder as getStructEncoder32,
+  combineCodec as combineCodec39,
+  getAddressDecoder as getAddressDecoder18,
+  getAddressEncoder as getAddressEncoder18,
+  getI64Decoder as getI64Decoder16,
+  getI64Encoder as getI64Encoder16,
+  getStructDecoder as getStructDecoder33,
+  getStructEncoder as getStructEncoder33,
   getU64Decoder as getU64Decoder14,
   getU64Encoder as getU64Encoder14
 } from "@solana/kit";
 function getRewardPoolIncreasedEventEncoder() {
-  return getStructEncoder32([
-    ["market", getAddressEncoder17()],
-    ["authority", getAddressEncoder17()],
+  return getStructEncoder33([
+    ["market", getAddressEncoder18()],
+    ["authority", getAddressEncoder18()],
     ["oldRewardAmount", getU64Encoder14()],
     ["newRewardAmount", getU64Encoder14()],
-    ["timestamp", getI64Encoder15()]
+    ["timestamp", getI64Encoder16()]
   ]);
 }
 function getRewardPoolIncreasedEventDecoder() {
-  return getStructDecoder32([
-    ["market", getAddressDecoder17()],
-    ["authority", getAddressDecoder17()],
+  return getStructDecoder33([
+    ["market", getAddressDecoder18()],
+    ["authority", getAddressDecoder18()],
     ["oldRewardAmount", getU64Decoder14()],
     ["newRewardAmount", getU64Decoder14()],
-    ["timestamp", getI64Decoder15()]
+    ["timestamp", getI64Decoder16()]
   ]);
 }
 function getRewardPoolIncreasedEventCodec() {
-  return combineCodec38(
+  return combineCodec39(
     getRewardPoolIncreasedEventEncoder(),
     getRewardPoolIncreasedEventDecoder()
   );
@@ -1611,32 +1640,32 @@ function getRewardPoolIncreasedEventCodec() {
 
 // src/generated/types/shareAccountInitializedEvent.ts
 import {
-  combineCodec as combineCodec39,
-  getAddressDecoder as getAddressDecoder18,
-  getAddressEncoder as getAddressEncoder18,
-  getI64Decoder as getI64Decoder16,
-  getI64Encoder as getI64Encoder16,
-  getStructDecoder as getStructDecoder33,
-  getStructEncoder as getStructEncoder33
+  combineCodec as combineCodec40,
+  getAddressDecoder as getAddressDecoder19,
+  getAddressEncoder as getAddressEncoder19,
+  getI64Decoder as getI64Decoder17,
+  getI64Encoder as getI64Encoder17,
+  getStructDecoder as getStructDecoder34,
+  getStructEncoder as getStructEncoder34
 } from "@solana/kit";
 function getShareAccountInitializedEventEncoder() {
-  return getStructEncoder33([
-    ["shareAccount", getAddressEncoder18()],
-    ["owner", getAddressEncoder18()],
-    ["market", getAddressEncoder18()],
-    ["timestamp", getI64Encoder16()]
+  return getStructEncoder34([
+    ["shareAccount", getAddressEncoder19()],
+    ["owner", getAddressEncoder19()],
+    ["market", getAddressEncoder19()],
+    ["timestamp", getI64Encoder17()]
   ]);
 }
 function getShareAccountInitializedEventDecoder() {
-  return getStructDecoder33([
-    ["shareAccount", getAddressDecoder18()],
-    ["owner", getAddressDecoder18()],
-    ["market", getAddressDecoder18()],
-    ["timestamp", getI64Decoder16()]
+  return getStructDecoder34([
+    ["shareAccount", getAddressDecoder19()],
+    ["owner", getAddressDecoder19()],
+    ["market", getAddressDecoder19()],
+    ["timestamp", getI64Decoder17()]
   ]);
 }
 function getShareAccountInitializedEventCodec() {
-  return combineCodec39(
+  return combineCodec40(
     getShareAccountInitializedEventEncoder(),
     getShareAccountInitializedEventDecoder()
   );
@@ -1644,52 +1673,52 @@ function getShareAccountInitializedEventCodec() {
 
 // src/generated/types/stakedError.ts
 import {
-  combineCodec as combineCodec40,
-  getAddressDecoder as getAddressDecoder19,
-  getAddressEncoder as getAddressEncoder19,
-  getI64Decoder as getI64Decoder17,
-  getI64Encoder as getI64Encoder17,
-  getStructDecoder as getStructDecoder34,
-  getStructEncoder as getStructEncoder34
+  combineCodec as combineCodec41,
+  getAddressDecoder as getAddressDecoder20,
+  getAddressEncoder as getAddressEncoder20,
+  getI64Decoder as getI64Decoder18,
+  getI64Encoder as getI64Encoder18,
+  getStructDecoder as getStructDecoder35,
+  getStructEncoder as getStructEncoder35
 } from "@solana/kit";
 function getStakedErrorEncoder() {
-  return getStructEncoder34([
-    ["user", getAddressEncoder19()],
-    ["timestamp", getI64Encoder17()]
+  return getStructEncoder35([
+    ["user", getAddressEncoder20()],
+    ["timestamp", getI64Encoder18()]
   ]);
 }
 function getStakedErrorDecoder() {
-  return getStructDecoder34([
-    ["user", getAddressDecoder19()],
-    ["timestamp", getI64Decoder17()]
+  return getStructDecoder35([
+    ["user", getAddressDecoder20()],
+    ["timestamp", getI64Decoder18()]
   ]);
 }
 function getStakedErrorCodec() {
-  return combineCodec40(getStakedErrorEncoder(), getStakedErrorDecoder());
+  return combineCodec41(getStakedErrorEncoder(), getStakedErrorDecoder());
 }
 
 // src/generated/types/stakedEvent.ts
 import {
-  combineCodec as combineCodec41,
-  getAddressDecoder as getAddressDecoder20,
-  getAddressEncoder as getAddressEncoder20,
+  combineCodec as combineCodec42,
+  getAddressDecoder as getAddressDecoder21,
+  getAddressEncoder as getAddressEncoder21,
   getArrayDecoder as getArrayDecoder13,
   getArrayEncoder as getArrayEncoder13,
-  getI64Decoder as getI64Decoder18,
-  getI64Encoder as getI64Encoder18,
-  getStructDecoder as getStructDecoder35,
-  getStructEncoder as getStructEncoder35,
+  getI64Decoder as getI64Decoder19,
+  getI64Encoder as getI64Encoder19,
+  getStructDecoder as getStructDecoder36,
+  getStructEncoder as getStructEncoder36,
   getU128Decoder as getU128Decoder8,
   getU128Encoder as getU128Encoder8,
   getU8Decoder as getU8Decoder15,
   getU8Encoder as getU8Encoder15
 } from "@solana/kit";
 function getStakedEventEncoder() {
-  return getStructEncoder35([
-    ["user", getAddressEncoder20()],
-    ["market", getAddressEncoder20()],
-    ["encryptedTokenAccount", getAddressEncoder20()],
-    ["shareAccount", getAddressEncoder20()],
+  return getStructEncoder36([
+    ["user", getAddressEncoder21()],
+    ["market", getAddressEncoder21()],
+    ["encryptedTokenAccount", getAddressEncoder21()],
+    ["shareAccount", getAddressEncoder21()],
     [
       "shareEncryptedState",
       getArrayEncoder13(getArrayEncoder13(getU8Encoder15(), { size: 32 }), {
@@ -1706,15 +1735,15 @@ function getStakedEventEncoder() {
     ["shareStateDisclosureNonce", getU128Encoder8()],
     ["encryptedEtaBalance", getArrayEncoder13(getU8Encoder15(), { size: 32 })],
     ["etaBalanceNonce", getU128Encoder8()],
-    ["timestamp", getI64Encoder18()]
+    ["timestamp", getI64Encoder19()]
   ]);
 }
 function getStakedEventDecoder() {
-  return getStructDecoder35([
-    ["user", getAddressDecoder20()],
-    ["market", getAddressDecoder20()],
-    ["encryptedTokenAccount", getAddressDecoder20()],
-    ["shareAccount", getAddressDecoder20()],
+  return getStructDecoder36([
+    ["user", getAddressDecoder21()],
+    ["market", getAddressDecoder21()],
+    ["encryptedTokenAccount", getAddressDecoder21()],
+    ["shareAccount", getAddressDecoder21()],
     [
       "shareEncryptedState",
       getArrayDecoder13(getArrayDecoder13(getU8Decoder15(), { size: 32 }), {
@@ -1731,37 +1760,37 @@ function getStakedEventDecoder() {
     ["shareStateDisclosureNonce", getU128Decoder8()],
     ["encryptedEtaBalance", getArrayDecoder13(getU8Decoder15(), { size: 32 })],
     ["etaBalanceNonce", getU128Decoder8()],
-    ["timestamp", getI64Decoder18()]
+    ["timestamp", getI64Decoder19()]
   ]);
 }
 function getStakedEventCodec() {
-  return combineCodec41(getStakedEventEncoder(), getStakedEventDecoder());
+  return combineCodec42(getStakedEventEncoder(), getStakedEventDecoder());
 }
 
 // src/generated/types/stakeRevealedError.ts
 import {
-  combineCodec as combineCodec42,
-  getAddressDecoder as getAddressDecoder21,
-  getAddressEncoder as getAddressEncoder21,
-  getI64Decoder as getI64Decoder19,
-  getI64Encoder as getI64Encoder19,
-  getStructDecoder as getStructDecoder36,
-  getStructEncoder as getStructEncoder36
+  combineCodec as combineCodec43,
+  getAddressDecoder as getAddressDecoder22,
+  getAddressEncoder as getAddressEncoder22,
+  getI64Decoder as getI64Decoder20,
+  getI64Encoder as getI64Encoder20,
+  getStructDecoder as getStructDecoder37,
+  getStructEncoder as getStructEncoder37
 } from "@solana/kit";
 function getStakeRevealedErrorEncoder() {
-  return getStructEncoder36([
-    ["user", getAddressEncoder21()],
-    ["timestamp", getI64Encoder19()]
+  return getStructEncoder37([
+    ["user", getAddressEncoder22()],
+    ["timestamp", getI64Encoder20()]
   ]);
 }
 function getStakeRevealedErrorDecoder() {
-  return getStructDecoder36([
-    ["user", getAddressDecoder21()],
-    ["timestamp", getI64Decoder19()]
+  return getStructDecoder37([
+    ["user", getAddressDecoder22()],
+    ["timestamp", getI64Decoder20()]
   ]);
 }
 function getStakeRevealedErrorCodec() {
-  return combineCodec42(
+  return combineCodec43(
     getStakeRevealedErrorEncoder(),
     getStakeRevealedErrorDecoder()
   );
@@ -1769,42 +1798,42 @@ function getStakeRevealedErrorCodec() {
 
 // src/generated/types/stakeRevealedEvent.ts
 import {
-  combineCodec as combineCodec43,
-  getAddressDecoder as getAddressDecoder22,
-  getAddressEncoder as getAddressEncoder22,
-  getI64Decoder as getI64Decoder20,
-  getI64Encoder as getI64Encoder20,
-  getStructDecoder as getStructDecoder37,
-  getStructEncoder as getStructEncoder37,
+  combineCodec as combineCodec44,
+  getAddressDecoder as getAddressDecoder23,
+  getAddressEncoder as getAddressEncoder23,
+  getI64Decoder as getI64Decoder21,
+  getI64Encoder as getI64Encoder21,
+  getStructDecoder as getStructDecoder38,
+  getStructEncoder as getStructEncoder38,
   getU16Decoder as getU16Decoder5,
   getU16Encoder as getU16Encoder5,
   getU64Decoder as getU64Decoder15,
   getU64Encoder as getU64Encoder15
 } from "@solana/kit";
 function getStakeRevealedEventEncoder() {
-  return getStructEncoder37([
-    ["user", getAddressEncoder22()],
-    ["market", getAddressEncoder22()],
-    ["encryptedTokenAccount", getAddressEncoder22()],
-    ["shareAccount", getAddressEncoder22()],
+  return getStructEncoder38([
+    ["user", getAddressEncoder23()],
+    ["market", getAddressEncoder23()],
+    ["encryptedTokenAccount", getAddressEncoder23()],
+    ["shareAccount", getAddressEncoder23()],
     ["sharesAmount", getU64Encoder15()],
     ["selectedOption", getU16Encoder5()],
-    ["timestamp", getI64Encoder20()]
+    ["timestamp", getI64Encoder21()]
   ]);
 }
 function getStakeRevealedEventDecoder() {
-  return getStructDecoder37([
-    ["user", getAddressDecoder22()],
-    ["market", getAddressDecoder22()],
-    ["encryptedTokenAccount", getAddressDecoder22()],
-    ["shareAccount", getAddressDecoder22()],
+  return getStructDecoder38([
+    ["user", getAddressDecoder23()],
+    ["market", getAddressDecoder23()],
+    ["encryptedTokenAccount", getAddressDecoder23()],
+    ["shareAccount", getAddressDecoder23()],
     ["sharesAmount", getU64Decoder15()],
     ["selectedOption", getU16Decoder5()],
-    ["timestamp", getI64Decoder20()]
+    ["timestamp", getI64Decoder21()]
   ]);
 }
 function getStakeRevealedEventCodec() {
-  return combineCodec43(
+  return combineCodec44(
     getStakeRevealedEventEncoder(),
     getStakeRevealedEventDecoder()
   );
@@ -1812,42 +1841,42 @@ function getStakeRevealedEventCodec() {
 
 // src/generated/types/tallyIncrementedEvent.ts
 import {
-  combineCodec as combineCodec44,
-  getAddressDecoder as getAddressDecoder23,
-  getAddressEncoder as getAddressEncoder23,
-  getI64Decoder as getI64Decoder21,
-  getI64Encoder as getI64Encoder21,
-  getStructDecoder as getStructDecoder38,
-  getStructEncoder as getStructEncoder38,
+  combineCodec as combineCodec45,
+  getAddressDecoder as getAddressDecoder24,
+  getAddressEncoder as getAddressEncoder24,
+  getI64Decoder as getI64Decoder22,
+  getI64Encoder as getI64Encoder22,
+  getStructDecoder as getStructDecoder39,
+  getStructEncoder as getStructEncoder39,
   getU16Decoder as getU16Decoder6,
   getU16Encoder as getU16Encoder6,
   getU64Decoder as getU64Decoder16,
   getU64Encoder as getU64Encoder16
 } from "@solana/kit";
 function getTallyIncrementedEventEncoder() {
-  return getStructEncoder38([
-    ["owner", getAddressEncoder23()],
-    ["market", getAddressEncoder23()],
-    ["shareAccount", getAddressEncoder23()],
+  return getStructEncoder39([
+    ["owner", getAddressEncoder24()],
+    ["market", getAddressEncoder24()],
+    ["shareAccount", getAddressEncoder24()],
     ["option", getU16Encoder6()],
     ["revealedAmount", getU64Encoder16()],
     ["userScore", getU64Encoder16()],
-    ["timestamp", getI64Encoder21()]
+    ["timestamp", getI64Encoder22()]
   ]);
 }
 function getTallyIncrementedEventDecoder() {
-  return getStructDecoder38([
-    ["owner", getAddressDecoder23()],
-    ["market", getAddressDecoder23()],
-    ["shareAccount", getAddressDecoder23()],
+  return getStructDecoder39([
+    ["owner", getAddressDecoder24()],
+    ["market", getAddressDecoder24()],
+    ["shareAccount", getAddressDecoder24()],
     ["option", getU16Decoder6()],
     ["revealedAmount", getU64Decoder16()],
     ["userScore", getU64Decoder16()],
-    ["timestamp", getI64Decoder21()]
+    ["timestamp", getI64Decoder22()]
   ]);
 }
 function getTallyIncrementedEventCodec() {
-  return combineCodec44(
+  return combineCodec45(
     getTallyIncrementedEventEncoder(),
     getTallyIncrementedEventDecoder()
   );
@@ -1855,97 +1884,97 @@ function getTallyIncrementedEventCodec() {
 
 // src/generated/types/timestamp.ts
 import {
-  combineCodec as combineCodec45,
-  getStructDecoder as getStructDecoder39,
-  getStructEncoder as getStructEncoder39,
+  combineCodec as combineCodec46,
+  getStructDecoder as getStructDecoder40,
+  getStructEncoder as getStructEncoder40,
   getU64Decoder as getU64Decoder17,
   getU64Encoder as getU64Encoder17
 } from "@solana/kit";
 function getTimestampEncoder() {
-  return getStructEncoder39([["timestamp", getU64Encoder17()]]);
+  return getStructEncoder40([["timestamp", getU64Encoder17()]]);
 }
 function getTimestampDecoder() {
-  return getStructDecoder39([["timestamp", getU64Decoder17()]]);
+  return getStructDecoder40([["timestamp", getU64Decoder17()]]);
 }
 function getTimestampCodec() {
-  return combineCodec45(getTimestampEncoder(), getTimestampDecoder());
+  return combineCodec46(getTimestampEncoder(), getTimestampDecoder());
 }
 
 // src/generated/types/unstakedError.ts
 import {
-  combineCodec as combineCodec46,
-  getAddressDecoder as getAddressDecoder24,
-  getAddressEncoder as getAddressEncoder24,
-  getI64Decoder as getI64Decoder22,
-  getI64Encoder as getI64Encoder22,
-  getStructDecoder as getStructDecoder40,
-  getStructEncoder as getStructEncoder40
+  combineCodec as combineCodec47,
+  getAddressDecoder as getAddressDecoder25,
+  getAddressEncoder as getAddressEncoder25,
+  getI64Decoder as getI64Decoder23,
+  getI64Encoder as getI64Encoder23,
+  getStructDecoder as getStructDecoder41,
+  getStructEncoder as getStructEncoder41
 } from "@solana/kit";
 function getUnstakedErrorEncoder() {
-  return getStructEncoder40([
-    ["user", getAddressEncoder24()],
-    ["timestamp", getI64Encoder22()]
+  return getStructEncoder41([
+    ["user", getAddressEncoder25()],
+    ["timestamp", getI64Encoder23()]
   ]);
 }
 function getUnstakedErrorDecoder() {
-  return getStructDecoder40([
-    ["user", getAddressDecoder24()],
-    ["timestamp", getI64Decoder22()]
+  return getStructDecoder41([
+    ["user", getAddressDecoder25()],
+    ["timestamp", getI64Decoder23()]
   ]);
 }
 function getUnstakedErrorCodec() {
-  return combineCodec46(getUnstakedErrorEncoder(), getUnstakedErrorDecoder());
+  return combineCodec47(getUnstakedErrorEncoder(), getUnstakedErrorDecoder());
 }
 
 // src/generated/types/unstakedEvent.ts
 import {
-  combineCodec as combineCodec47,
-  getAddressDecoder as getAddressDecoder25,
-  getAddressEncoder as getAddressEncoder25,
-  getI64Decoder as getI64Decoder23,
-  getI64Encoder as getI64Encoder23,
-  getStructDecoder as getStructDecoder41,
-  getStructEncoder as getStructEncoder41
+  combineCodec as combineCodec48,
+  getAddressDecoder as getAddressDecoder26,
+  getAddressEncoder as getAddressEncoder26,
+  getI64Decoder as getI64Decoder24,
+  getI64Encoder as getI64Encoder24,
+  getStructDecoder as getStructDecoder42,
+  getStructEncoder as getStructEncoder42
 } from "@solana/kit";
 function getUnstakedEventEncoder() {
-  return getStructEncoder41([
-    ["user", getAddressEncoder25()],
-    ["market", getAddressEncoder25()],
-    ["encryptedTokenAccount", getAddressEncoder25()],
-    ["shareAccount", getAddressEncoder25()],
-    ["timestamp", getI64Encoder23()]
+  return getStructEncoder42([
+    ["user", getAddressEncoder26()],
+    ["market", getAddressEncoder26()],
+    ["encryptedTokenAccount", getAddressEncoder26()],
+    ["shareAccount", getAddressEncoder26()],
+    ["timestamp", getI64Encoder24()]
   ]);
 }
 function getUnstakedEventDecoder() {
-  return getStructDecoder41([
-    ["user", getAddressDecoder25()],
-    ["market", getAddressDecoder25()],
-    ["encryptedTokenAccount", getAddressDecoder25()],
-    ["shareAccount", getAddressDecoder25()],
-    ["timestamp", getI64Decoder23()]
+  return getStructDecoder42([
+    ["user", getAddressDecoder26()],
+    ["market", getAddressDecoder26()],
+    ["encryptedTokenAccount", getAddressDecoder26()],
+    ["shareAccount", getAddressDecoder26()],
+    ["timestamp", getI64Decoder24()]
   ]);
 }
 function getUnstakedEventCodec() {
-  return combineCodec47(getUnstakedEventEncoder(), getUnstakedEventDecoder());
+  return combineCodec48(getUnstakedEventEncoder(), getUnstakedEventDecoder());
 }
 
 // src/generated/types/unstakeEarlyOutput.ts
 import {
-  combineCodec as combineCodec48,
+  combineCodec as combineCodec49,
   getArrayDecoder as getArrayDecoder14,
   getArrayEncoder as getArrayEncoder14,
-  getStructDecoder as getStructDecoder42,
-  getStructEncoder as getStructEncoder42,
+  getStructDecoder as getStructDecoder43,
+  getStructEncoder as getStructEncoder43,
   getU128Decoder as getU128Decoder9,
   getU128Encoder as getU128Encoder9,
   getU8Decoder as getU8Decoder16,
   getU8Encoder as getU8Encoder16
 } from "@solana/kit";
 function getUnstakeEarlyOutputEncoder() {
-  return getStructEncoder42([
+  return getStructEncoder43([
     [
       "field0",
-      getStructEncoder42([
+      getStructEncoder43([
         ["encryptionKey", getArrayEncoder14(getU8Encoder16(), { size: 32 })],
         ["nonce", getU128Encoder9()],
         [
@@ -1959,10 +1988,10 @@ function getUnstakeEarlyOutputEncoder() {
   ]);
 }
 function getUnstakeEarlyOutputDecoder() {
-  return getStructDecoder42([
+  return getStructDecoder43([
     [
       "field0",
-      getStructDecoder42([
+      getStructDecoder43([
         ["encryptionKey", getArrayDecoder14(getU8Decoder16(), { size: 32 })],
         ["nonce", getU128Decoder9()],
         [
@@ -1976,7 +2005,7 @@ function getUnstakeEarlyOutputDecoder() {
   ]);
 }
 function getUnstakeEarlyOutputCodec() {
-  return combineCodec48(
+  return combineCodec49(
     getUnstakeEarlyOutputEncoder(),
     getUnstakeEarlyOutputDecoder()
   );
@@ -1984,36 +2013,36 @@ function getUnstakeEarlyOutputCodec() {
 
 // src/generated/types/unstakeInitiatedEvent.ts
 import {
-  combineCodec as combineCodec49,
-  getAddressDecoder as getAddressDecoder26,
-  getAddressEncoder as getAddressEncoder26,
-  getI64Decoder as getI64Decoder24,
-  getI64Encoder as getI64Encoder24,
-  getStructDecoder as getStructDecoder43,
-  getStructEncoder as getStructEncoder43,
+  combineCodec as combineCodec50,
+  getAddressDecoder as getAddressDecoder27,
+  getAddressEncoder as getAddressEncoder27,
+  getI64Decoder as getI64Decoder25,
+  getI64Encoder as getI64Encoder25,
+  getStructDecoder as getStructDecoder44,
+  getStructEncoder as getStructEncoder44,
   getU64Decoder as getU64Decoder18,
   getU64Encoder as getU64Encoder18
 } from "@solana/kit";
 function getUnstakeInitiatedEventEncoder() {
-  return getStructEncoder43([
-    ["user", getAddressEncoder26()],
-    ["market", getAddressEncoder26()],
-    ["shareAccount", getAddressEncoder26()],
+  return getStructEncoder44([
+    ["user", getAddressEncoder27()],
+    ["market", getAddressEncoder27()],
+    ["shareAccount", getAddressEncoder27()],
     ["unstakeableAtTimestamp", getU64Encoder18()],
-    ["timestamp", getI64Encoder24()]
+    ["timestamp", getI64Encoder25()]
   ]);
 }
 function getUnstakeInitiatedEventDecoder() {
-  return getStructDecoder43([
-    ["user", getAddressDecoder26()],
-    ["market", getAddressDecoder26()],
-    ["shareAccount", getAddressDecoder26()],
+  return getStructDecoder44([
+    ["user", getAddressDecoder27()],
+    ["market", getAddressDecoder27()],
+    ["shareAccount", getAddressDecoder27()],
     ["unstakeableAtTimestamp", getU64Decoder18()],
-    ["timestamp", getI64Decoder24()]
+    ["timestamp", getI64Decoder25()]
   ]);
 }
 function getUnstakeInitiatedEventCodec() {
-  return combineCodec49(
+  return combineCodec50(
     getUnstakeInitiatedEventEncoder(),
     getUnstakeInitiatedEventDecoder()
   );
@@ -2021,22 +2050,22 @@ function getUnstakeInitiatedEventCodec() {
 
 // src/generated/types/unwrapEncryptedTokensOutput.ts
 import {
-  combineCodec as combineCodec50,
-  getStructDecoder as getStructDecoder44,
-  getStructEncoder as getStructEncoder44
+  combineCodec as combineCodec51,
+  getStructDecoder as getStructDecoder45,
+  getStructEncoder as getStructEncoder45
 } from "@solana/kit";
 function getUnwrapEncryptedTokensOutputEncoder() {
-  return getStructEncoder44([
+  return getStructEncoder45([
     ["field0", getUnwrapEncryptedTokensOutputStruct0Encoder()]
   ]);
 }
 function getUnwrapEncryptedTokensOutputDecoder() {
-  return getStructDecoder44([
+  return getStructDecoder45([
     ["field0", getUnwrapEncryptedTokensOutputStruct0Decoder()]
   ]);
 }
 function getUnwrapEncryptedTokensOutputCodec() {
-  return combineCodec50(
+  return combineCodec51(
     getUnwrapEncryptedTokensOutputEncoder(),
     getUnwrapEncryptedTokensOutputDecoder()
   );
@@ -2044,13 +2073,13 @@ function getUnwrapEncryptedTokensOutputCodec() {
 
 // src/generated/types/unwrapEncryptedTokensOutputStruct0.ts
 import {
-  combineCodec as combineCodec51,
+  combineCodec as combineCodec52,
   getArrayDecoder as getArrayDecoder15,
   getArrayEncoder as getArrayEncoder15,
   getBooleanDecoder as getBooleanDecoder6,
   getBooleanEncoder as getBooleanEncoder6,
-  getStructDecoder as getStructDecoder45,
-  getStructEncoder as getStructEncoder45,
+  getStructDecoder as getStructDecoder46,
+  getStructEncoder as getStructEncoder46,
   getU128Decoder as getU128Decoder10,
   getU128Encoder as getU128Encoder10,
   getU64Decoder as getU64Decoder19,
@@ -2059,12 +2088,12 @@ import {
   getU8Encoder as getU8Encoder17
 } from "@solana/kit";
 function getUnwrapEncryptedTokensOutputStruct0Encoder() {
-  return getStructEncoder45([
+  return getStructEncoder46([
     ["field0", getBooleanEncoder6()],
     ["field1", getU64Encoder19()],
     [
       "field2",
-      getStructEncoder45([
+      getStructEncoder46([
         ["encryptionKey", getArrayEncoder15(getU8Encoder17(), { size: 32 })],
         ["nonce", getU128Encoder10()],
         [
@@ -2078,12 +2107,12 @@ function getUnwrapEncryptedTokensOutputStruct0Encoder() {
   ]);
 }
 function getUnwrapEncryptedTokensOutputStruct0Decoder() {
-  return getStructDecoder45([
+  return getStructDecoder46([
     ["field0", getBooleanDecoder6()],
     ["field1", getU64Decoder19()],
     [
       "field2",
-      getStructDecoder45([
+      getStructDecoder46([
         ["encryptionKey", getArrayDecoder15(getU8Decoder17(), { size: 32 })],
         ["nonce", getU128Decoder10()],
         [
@@ -2097,7 +2126,7 @@ function getUnwrapEncryptedTokensOutputStruct0Decoder() {
   ]);
 }
 function getUnwrapEncryptedTokensOutputStruct0Codec() {
-  return combineCodec51(
+  return combineCodec52(
     getUnwrapEncryptedTokensOutputStruct0Encoder(),
     getUnwrapEncryptedTokensOutputStruct0Decoder()
   );
@@ -2105,16 +2134,16 @@ function getUnwrapEncryptedTokensOutputStruct0Codec() {
 
 // src/generated/types/utilityPubkeys.ts
 import {
-  combineCodec as combineCodec52,
+  combineCodec as combineCodec53,
   getArrayDecoder as getArrayDecoder16,
   getArrayEncoder as getArrayEncoder16,
-  getStructDecoder as getStructDecoder46,
-  getStructEncoder as getStructEncoder46,
+  getStructDecoder as getStructDecoder47,
+  getStructEncoder as getStructEncoder47,
   getU8Decoder as getU8Decoder18,
   getU8Encoder as getU8Encoder18
 } from "@solana/kit";
 function getUtilityPubkeysEncoder() {
-  return getStructEncoder46([
+  return getStructEncoder47([
     ["x25519Pubkey", getArrayEncoder16(getU8Encoder18(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayEncoder16(getU8Encoder18(), { size: 32 })],
     ["elgamalPubkey", getArrayEncoder16(getU8Encoder18(), { size: 32 })],
@@ -2122,7 +2151,7 @@ function getUtilityPubkeysEncoder() {
   ]);
 }
 function getUtilityPubkeysDecoder() {
-  return getStructDecoder46([
+  return getStructDecoder47([
     ["x25519Pubkey", getArrayDecoder16(getU8Decoder18(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayDecoder16(getU8Decoder18(), { size: 32 })],
     ["elgamalPubkey", getArrayDecoder16(getU8Decoder18(), { size: 32 })],
@@ -2130,65 +2159,65 @@ function getUtilityPubkeysDecoder() {
   ]);
 }
 function getUtilityPubkeysCodec() {
-  return combineCodec52(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
+  return combineCodec53(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
 }
 
 // src/generated/types/winningOption.ts
 import {
-  combineCodec as combineCodec53,
-  getStructDecoder as getStructDecoder47,
-  getStructEncoder as getStructEncoder47,
+  combineCodec as combineCodec54,
+  getStructDecoder as getStructDecoder48,
+  getStructEncoder as getStructEncoder48,
   getU16Decoder as getU16Decoder7,
   getU16Encoder as getU16Encoder7,
   getU8Decoder as getU8Decoder19,
   getU8Encoder as getU8Encoder19
 } from "@solana/kit";
 function getWinningOptionEncoder() {
-  return getStructEncoder47([
+  return getStructEncoder48([
     ["optionIndex", getU16Encoder7()],
     ["rewardPercentage", getU8Encoder19()]
   ]);
 }
 function getWinningOptionDecoder() {
-  return getStructDecoder47([
+  return getStructDecoder48([
     ["optionIndex", getU16Decoder7()],
     ["rewardPercentage", getU8Decoder19()]
   ]);
 }
 function getWinningOptionCodec() {
-  return combineCodec53(getWinningOptionEncoder(), getWinningOptionDecoder());
+  return combineCodec54(getWinningOptionEncoder(), getWinningOptionDecoder());
 }
 
 // src/generated/types/winningOptionsSelectedEvent.ts
 import {
-  combineCodec as combineCodec54,
-  getAddressDecoder as getAddressDecoder27,
-  getAddressEncoder as getAddressEncoder27,
+  combineCodec as combineCodec55,
+  getAddressDecoder as getAddressDecoder28,
+  getAddressEncoder as getAddressEncoder28,
   getArrayDecoder as getArrayDecoder17,
   getArrayEncoder as getArrayEncoder17,
-  getI64Decoder as getI64Decoder25,
-  getI64Encoder as getI64Encoder25,
-  getStructDecoder as getStructDecoder48,
-  getStructEncoder as getStructEncoder48
+  getI64Decoder as getI64Decoder26,
+  getI64Encoder as getI64Encoder26,
+  getStructDecoder as getStructDecoder49,
+  getStructEncoder as getStructEncoder49
 } from "@solana/kit";
 function getWinningOptionsSelectedEventEncoder() {
-  return getStructEncoder48([
-    ["market", getAddressEncoder27()],
-    ["authority", getAddressEncoder27()],
+  return getStructEncoder49([
+    ["market", getAddressEncoder28()],
+    ["authority", getAddressEncoder28()],
     ["selectedOptions", getArrayEncoder17(getWinningOptionEncoder())],
-    ["timestamp", getI64Encoder25()]
+    ["timestamp", getI64Encoder26()]
   ]);
 }
 function getWinningOptionsSelectedEventDecoder() {
-  return getStructDecoder48([
-    ["market", getAddressDecoder27()],
-    ["authority", getAddressDecoder27()],
+  return getStructDecoder49([
+    ["market", getAddressDecoder28()],
+    ["authority", getAddressDecoder28()],
     ["selectedOptions", getArrayDecoder17(getWinningOptionDecoder())],
-    ["timestamp", getI64Decoder25()]
+    ["timestamp", getI64Decoder26()]
   ]);
 }
 function getWinningOptionsSelectedEventCodec() {
-  return combineCodec54(
+  return combineCodec55(
     getWinningOptionsSelectedEventEncoder(),
     getWinningOptionsSelectedEventDecoder()
   );
@@ -2196,21 +2225,21 @@ function getWinningOptionsSelectedEventCodec() {
 
 // src/generated/types/wrapEncryptedTokensOutput.ts
 import {
-  combineCodec as combineCodec55,
+  combineCodec as combineCodec56,
   getArrayDecoder as getArrayDecoder18,
   getArrayEncoder as getArrayEncoder18,
-  getStructDecoder as getStructDecoder49,
-  getStructEncoder as getStructEncoder49,
+  getStructDecoder as getStructDecoder50,
+  getStructEncoder as getStructEncoder50,
   getU128Decoder as getU128Decoder11,
   getU128Encoder as getU128Encoder11,
   getU8Decoder as getU8Decoder20,
   getU8Encoder as getU8Encoder20
 } from "@solana/kit";
 function getWrapEncryptedTokensOutputEncoder() {
-  return getStructEncoder49([
+  return getStructEncoder50([
     [
       "field0",
-      getStructEncoder49([
+      getStructEncoder50([
         ["encryptionKey", getArrayEncoder18(getU8Encoder20(), { size: 32 })],
         ["nonce", getU128Encoder11()],
         [
@@ -2224,10 +2253,10 @@ function getWrapEncryptedTokensOutputEncoder() {
   ]);
 }
 function getWrapEncryptedTokensOutputDecoder() {
-  return getStructDecoder49([
+  return getStructDecoder50([
     [
       "field0",
-      getStructDecoder49([
+      getStructDecoder50([
         ["encryptionKey", getArrayDecoder18(getU8Decoder20(), { size: 32 })],
         ["nonce", getU128Decoder11()],
         [
@@ -2241,7 +2270,7 @@ function getWrapEncryptedTokensOutputDecoder() {
   ]);
 }
 function getWrapEncryptedTokensOutputCodec() {
-  return combineCodec55(
+  return combineCodec56(
     getWrapEncryptedTokensOutputEncoder(),
     getWrapEncryptedTokensOutputDecoder()
   );
@@ -2265,7 +2294,7 @@ function getClockAccountDiscriminatorBytes() {
 }
 function getClockAccountEncoder() {
   return transformEncoder3(
-    getStructEncoder50([
+    getStructEncoder51([
       ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
       ["startEpoch", getEpochEncoder()],
       ["currentEpoch", getEpochEncoder()],
@@ -2276,7 +2305,7 @@ function getClockAccountEncoder() {
   );
 }
 function getClockAccountDecoder() {
-  return getStructDecoder50([
+  return getStructDecoder51([
     ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
     ["startEpoch", getEpochDecoder()],
     ["currentEpoch", getEpochDecoder()],
@@ -2285,7 +2314,7 @@ function getClockAccountDecoder() {
   ]);
 }
 function getClockAccountCodec() {
-  return combineCodec56(getClockAccountEncoder(), getClockAccountDecoder());
+  return combineCodec57(getClockAccountEncoder(), getClockAccountDecoder());
 }
 function decodeClockAccount(encodedAccount) {
   return decodeAccount3(
@@ -2316,14 +2345,14 @@ async function fetchAllMaybeClockAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists4,
   assertAccountsExist as assertAccountsExist4,
-  combineCodec as combineCodec57,
+  combineCodec as combineCodec58,
   decodeAccount as decodeAccount4,
   fetchEncodedAccount as fetchEncodedAccount4,
   fetchEncodedAccounts as fetchEncodedAccounts4,
   fixDecoderSize as fixDecoderSize4,
   fixEncoderSize as fixEncoderSize4,
-  getAddressDecoder as getAddressDecoder28,
-  getAddressEncoder as getAddressEncoder28,
+  getAddressDecoder as getAddressDecoder29,
+  getAddressEncoder as getAddressEncoder29,
   getArrayDecoder as getArrayDecoder19,
   getArrayEncoder as getArrayEncoder19,
   getBooleanDecoder as getBooleanDecoder7,
@@ -2334,8 +2363,8 @@ import {
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder2,
   getOptionDecoder as getOptionDecoder2,
   getOptionEncoder as getOptionEncoder2,
-  getStructDecoder as getStructDecoder51,
-  getStructEncoder as getStructEncoder51,
+  getStructDecoder as getStructDecoder52,
+  getStructEncoder as getStructEncoder52,
   getTupleDecoder as getTupleDecoder4,
   getTupleEncoder as getTupleEncoder4,
   getU16Decoder as getU16Decoder8,
@@ -2363,10 +2392,10 @@ function getClusterDiscriminatorBytes() {
 }
 function getClusterEncoder() {
   return transformEncoder4(
-    getStructEncoder51([
+    getStructEncoder52([
       ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
       ["tdInfo", getOptionEncoder2(getNodeMetadataEncoder())],
-      ["authority", getOptionEncoder2(getAddressEncoder28())],
+      ["authority", getOptionEncoder2(getAddressEncoder29())],
       ["clusterSize", getU16Encoder8()],
       ["activation", getActivationEncoder()],
       ["maxCapacity", getU64Encoder20()],
@@ -2380,13 +2409,13 @@ function getClusterEncoder() {
         getDiscriminatedUnionEncoder2([
           [
             "Set",
-            getStructEncoder51([
+            getStructEncoder52([
               ["fields", getTupleEncoder4([getBN254G2BLSPublicKeyEncoder()])]
             ])
           ],
           [
             "Unset",
-            getStructEncoder51([
+            getStructEncoder52([
               [
                 "fields",
                 getTupleEncoder4([
@@ -2404,10 +2433,10 @@ function getClusterEncoder() {
   );
 }
 function getClusterDecoder() {
-  return getStructDecoder51([
+  return getStructDecoder52([
     ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
     ["tdInfo", getOptionDecoder2(getNodeMetadataDecoder())],
-    ["authority", getOptionDecoder2(getAddressDecoder28())],
+    ["authority", getOptionDecoder2(getAddressDecoder29())],
     ["clusterSize", getU16Decoder8()],
     ["activation", getActivationDecoder()],
     ["maxCapacity", getU64Decoder20()],
@@ -2421,13 +2450,13 @@ function getClusterDecoder() {
       getDiscriminatedUnionDecoder2([
         [
           "Set",
-          getStructDecoder51([
+          getStructDecoder52([
             ["fields", getTupleDecoder4([getBN254G2BLSPublicKeyDecoder()])]
           ])
         ],
         [
           "Unset",
-          getStructDecoder51([
+          getStructDecoder52([
             [
               "fields",
               getTupleDecoder4([
@@ -2443,7 +2472,7 @@ function getClusterDecoder() {
   ]);
 }
 function getClusterCodec() {
-  return combineCodec57(getClusterEncoder(), getClusterDecoder());
+  return combineCodec58(getClusterEncoder(), getClusterDecoder());
 }
 function decodeCluster(encodedAccount) {
   return decodeAccount4(
@@ -2474,20 +2503,20 @@ async function fetchAllMaybeCluster(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists5,
   assertAccountsExist as assertAccountsExist5,
-  combineCodec as combineCodec58,
+  combineCodec as combineCodec59,
   decodeAccount as decodeAccount5,
   fetchEncodedAccount as fetchEncodedAccount5,
   fetchEncodedAccounts as fetchEncodedAccounts5,
   fixDecoderSize as fixDecoderSize5,
   fixEncoderSize as fixEncoderSize5,
-  getAddressDecoder as getAddressDecoder29,
-  getAddressEncoder as getAddressEncoder29,
+  getAddressDecoder as getAddressDecoder30,
+  getAddressEncoder as getAddressEncoder30,
   getBytesDecoder as getBytesDecoder5,
   getBytesEncoder as getBytesEncoder5,
   getOptionDecoder as getOptionDecoder3,
   getOptionEncoder as getOptionEncoder3,
-  getStructDecoder as getStructDecoder52,
-  getStructEncoder as getStructEncoder52,
+  getStructDecoder as getStructDecoder53,
+  getStructEncoder as getStructEncoder53,
   getU64Decoder as getU64Decoder21,
   getU64Encoder as getU64Encoder21,
   getU8Decoder as getU8Decoder23,
@@ -2511,9 +2540,9 @@ function getComputationDefinitionAccountDiscriminatorBytes() {
 }
 function getComputationDefinitionAccountEncoder() {
   return transformEncoder5(
-    getStructEncoder52([
+    getStructEncoder53([
       ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
-      ["finalizationAuthority", getOptionEncoder3(getAddressEncoder29())],
+      ["finalizationAuthority", getOptionEncoder3(getAddressEncoder30())],
       ["cuAmount", getU64Encoder21()],
       ["definition", getComputationDefinitionMetaEncoder()],
       ["circuitSource", getCircuitSourceEncoder()],
@@ -2526,9 +2555,9 @@ function getComputationDefinitionAccountEncoder() {
   );
 }
 function getComputationDefinitionAccountDecoder() {
-  return getStructDecoder52([
+  return getStructDecoder53([
     ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
-    ["finalizationAuthority", getOptionDecoder3(getAddressDecoder29())],
+    ["finalizationAuthority", getOptionDecoder3(getAddressDecoder30())],
     ["cuAmount", getU64Decoder21()],
     ["definition", getComputationDefinitionMetaDecoder()],
     ["circuitSource", getCircuitSourceDecoder()],
@@ -2536,7 +2565,7 @@ function getComputationDefinitionAccountDecoder() {
   ]);
 }
 function getComputationDefinitionAccountCodec() {
-  return combineCodec58(
+  return combineCodec59(
     getComputationDefinitionAccountEncoder(),
     getComputationDefinitionAccountDecoder()
   );
@@ -2580,14 +2609,14 @@ async function fetchAllMaybeComputationDefinitionAccount(rpc, addresses, config)
 import {
   assertAccountExists as assertAccountExists6,
   assertAccountsExist as assertAccountsExist6,
-  combineCodec as combineCodec59,
+  combineCodec as combineCodec60,
   decodeAccount as decodeAccount6,
   fetchEncodedAccount as fetchEncodedAccount6,
   fetchEncodedAccounts as fetchEncodedAccounts6,
   fixDecoderSize as fixDecoderSize6,
   fixEncoderSize as fixEncoderSize6,
-  getAddressDecoder as getAddressDecoder30,
-  getAddressEncoder as getAddressEncoder30,
+  getAddressDecoder as getAddressDecoder31,
+  getAddressEncoder as getAddressEncoder31,
   getArrayDecoder as getArrayDecoder20,
   getArrayEncoder as getArrayEncoder20,
   getBooleanDecoder as getBooleanDecoder8,
@@ -2596,8 +2625,8 @@ import {
   getBytesEncoder as getBytesEncoder6,
   getOptionDecoder as getOptionDecoder4,
   getOptionEncoder as getOptionEncoder4,
-  getStructDecoder as getStructDecoder53,
-  getStructEncoder as getStructEncoder53,
+  getStructDecoder as getStructDecoder54,
+  getStructEncoder as getStructEncoder54,
   getU128Decoder as getU128Decoder12,
   getU128Encoder as getU128Encoder12,
   getU64Decoder as getU64Decoder22,
@@ -2623,7 +2652,7 @@ function getEncryptedTokenAccountDiscriminatorBytes() {
 }
 function getEncryptedTokenAccountEncoder() {
   return transformEncoder6(
-    getStructEncoder53([
+    getStructEncoder54([
       ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
       [
         "encryptedState",
@@ -2633,13 +2662,13 @@ function getEncryptedTokenAccountEncoder() {
       ],
       ["bump", getU8Encoder24()],
       ["index", getU64Encoder22()],
-      ["owner", getAddressEncoder30()],
+      ["owner", getAddressEncoder31()],
       ["stateNonce", getU128Encoder12()],
-      ["tokenMint", getAddressEncoder30()],
+      ["tokenMint", getAddressEncoder31()],
       ["userPubkey", getArrayEncoder20(getU8Encoder24(), { size: 32 })],
       ["locked", getBooleanEncoder8()],
       ["pendingDeposit", getU64Encoder22()],
-      ["rentPayer", getOptionEncoder4(getAddressEncoder30())],
+      ["rentPayer", getOptionEncoder4(getAddressEncoder31())],
       ["isInitialized", getBooleanEncoder8()]
     ]),
     (value) => ({
@@ -2649,7 +2678,7 @@ function getEncryptedTokenAccountEncoder() {
   );
 }
 function getEncryptedTokenAccountDecoder() {
-  return getStructDecoder53([
+  return getStructDecoder54([
     ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
     [
       "encryptedState",
@@ -2659,18 +2688,18 @@ function getEncryptedTokenAccountDecoder() {
     ],
     ["bump", getU8Decoder24()],
     ["index", getU64Decoder22()],
-    ["owner", getAddressDecoder30()],
+    ["owner", getAddressDecoder31()],
     ["stateNonce", getU128Decoder12()],
-    ["tokenMint", getAddressDecoder30()],
+    ["tokenMint", getAddressDecoder31()],
     ["userPubkey", getArrayDecoder20(getU8Decoder24(), { size: 32 })],
     ["locked", getBooleanDecoder8()],
     ["pendingDeposit", getU64Decoder22()],
-    ["rentPayer", getOptionDecoder4(getAddressDecoder30())],
+    ["rentPayer", getOptionDecoder4(getAddressDecoder31())],
     ["isInitialized", getBooleanDecoder8()]
   ]);
 }
 function getEncryptedTokenAccountCodec() {
-  return combineCodec59(
+  return combineCodec60(
     getEncryptedTokenAccountEncoder(),
     getEncryptedTokenAccountDecoder()
   );
@@ -2714,7 +2743,7 @@ async function fetchAllMaybeEncryptedTokenAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists7,
   assertAccountsExist as assertAccountsExist7,
-  combineCodec as combineCodec60,
+  combineCodec as combineCodec61,
   decodeAccount as decodeAccount7,
   fetchEncodedAccount as fetchEncodedAccount7,
   fetchEncodedAccounts as fetchEncodedAccounts7,
@@ -2722,8 +2751,8 @@ import {
   fixEncoderSize as fixEncoderSize7,
   getBytesDecoder as getBytesDecoder7,
   getBytesEncoder as getBytesEncoder7,
-  getStructDecoder as getStructDecoder54,
-  getStructEncoder as getStructEncoder54,
+  getStructDecoder as getStructDecoder55,
+  getStructEncoder as getStructEncoder55,
   getU8Decoder as getU8Decoder25,
   getU8Encoder as getU8Encoder25,
   transformEncoder as transformEncoder7
@@ -2743,7 +2772,7 @@ function getFeePoolDiscriminatorBytes() {
 }
 function getFeePoolEncoder() {
   return transformEncoder7(
-    getStructEncoder54([
+    getStructEncoder55([
       ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
       ["bump", getU8Encoder25()]
     ]),
@@ -2751,13 +2780,13 @@ function getFeePoolEncoder() {
   );
 }
 function getFeePoolDecoder() {
-  return getStructDecoder54([
+  return getStructDecoder55([
     ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
     ["bump", getU8Decoder25()]
   ]);
 }
 function getFeePoolCodec() {
-  return combineCodec60(getFeePoolEncoder(), getFeePoolDecoder());
+  return combineCodec61(getFeePoolEncoder(), getFeePoolDecoder());
 }
 function decodeFeePool(encodedAccount) {
   return decodeAccount7(
@@ -2788,14 +2817,14 @@ async function fetchAllMaybeFeePool(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists8,
   assertAccountsExist as assertAccountsExist8,
-  combineCodec as combineCodec61,
+  combineCodec as combineCodec62,
   decodeAccount as decodeAccount8,
   fetchEncodedAccount as fetchEncodedAccount8,
   fetchEncodedAccounts as fetchEncodedAccounts8,
   fixDecoderSize as fixDecoderSize8,
   fixEncoderSize as fixEncoderSize8,
-  getAddressDecoder as getAddressDecoder31,
-  getAddressEncoder as getAddressEncoder31,
+  getAddressDecoder as getAddressDecoder32,
+  getAddressEncoder as getAddressEncoder32,
   getArrayDecoder as getArrayDecoder21,
   getArrayEncoder as getArrayEncoder21,
   getBooleanDecoder as getBooleanDecoder9,
@@ -2806,8 +2835,8 @@ import {
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder3,
   getOptionDecoder as getOptionDecoder5,
   getOptionEncoder as getOptionEncoder5,
-  getStructDecoder as getStructDecoder55,
-  getStructEncoder as getStructEncoder55,
+  getStructDecoder as getStructDecoder56,
+  getStructEncoder as getStructEncoder56,
   getTupleDecoder as getTupleDecoder5,
   getTupleEncoder as getTupleEncoder5,
   getU32Decoder as getU32Decoder6,
@@ -2835,25 +2864,25 @@ function getMXEAccountDiscriminatorBytes() {
 }
 function getMXEAccountEncoder() {
   return transformEncoder8(
-    getStructEncoder55([
+    getStructEncoder56([
       ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
       ["cluster", getOptionEncoder5(getU32Encoder6())],
       ["keygenOffset", getU64Encoder23()],
       ["keyRecoveryInitOffset", getU64Encoder23()],
-      ["mxeProgramId", getAddressEncoder31()],
-      ["authority", getOptionEncoder5(getAddressEncoder31())],
+      ["mxeProgramId", getAddressEncoder32()],
+      ["authority", getOptionEncoder5(getAddressEncoder32())],
       [
         "utilityPubkeys",
         getDiscriminatedUnionEncoder3([
           [
             "Set",
-            getStructEncoder55([
+            getStructEncoder56([
               ["fields", getTupleEncoder5([getUtilityPubkeysEncoder()])]
             ])
           ],
           [
             "Unset",
-            getStructEncoder55([
+            getStructEncoder56([
               [
                 "fields",
                 getTupleEncoder5([
@@ -2874,25 +2903,25 @@ function getMXEAccountEncoder() {
   );
 }
 function getMXEAccountDecoder() {
-  return getStructDecoder55([
+  return getStructDecoder56([
     ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
     ["cluster", getOptionDecoder5(getU32Decoder6())],
     ["keygenOffset", getU64Decoder23()],
     ["keyRecoveryInitOffset", getU64Decoder23()],
-    ["mxeProgramId", getAddressDecoder31()],
-    ["authority", getOptionDecoder5(getAddressDecoder31())],
+    ["mxeProgramId", getAddressDecoder32()],
+    ["authority", getOptionDecoder5(getAddressDecoder32())],
     [
       "utilityPubkeys",
       getDiscriminatedUnionDecoder3([
         [
           "Set",
-          getStructDecoder55([
+          getStructDecoder56([
             ["fields", getTupleDecoder5([getUtilityPubkeysDecoder()])]
           ])
         ],
         [
           "Unset",
-          getStructDecoder55([
+          getStructDecoder56([
             [
               "fields",
               getTupleDecoder5([
@@ -2911,7 +2940,7 @@ function getMXEAccountDecoder() {
   ]);
 }
 function getMXEAccountCodec() {
-  return combineCodec61(getMXEAccountEncoder(), getMXEAccountDecoder());
+  return combineCodec62(getMXEAccountEncoder(), getMXEAccountDecoder());
 }
 function decodeMXEAccount(encodedAccount) {
   return decodeAccount8(
@@ -2942,14 +2971,14 @@ async function fetchAllMaybeMXEAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists9,
   assertAccountsExist as assertAccountsExist9,
-  combineCodec as combineCodec62,
+  combineCodec as combineCodec63,
   decodeAccount as decodeAccount9,
   fetchEncodedAccount as fetchEncodedAccount9,
   fetchEncodedAccounts as fetchEncodedAccounts9,
   fixDecoderSize as fixDecoderSize9,
   fixEncoderSize as fixEncoderSize9,
-  getAddressDecoder as getAddressDecoder32,
-  getAddressEncoder as getAddressEncoder32,
+  getAddressDecoder as getAddressDecoder33,
+  getAddressEncoder as getAddressEncoder33,
   getArrayDecoder as getArrayDecoder22,
   getArrayEncoder as getArrayEncoder22,
   getBooleanDecoder as getBooleanDecoder10,
@@ -2958,8 +2987,8 @@ import {
   getBytesEncoder as getBytesEncoder9,
   getOptionDecoder as getOptionDecoder6,
   getOptionEncoder as getOptionEncoder6,
-  getStructDecoder as getStructDecoder56,
-  getStructEncoder as getStructEncoder56,
+  getStructDecoder as getStructDecoder57,
+  getStructEncoder as getStructEncoder57,
   getU16Decoder as getU16Decoder9,
   getU16Encoder as getU16Encoder9,
   getU64Decoder as getU64Decoder24,
@@ -2985,10 +3014,10 @@ function getOpportunityMarketDiscriminatorBytes() {
 }
 function getOpportunityMarketEncoder() {
   return transformEncoder9(
-    getStructEncoder56([
+    getStructEncoder57([
       ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
       ["bump", getU8Encoder27()],
-      ["creator", getAddressEncoder32()],
+      ["creator", getAddressEncoder33()],
       ["index", getU64Encoder24()],
       ["totalOptions", getU16Encoder9()],
       ["openTimestamp", getOptionEncoder6(getU64Encoder24())],
@@ -2999,8 +3028,8 @@ function getOpportunityMarketEncoder() {
         getOptionEncoder6(getArrayEncoder22(getWinningOptionEncoder()))
       ],
       ["rewardAmount", getU64Encoder24()],
-      ["marketAuthority", getOptionEncoder6(getAddressEncoder32())],
-      ["mint", getAddressEncoder32()],
+      ["marketAuthority", getOptionEncoder6(getAddressEncoder33())],
+      ["mint", getAddressEncoder33()],
       ["earlinessCutoffSeconds", getU64Encoder24()],
       ["unstakeDelaySeconds", getU64Encoder24()],
       ["authorizedReaderPubkey", getArrayEncoder22(getU8Encoder27(), { size: 32 })],
@@ -3010,10 +3039,10 @@ function getOpportunityMarketEncoder() {
   );
 }
 function getOpportunityMarketDecoder() {
-  return getStructDecoder56([
+  return getStructDecoder57([
     ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
     ["bump", getU8Decoder27()],
-    ["creator", getAddressDecoder32()],
+    ["creator", getAddressDecoder33()],
     ["index", getU64Decoder24()],
     ["totalOptions", getU16Decoder9()],
     ["openTimestamp", getOptionDecoder6(getU64Decoder24())],
@@ -3024,8 +3053,8 @@ function getOpportunityMarketDecoder() {
       getOptionDecoder6(getArrayDecoder22(getWinningOptionDecoder()))
     ],
     ["rewardAmount", getU64Decoder24()],
-    ["marketAuthority", getOptionDecoder6(getAddressDecoder32())],
-    ["mint", getAddressDecoder32()],
+    ["marketAuthority", getOptionDecoder6(getAddressDecoder33())],
+    ["mint", getAddressDecoder33()],
     ["earlinessCutoffSeconds", getU64Decoder24()],
     ["unstakeDelaySeconds", getU64Decoder24()],
     ["authorizedReaderPubkey", getArrayDecoder22(getU8Decoder27(), { size: 32 })],
@@ -3033,7 +3062,7 @@ function getOpportunityMarketDecoder() {
   ]);
 }
 function getOpportunityMarketCodec() {
-  return combineCodec62(
+  return combineCodec63(
     getOpportunityMarketEncoder(),
     getOpportunityMarketDecoder()
   );
@@ -3075,22 +3104,22 @@ import {
   addEncoderSizePrefix as addEncoderSizePrefix3,
   assertAccountExists as assertAccountExists10,
   assertAccountsExist as assertAccountsExist10,
-  combineCodec as combineCodec63,
+  combineCodec as combineCodec64,
   decodeAccount as decodeAccount10,
   fetchEncodedAccount as fetchEncodedAccount10,
   fetchEncodedAccounts as fetchEncodedAccounts10,
   fixDecoderSize as fixDecoderSize10,
   fixEncoderSize as fixEncoderSize10,
-  getAddressDecoder as getAddressDecoder33,
-  getAddressEncoder as getAddressEncoder33,
+  getAddressDecoder as getAddressDecoder34,
+  getAddressEncoder as getAddressEncoder34,
   getBooleanDecoder as getBooleanDecoder11,
   getBooleanEncoder as getBooleanEncoder11,
   getBytesDecoder as getBytesDecoder10,
   getBytesEncoder as getBytesEncoder10,
   getOptionDecoder as getOptionDecoder7,
   getOptionEncoder as getOptionEncoder7,
-  getStructDecoder as getStructDecoder57,
-  getStructEncoder as getStructEncoder57,
+  getStructDecoder as getStructDecoder58,
+  getStructEncoder as getStructEncoder58,
   getU16Decoder as getU16Decoder10,
   getU16Encoder as getU16Encoder10,
   getU32Decoder as getU32Decoder7,
@@ -3120,10 +3149,10 @@ function getOpportunityMarketOptionDiscriminatorBytes() {
 }
 function getOpportunityMarketOptionEncoder() {
   return transformEncoder10(
-    getStructEncoder57([
+    getStructEncoder58([
       ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
       ["bump", getU8Encoder28()],
-      ["creator", getAddressEncoder33()],
+      ["creator", getAddressEncoder34()],
       ["index", getU16Encoder10()],
       ["name", addEncoderSizePrefix3(getUtf8Encoder3(), getU32Encoder7())],
       ["totalShares", getOptionEncoder7(getU64Encoder25())],
@@ -3137,10 +3166,10 @@ function getOpportunityMarketOptionEncoder() {
   );
 }
 function getOpportunityMarketOptionDecoder() {
-  return getStructDecoder57([
+  return getStructDecoder58([
     ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
     ["bump", getU8Decoder28()],
-    ["creator", getAddressDecoder33()],
+    ["creator", getAddressDecoder34()],
     ["index", getU16Decoder10()],
     ["name", addDecoderSizePrefix3(getUtf8Decoder3(), getU32Decoder7())],
     ["totalShares", getOptionDecoder7(getU64Decoder25())],
@@ -3149,7 +3178,7 @@ function getOpportunityMarketOptionDecoder() {
   ]);
 }
 function getOpportunityMarketOptionCodec() {
-  return combineCodec63(
+  return combineCodec64(
     getOpportunityMarketOptionEncoder(),
     getOpportunityMarketOptionDecoder()
   );
@@ -3193,14 +3222,14 @@ async function fetchAllMaybeOpportunityMarketOption(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists11,
   assertAccountsExist as assertAccountsExist11,
-  combineCodec as combineCodec64,
+  combineCodec as combineCodec65,
   decodeAccount as decodeAccount11,
   fetchEncodedAccount as fetchEncodedAccount11,
   fetchEncodedAccounts as fetchEncodedAccounts11,
   fixDecoderSize as fixDecoderSize11,
   fixEncoderSize as fixEncoderSize11,
-  getAddressDecoder as getAddressDecoder34,
-  getAddressEncoder as getAddressEncoder34,
+  getAddressDecoder as getAddressDecoder35,
+  getAddressEncoder as getAddressEncoder35,
   getArrayDecoder as getArrayDecoder23,
   getArrayEncoder as getArrayEncoder23,
   getBooleanDecoder as getBooleanDecoder12,
@@ -3209,8 +3238,8 @@ import {
   getBytesEncoder as getBytesEncoder11,
   getOptionDecoder as getOptionDecoder8,
   getOptionEncoder as getOptionEncoder8,
-  getStructDecoder as getStructDecoder58,
-  getStructEncoder as getStructEncoder58,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
   getU128Decoder as getU128Decoder13,
   getU128Encoder as getU128Encoder13,
   getU16Decoder as getU16Decoder11,
@@ -3238,7 +3267,7 @@ function getShareAccountDiscriminatorBytes() {
 }
 function getShareAccountEncoder() {
   return transformEncoder11(
-    getStructEncoder58([
+    getStructEncoder59([
       ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
       [
         "encryptedState",
@@ -3248,8 +3277,8 @@ function getShareAccountEncoder() {
       ],
       ["stateNonce", getU128Encoder13()],
       ["bump", getU8Encoder29()],
-      ["owner", getAddressEncoder34()],
-      ["market", getAddressEncoder34()],
+      ["owner", getAddressEncoder35()],
+      ["market", getAddressEncoder35()],
       [
         "encryptedStateDisclosure",
         getArrayEncoder23(getArrayEncoder23(getU8Encoder29(), { size: 32 }), {
@@ -3270,7 +3299,7 @@ function getShareAccountEncoder() {
   );
 }
 function getShareAccountDecoder() {
-  return getStructDecoder58([
+  return getStructDecoder59([
     ["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)],
     [
       "encryptedState",
@@ -3280,8 +3309,8 @@ function getShareAccountDecoder() {
     ],
     ["stateNonce", getU128Decoder13()],
     ["bump", getU8Decoder29()],
-    ["owner", getAddressDecoder34()],
-    ["market", getAddressDecoder34()],
+    ["owner", getAddressDecoder35()],
+    ["market", getAddressDecoder35()],
     [
       "encryptedStateDisclosure",
       getArrayDecoder23(getArrayDecoder23(getU8Decoder29(), { size: 32 }), {
@@ -3300,7 +3329,7 @@ function getShareAccountDecoder() {
   ]);
 }
 function getShareAccountCodec() {
-  return combineCodec64(getShareAccountEncoder(), getShareAccountDecoder());
+  return combineCodec65(getShareAccountEncoder(), getShareAccountDecoder());
 }
 function decodeShareAccount(encodedAccount) {
   return decodeAccount11(
@@ -3331,18 +3360,18 @@ async function fetchAllMaybeShareAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists12,
   assertAccountsExist as assertAccountsExist12,
-  combineCodec as combineCodec65,
+  combineCodec as combineCodec66,
   decodeAccount as decodeAccount12,
   fetchEncodedAccount as fetchEncodedAccount12,
   fetchEncodedAccounts as fetchEncodedAccounts12,
   fixDecoderSize as fixDecoderSize12,
   fixEncoderSize as fixEncoderSize12,
-  getAddressDecoder as getAddressDecoder35,
-  getAddressEncoder as getAddressEncoder35,
+  getAddressDecoder as getAddressDecoder36,
+  getAddressEncoder as getAddressEncoder36,
   getBytesDecoder as getBytesDecoder12,
   getBytesEncoder as getBytesEncoder12,
-  getStructDecoder as getStructDecoder59,
-  getStructEncoder as getStructEncoder59,
+  getStructDecoder as getStructDecoder60,
+  getStructEncoder as getStructEncoder60,
   getU16Decoder as getU16Decoder12,
   getU16Encoder as getU16Encoder12,
   getU64Decoder as getU64Decoder27,
@@ -3366,11 +3395,11 @@ function getTokenVaultDiscriminatorBytes() {
 }
 function getTokenVaultEncoder() {
   return transformEncoder12(
-    getStructEncoder59([
+    getStructEncoder60([
       ["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)],
       ["bump", getU8Encoder30()],
-      ["fundManager", getAddressEncoder35()],
-      ["mint", getAddressEncoder35()],
+      ["fundManager", getAddressEncoder36()],
+      ["mint", getAddressEncoder36()],
       ["collectedFees", getU64Encoder27()],
       ["protocolFeeBp", getU16Encoder12()]
     ]),
@@ -3378,17 +3407,17 @@ function getTokenVaultEncoder() {
   );
 }
 function getTokenVaultDecoder() {
-  return getStructDecoder59([
+  return getStructDecoder60([
     ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
     ["bump", getU8Decoder30()],
-    ["fundManager", getAddressDecoder35()],
-    ["mint", getAddressDecoder35()],
+    ["fundManager", getAddressDecoder36()],
+    ["mint", getAddressDecoder36()],
     ["collectedFees", getU64Decoder27()],
     ["protocolFeeBp", getU16Decoder12()]
   ]);
 }
 function getTokenVaultCodec() {
-  return combineCodec65(getTokenVaultEncoder(), getTokenVaultDecoder());
+  return combineCodec66(getTokenVaultEncoder(), getTokenVaultDecoder());
 }
 function decodeTokenVault(encodedAccount) {
   return decodeAccount12(
@@ -4041,17 +4070,17 @@ function isOpportunityMarketError(error, transactionMessage, code) {
 import {
   addDecoderSizePrefix as addDecoderSizePrefix4,
   addEncoderSizePrefix as addEncoderSizePrefix4,
-  combineCodec as combineCodec66,
+  combineCodec as combineCodec67,
   fixDecoderSize as fixDecoderSize13,
   fixEncoderSize as fixEncoderSize14,
-  getAddressEncoder as getAddressEncoder36,
+  getAddressEncoder as getAddressEncoder37,
   getArrayDecoder as getArrayDecoder24,
   getArrayEncoder as getArrayEncoder24,
   getBytesDecoder as getBytesDecoder13,
   getBytesEncoder as getBytesEncoder14,
   getProgramDerivedAddress,
-  getStructDecoder as getStructDecoder60,
-  getStructEncoder as getStructEncoder60,
+  getStructDecoder as getStructDecoder61,
+  getStructEncoder as getStructEncoder61,
   getU128Decoder as getU128Decoder14,
   getU128Encoder as getU128Encoder14,
   getU16Decoder as getU16Decoder13,
@@ -4131,7 +4160,7 @@ function getAddMarketOptionDiscriminatorBytes() {
 }
 function getAddMarketOptionInstructionDataEncoder() {
   return transformEncoder13(
-    getStructEncoder60([
+    getStructEncoder61([
       ["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
       ["computationOffset", getU64Encoder28()],
       ["optionIndex", getU16Encoder13()],
@@ -4145,7 +4174,7 @@ function getAddMarketOptionInstructionDataEncoder() {
   );
 }
 function getAddMarketOptionInstructionDataDecoder() {
-  return getStructDecoder60([
+  return getStructDecoder61([
     ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
     ["computationOffset", getU64Decoder28()],
     ["optionIndex", getU16Decoder13()],
@@ -4157,7 +4186,7 @@ function getAddMarketOptionInstructionDataDecoder() {
   ]);
 }
 function getAddMarketOptionInstructionDataCodec() {
-  return combineCodec66(
+  return combineCodec67(
     getAddMarketOptionInstructionDataEncoder(),
     getAddMarketOptionInstructionDataDecoder()
   );
@@ -4219,7 +4248,7 @@ async function getAddMarketOptionInstructionAsync(input, config) {
         getBytesEncoder14().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder37().encode(expectAddress(accounts.market.value)),
         getU16Encoder13().encode(expectSome(args.optionIndex))
       ]
     });
@@ -4245,8 +4274,8 @@ async function getAddMarketOptionInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder36().encode(expectAddress(accounts.creator.value)),
-        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder37().encode(expectAddress(accounts.creator.value)),
+        getAddressEncoder37().encode(expectAddress(accounts.market.value)),
         getU32Encoder8().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -4424,15 +4453,15 @@ function parseAddMarketOptionInstruction(instruction) {
 import {
   addDecoderSizePrefix as addDecoderSizePrefix5,
   addEncoderSizePrefix as addEncoderSizePrefix5,
-  combineCodec as combineCodec67,
+  combineCodec as combineCodec68,
   fixDecoderSize as fixDecoderSize14,
   fixEncoderSize as fixEncoderSize15,
-  getAddressEncoder as getAddressEncoder37,
+  getAddressEncoder as getAddressEncoder38,
   getBytesDecoder as getBytesDecoder14,
   getBytesEncoder as getBytesEncoder15,
   getProgramDerivedAddress as getProgramDerivedAddress2,
-  getStructDecoder as getStructDecoder61,
-  getStructEncoder as getStructEncoder61,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
   getU16Decoder as getU16Decoder14,
   getU16Encoder as getU16Encoder14,
   getU32Decoder as getU32Decoder9,
@@ -4458,7 +4487,7 @@ function getAddMarketOptionAsCreatorDiscriminatorBytes() {
 }
 function getAddMarketOptionAsCreatorInstructionDataEncoder() {
   return transformEncoder14(
-    getStructEncoder61([
+    getStructEncoder62([
       ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
       ["optionIndex", getU16Encoder14()],
       ["name", addEncoderSizePrefix5(getUtf8Encoder5(), getU32Encoder9())]
@@ -4470,14 +4499,14 @@ function getAddMarketOptionAsCreatorInstructionDataEncoder() {
   );
 }
 function getAddMarketOptionAsCreatorInstructionDataDecoder() {
-  return getStructDecoder61([
+  return getStructDecoder62([
     ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
     ["optionIndex", getU16Decoder14()],
     ["name", addDecoderSizePrefix5(getUtf8Decoder5(), getU32Decoder9())]
   ]);
 }
 function getAddMarketOptionAsCreatorInstructionDataCodec() {
-  return combineCodec67(
+  return combineCodec68(
     getAddMarketOptionAsCreatorInstructionDataEncoder(),
     getAddMarketOptionAsCreatorInstructionDataDecoder()
   );
@@ -4499,7 +4528,7 @@ async function getAddMarketOptionAsCreatorInstructionAsync(input, config) {
         getBytesEncoder15().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder37().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
         getU16Encoder14().encode(expectSome(args.optionIndex))
       ]
     });
@@ -4574,7 +4603,7 @@ function parseAddMarketOptionAsCreatorInstruction(instruction) {
 
 // src/generated/instructions/addOptionStakeCallback.ts
 import {
-  combineCodec as combineCodec68,
+  combineCodec as combineCodec69,
   fixDecoderSize as fixDecoderSize15,
   fixEncoderSize as fixEncoderSize16,
   getArrayDecoder as getArrayDecoder25,
@@ -4583,8 +4612,8 @@ import {
   getBytesEncoder as getBytesEncoder16,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder4,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder4,
-  getStructDecoder as getStructDecoder62,
-  getStructEncoder as getStructEncoder62,
+  getStructDecoder as getStructDecoder63,
+  getStructEncoder as getStructEncoder63,
   getTupleDecoder as getTupleDecoder6,
   getTupleEncoder as getTupleEncoder6,
   getU8Decoder as getU8Decoder32,
@@ -4610,14 +4639,14 @@ function getAddOptionStakeCallbackDiscriminatorBytes() {
 }
 function getAddOptionStakeCallbackInstructionDataEncoder() {
   return transformEncoder15(
-    getStructEncoder62([
+    getStructEncoder63([
       ["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder4([
           [
             "Success",
-            getStructEncoder62([
+            getStructEncoder63([
               [
                 "fields",
                 getTupleEncoder6([
@@ -4630,7 +4659,7 @@ function getAddOptionStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder62([
+            getStructEncoder63([
               ["fields", getTupleEncoder6([getAddOptionStakeOutputEncoder()])]
             ])
           ]
@@ -4644,14 +4673,14 @@ function getAddOptionStakeCallbackInstructionDataEncoder() {
   );
 }
 function getAddOptionStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder62([
+  return getStructDecoder63([
     ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder4([
         [
           "Success",
-          getStructDecoder62([
+          getStructDecoder63([
             [
               "fields",
               getTupleDecoder6([
@@ -4664,7 +4693,7 @@ function getAddOptionStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder62([
+          getStructDecoder63([
             ["fields", getTupleDecoder6([getAddOptionStakeOutputDecoder()])]
           ])
         ]
@@ -4673,7 +4702,7 @@ function getAddOptionStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getAddOptionStakeCallbackInstructionDataCodec() {
-  return combineCodec68(
+  return combineCodec69(
     getAddOptionStakeCallbackInstructionDataEncoder(),
     getAddOptionStakeCallbackInstructionDataDecoder()
   );
@@ -4755,13 +4784,13 @@ function parseAddOptionStakeCallbackInstruction(instruction) {
 
 // src/generated/instructions/addOptionStakeCompDef.ts
 import {
-  combineCodec as combineCodec69,
+  combineCodec as combineCodec70,
   fixDecoderSize as fixDecoderSize16,
   fixEncoderSize as fixEncoderSize17,
   getBytesDecoder as getBytesDecoder16,
   getBytesEncoder as getBytesEncoder17,
-  getStructDecoder as getStructDecoder63,
-  getStructEncoder as getStructEncoder63,
+  getStructDecoder as getStructDecoder64,
+  getStructEncoder as getStructEncoder64,
   transformEncoder as transformEncoder16
 } from "@solana/kit";
 var ADD_OPTION_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -4781,7 +4810,7 @@ function getAddOptionStakeCompDefDiscriminatorBytes() {
 }
 function getAddOptionStakeCompDefInstructionDataEncoder() {
   return transformEncoder16(
-    getStructEncoder63([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
+    getStructEncoder64([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
     (value) => ({
       ...value,
       discriminator: ADD_OPTION_STAKE_COMP_DEF_DISCRIMINATOR
@@ -4789,12 +4818,12 @@ function getAddOptionStakeCompDefInstructionDataEncoder() {
   );
 }
 function getAddOptionStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder63([
+  return getStructDecoder64([
     ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)]
   ]);
 }
 function getAddOptionStakeCompDefInstructionDataCodec() {
-  return combineCodec69(
+  return combineCodec70(
     getAddOptionStakeCompDefInstructionDataEncoder(),
     getAddOptionStakeCompDefInstructionDataDecoder()
   );
@@ -4867,7 +4896,7 @@ function parseAddOptionStakeCompDefInstruction(instruction) {
 
 // src/generated/instructions/buyOpportunityMarketSharesCallback.ts
 import {
-  combineCodec as combineCodec70,
+  combineCodec as combineCodec71,
   fixDecoderSize as fixDecoderSize17,
   fixEncoderSize as fixEncoderSize18,
   getArrayDecoder as getArrayDecoder26,
@@ -4876,8 +4905,8 @@ import {
   getBytesEncoder as getBytesEncoder18,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder5,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder5,
-  getStructDecoder as getStructDecoder64,
-  getStructEncoder as getStructEncoder64,
+  getStructDecoder as getStructDecoder65,
+  getStructEncoder as getStructEncoder65,
   getTupleDecoder as getTupleDecoder7,
   getTupleEncoder as getTupleEncoder7,
   getU8Decoder as getU8Decoder33,
@@ -4894,14 +4923,14 @@ function getBuyOpportunityMarketSharesCallbackDiscriminatorBytes() {
 }
 function getBuyOpportunityMarketSharesCallbackInstructionDataEncoder() {
   return transformEncoder17(
-    getStructEncoder64([
+    getStructEncoder65([
       ["discriminator", fixEncoderSize18(getBytesEncoder18(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder5([
           [
             "Success",
-            getStructEncoder64([
+            getStructEncoder65([
               [
                 "fields",
                 getTupleEncoder7([
@@ -4914,7 +4943,7 @@ function getBuyOpportunityMarketSharesCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder2()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder64([
+            getStructEncoder65([
               [
                 "fields",
                 getTupleEncoder7([getBuyOpportunityMarketSharesOutputEncoder()])
@@ -4931,14 +4960,14 @@ function getBuyOpportunityMarketSharesCallbackInstructionDataEncoder() {
   );
 }
 function getBuyOpportunityMarketSharesCallbackInstructionDataDecoder() {
-  return getStructDecoder64([
+  return getStructDecoder65([
     ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder5([
         [
           "Success",
-          getStructDecoder64([
+          getStructDecoder65([
             [
               "fields",
               getTupleDecoder7([
@@ -4951,7 +4980,7 @@ function getBuyOpportunityMarketSharesCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder2()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder64([
+          getStructDecoder65([
             [
               "fields",
               getTupleDecoder7([getBuyOpportunityMarketSharesOutputDecoder()])
@@ -4963,7 +4992,7 @@ function getBuyOpportunityMarketSharesCallbackInstructionDataDecoder() {
   ]);
 }
 function getBuyOpportunityMarketSharesCallbackInstructionDataCodec() {
-  return combineCodec70(
+  return combineCodec71(
     getBuyOpportunityMarketSharesCallbackInstructionDataEncoder(),
     getBuyOpportunityMarketSharesCallbackInstructionDataDecoder()
   );
@@ -5045,13 +5074,13 @@ function parseBuyOpportunityMarketSharesCallbackInstruction(instruction) {
 
 // src/generated/instructions/buyOpportunityMarketSharesCompDef.ts
 import {
-  combineCodec as combineCodec71,
+  combineCodec as combineCodec72,
   fixDecoderSize as fixDecoderSize18,
   fixEncoderSize as fixEncoderSize19,
   getBytesDecoder as getBytesDecoder18,
   getBytesEncoder as getBytesEncoder19,
-  getStructDecoder as getStructDecoder65,
-  getStructEncoder as getStructEncoder65,
+  getStructDecoder as getStructDecoder66,
+  getStructEncoder as getStructEncoder66,
   transformEncoder as transformEncoder18
 } from "@solana/kit";
 var BUY_OPPORTUNITY_MARKET_SHARES_COMP_DEF_DISCRIMINATOR = new Uint8Array([111, 144, 68, 110, 33, 204, 64, 235]);
@@ -5062,7 +5091,7 @@ function getBuyOpportunityMarketSharesCompDefDiscriminatorBytes() {
 }
 function getBuyOpportunityMarketSharesCompDefInstructionDataEncoder() {
   return transformEncoder18(
-    getStructEncoder65([["discriminator", fixEncoderSize19(getBytesEncoder19(), 8)]]),
+    getStructEncoder66([["discriminator", fixEncoderSize19(getBytesEncoder19(), 8)]]),
     (value) => ({
       ...value,
       discriminator: BUY_OPPORTUNITY_MARKET_SHARES_COMP_DEF_DISCRIMINATOR
@@ -5070,12 +5099,12 @@ function getBuyOpportunityMarketSharesCompDefInstructionDataEncoder() {
   );
 }
 function getBuyOpportunityMarketSharesCompDefInstructionDataDecoder() {
-  return getStructDecoder65([
+  return getStructDecoder66([
     ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)]
   ]);
 }
 function getBuyOpportunityMarketSharesCompDefInstructionDataCodec() {
-  return combineCodec71(
+  return combineCodec72(
     getBuyOpportunityMarketSharesCompDefInstructionDataEncoder(),
     getBuyOpportunityMarketSharesCompDefInstructionDataDecoder()
   );
@@ -5150,15 +5179,15 @@ function parseBuyOpportunityMarketSharesCompDefInstruction(instruction) {
 
 // src/generated/instructions/claimFees.ts
 import {
-  combineCodec as combineCodec72,
+  combineCodec as combineCodec73,
   fixDecoderSize as fixDecoderSize19,
   fixEncoderSize as fixEncoderSize20,
-  getAddressEncoder as getAddressEncoder38,
+  getAddressEncoder as getAddressEncoder39,
   getBytesDecoder as getBytesDecoder19,
   getBytesEncoder as getBytesEncoder20,
   getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder66,
-  getStructEncoder as getStructEncoder66,
+  getStructDecoder as getStructDecoder67,
+  getStructEncoder as getStructEncoder67,
   transformEncoder as transformEncoder19
 } from "@solana/kit";
 var CLAIM_FEES_DISCRIMINATOR = new Uint8Array([
@@ -5176,17 +5205,17 @@ function getClaimFeesDiscriminatorBytes() {
 }
 function getClaimFeesInstructionDataEncoder() {
   return transformEncoder19(
-    getStructEncoder66([["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)]]),
+    getStructEncoder67([["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_FEES_DISCRIMINATOR })
   );
 }
 function getClaimFeesInstructionDataDecoder() {
-  return getStructDecoder66([
+  return getStructDecoder67([
     ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)]
   ]);
 }
 function getClaimFeesInstructionDataCodec() {
-  return combineCodec72(
+  return combineCodec73(
     getClaimFeesInstructionDataEncoder(),
     getClaimFeesInstructionDataDecoder()
   );
@@ -5237,7 +5266,7 @@ async function getClaimFeesInstructionAsync(input, config) {
         getBytesEncoder20().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder38().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder39().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5245,9 +5274,9 @@ async function getClaimFeesInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress3({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder38().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder39().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder39().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder39().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5323,15 +5352,15 @@ function parseClaimFeesInstruction(instruction) {
 
 // src/generated/instructions/claimPendingDeposit.ts
 import {
-  combineCodec as combineCodec73,
+  combineCodec as combineCodec74,
   fixDecoderSize as fixDecoderSize20,
   fixEncoderSize as fixEncoderSize21,
-  getAddressEncoder as getAddressEncoder39,
+  getAddressEncoder as getAddressEncoder40,
   getBytesDecoder as getBytesDecoder20,
   getBytesEncoder as getBytesEncoder21,
   getProgramDerivedAddress as getProgramDerivedAddress4,
-  getStructDecoder as getStructDecoder67,
-  getStructEncoder as getStructEncoder67,
+  getStructDecoder as getStructDecoder68,
+  getStructEncoder as getStructEncoder68,
   transformEncoder as transformEncoder20
 } from "@solana/kit";
 var CLAIM_PENDING_DEPOSIT_DISCRIMINATOR = new Uint8Array([
@@ -5351,7 +5380,7 @@ function getClaimPendingDepositDiscriminatorBytes() {
 }
 function getClaimPendingDepositInstructionDataEncoder() {
   return transformEncoder20(
-    getStructEncoder67([["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)]]),
+    getStructEncoder68([["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)]]),
     (value) => ({
       ...value,
       discriminator: CLAIM_PENDING_DEPOSIT_DISCRIMINATOR
@@ -5359,12 +5388,12 @@ function getClaimPendingDepositInstructionDataEncoder() {
   );
 }
 function getClaimPendingDepositInstructionDataDecoder() {
-  return getStructDecoder67([
+  return getStructDecoder68([
     ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)]
   ]);
 }
 function getClaimPendingDepositInstructionDataCodec() {
-  return combineCodec73(
+  return combineCodec74(
     getClaimPendingDepositInstructionDataEncoder(),
     getClaimPendingDepositInstructionDataDecoder()
   );
@@ -5394,7 +5423,7 @@ async function getClaimPendingDepositInstructionAsync(input, config) {
         getBytesEncoder21().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder39().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5402,9 +5431,9 @@ async function getClaimPendingDepositInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress4({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder39().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder39().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder39().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder40().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5485,15 +5514,15 @@ function parseClaimPendingDepositInstruction(instruction) {
 
 // src/generated/instructions/closeEphemeralEncryptedTokenAccount.ts
 import {
-  combineCodec as combineCodec74,
+  combineCodec as combineCodec75,
   fixDecoderSize as fixDecoderSize21,
   fixEncoderSize as fixEncoderSize22,
-  getAddressEncoder as getAddressEncoder40,
+  getAddressEncoder as getAddressEncoder41,
   getBytesDecoder as getBytesDecoder21,
   getBytesEncoder as getBytesEncoder22,
   getProgramDerivedAddress as getProgramDerivedAddress5,
-  getStructDecoder as getStructDecoder68,
-  getStructEncoder as getStructEncoder68,
+  getStructDecoder as getStructDecoder69,
+  getStructEncoder as getStructEncoder69,
   getU64Decoder as getU64Decoder29,
   getU64Encoder as getU64Encoder29,
   transformEncoder as transformEncoder21
@@ -5506,7 +5535,7 @@ function getCloseEphemeralEncryptedTokenAccountDiscriminatorBytes() {
 }
 function getCloseEphemeralEncryptedTokenAccountInstructionDataEncoder() {
   return transformEncoder21(
-    getStructEncoder68([
+    getStructEncoder69([
       ["discriminator", fixEncoderSize22(getBytesEncoder22(), 8)],
       ["computationOffset", getU64Encoder29()],
       ["index", getU64Encoder29()]
@@ -5518,14 +5547,14 @@ function getCloseEphemeralEncryptedTokenAccountInstructionDataEncoder() {
   );
 }
 function getCloseEphemeralEncryptedTokenAccountInstructionDataDecoder() {
-  return getStructDecoder68([
+  return getStructDecoder69([
     ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)],
     ["computationOffset", getU64Decoder29()],
     ["index", getU64Decoder29()]
   ]);
 }
 function getCloseEphemeralEncryptedTokenAccountInstructionDataCodec() {
-  return combineCodec74(
+  return combineCodec75(
     getCloseEphemeralEncryptedTokenAccountInstructionDataEncoder(),
     getCloseEphemeralEncryptedTokenAccountInstructionDataDecoder()
   );
@@ -5593,8 +5622,8 @@ async function getCloseEphemeralEncryptedTokenAccountInstructionAsync(input, con
             116
           ])
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.tokenMint.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.signer.value)),
         getBytesEncoder22().encode(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
       ]
     });
@@ -5630,8 +5659,8 @@ async function getCloseEphemeralEncryptedTokenAccountInstructionAsync(input, con
             116
           ])
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.tokenMint.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.signer.value)),
         getU64Encoder29().encode(expectSome(args.index))
       ]
     });
@@ -5815,7 +5844,7 @@ function parseCloseEphemeralEncryptedTokenAccountInstruction(instruction) {
 
 // src/generated/instructions/closeEphemeralEncryptedTokenAccountCallback.ts
 import {
-  combineCodec as combineCodec75,
+  combineCodec as combineCodec76,
   fixDecoderSize as fixDecoderSize22,
   fixEncoderSize as fixEncoderSize23,
   getArrayDecoder as getArrayDecoder27,
@@ -5824,8 +5853,8 @@ import {
   getBytesEncoder as getBytesEncoder23,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder6,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder6,
-  getStructDecoder as getStructDecoder69,
-  getStructEncoder as getStructEncoder69,
+  getStructDecoder as getStructDecoder70,
+  getStructEncoder as getStructEncoder70,
   getTupleDecoder as getTupleDecoder8,
   getTupleEncoder as getTupleEncoder8,
   getU8Decoder as getU8Decoder34,
@@ -5842,14 +5871,14 @@ function getCloseEphemeralEncryptedTokenAccountCallbackDiscriminatorBytes() {
 }
 function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataEncoder() {
   return transformEncoder22(
-    getStructEncoder69([
+    getStructEncoder70([
       ["discriminator", fixEncoderSize23(getBytesEncoder23(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder6([
           [
             "Success",
-            getStructEncoder69([
+            getStructEncoder70([
               [
                 "fields",
                 getTupleEncoder8([
@@ -5862,7 +5891,7 @@ function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataEncoder()
           ["Failure", getUnitEncoder3()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder69([
+            getStructEncoder70([
               [
                 "fields",
                 getTupleEncoder8([
@@ -5881,14 +5910,14 @@ function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataEncoder()
   );
 }
 function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataDecoder() {
-  return getStructDecoder69([
+  return getStructDecoder70([
     ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder6([
         [
           "Success",
-          getStructDecoder69([
+          getStructDecoder70([
             [
               "fields",
               getTupleDecoder8([
@@ -5901,7 +5930,7 @@ function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataDecoder()
         ["Failure", getUnitDecoder3()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder69([
+          getStructDecoder70([
             [
               "fields",
               getTupleDecoder8([
@@ -5915,7 +5944,7 @@ function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataDecoder()
   ]);
 }
 function getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataCodec() {
-  return combineCodec75(
+  return combineCodec76(
     getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataEncoder(),
     getCloseEphemeralEncryptedTokenAccountCallbackInstructionDataDecoder()
   );
@@ -6003,13 +6032,13 @@ function parseCloseEphemeralEncryptedTokenAccountCallbackInstruction(instruction
 
 // src/generated/instructions/closeEphemeralEncryptedTokenAccountCompDef.ts
 import {
-  combineCodec as combineCodec76,
+  combineCodec as combineCodec77,
   fixDecoderSize as fixDecoderSize23,
   fixEncoderSize as fixEncoderSize24,
   getBytesDecoder as getBytesDecoder23,
   getBytesEncoder as getBytesEncoder24,
-  getStructDecoder as getStructDecoder70,
-  getStructEncoder as getStructEncoder70,
+  getStructDecoder as getStructDecoder71,
+  getStructEncoder as getStructEncoder71,
   transformEncoder as transformEncoder23
 } from "@solana/kit";
 var CLOSE_EPHEMERAL_ENCRYPTED_TOKEN_ACCOUNT_COMP_DEF_DISCRIMINATOR = new Uint8Array([162, 99, 122, 48, 158, 203, 176, 243]);
@@ -6020,7 +6049,7 @@ function getCloseEphemeralEncryptedTokenAccountCompDefDiscriminatorBytes() {
 }
 function getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataEncoder() {
   return transformEncoder23(
-    getStructEncoder70([["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)]]),
+    getStructEncoder71([["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)]]),
     (value) => ({
       ...value,
       discriminator: CLOSE_EPHEMERAL_ENCRYPTED_TOKEN_ACCOUNT_COMP_DEF_DISCRIMINATOR
@@ -6028,12 +6057,12 @@ function getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataEncoder() {
   );
 }
 function getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataDecoder() {
-  return getStructDecoder70([
+  return getStructDecoder71([
     ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)]
   ]);
 }
 function getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataCodec() {
-  return combineCodec76(
+  return combineCodec77(
     getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataEncoder(),
     getCloseEphemeralEncryptedTokenAccountCompDefInstructionDataDecoder()
   );
@@ -6108,15 +6137,15 @@ function parseCloseEphemeralEncryptedTokenAccountCompDefInstruction(instruction)
 
 // src/generated/instructions/closeShareAccount.ts
 import {
-  combineCodec as combineCodec77,
+  combineCodec as combineCodec78,
   fixDecoderSize as fixDecoderSize24,
   fixEncoderSize as fixEncoderSize25,
-  getAddressEncoder as getAddressEncoder41,
+  getAddressEncoder as getAddressEncoder42,
   getBytesDecoder as getBytesDecoder24,
   getBytesEncoder as getBytesEncoder25,
   getProgramDerivedAddress as getProgramDerivedAddress6,
-  getStructDecoder as getStructDecoder71,
-  getStructEncoder as getStructEncoder71,
+  getStructDecoder as getStructDecoder72,
+  getStructEncoder as getStructEncoder72,
   getU16Decoder as getU16Decoder15,
   getU16Encoder as getU16Encoder15,
   getU32Decoder as getU32Decoder10,
@@ -6140,7 +6169,7 @@ function getCloseShareAccountDiscriminatorBytes() {
 }
 function getCloseShareAccountInstructionDataEncoder() {
   return transformEncoder24(
-    getStructEncoder71([
+    getStructEncoder72([
       ["discriminator", fixEncoderSize25(getBytesEncoder25(), 8)],
       ["optionIndex", getU16Encoder15()],
       ["shareAccountId", getU32Encoder10()]
@@ -6149,14 +6178,14 @@ function getCloseShareAccountInstructionDataEncoder() {
   );
 }
 function getCloseShareAccountInstructionDataDecoder() {
-  return getStructDecoder71([
+  return getStructDecoder72([
     ["discriminator", fixDecoderSize24(getBytesDecoder24(), 8)],
     ["optionIndex", getU16Decoder15()],
     ["shareAccountId", getU32Decoder10()]
   ]);
 }
 function getCloseShareAccountInstructionDataCodec() {
-  return combineCodec77(
+  return combineCodec78(
     getCloseShareAccountInstructionDataEncoder(),
     getCloseShareAccountInstructionDataDecoder()
   );
@@ -6200,8 +6229,8 @@ async function getCloseShareAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder41().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
         getU32Encoder10().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -6213,7 +6242,7 @@ async function getCloseShareAccountInstructionAsync(input, config) {
         getBytesEncoder25().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
         getU16Encoder15().encode(expectSome(args.optionIndex))
       ]
     });
@@ -6222,9 +6251,9 @@ async function getCloseShareAccountInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress6({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder41().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder41().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6319,11 +6348,11 @@ function parseCloseShareAccountInstruction(instruction) {
 
 // src/generated/instructions/createMarket.ts
 import {
-  combineCodec as combineCodec78,
+  combineCodec as combineCodec79,
   fixDecoderSize as fixDecoderSize25,
   fixEncoderSize as fixEncoderSize26,
-  getAddressDecoder as getAddressDecoder36,
-  getAddressEncoder as getAddressEncoder42,
+  getAddressDecoder as getAddressDecoder37,
+  getAddressEncoder as getAddressEncoder43,
   getArrayDecoder as getArrayDecoder28,
   getArrayEncoder as getArrayEncoder28,
   getBooleanDecoder as getBooleanDecoder13,
@@ -6333,8 +6362,8 @@ import {
   getOptionDecoder as getOptionDecoder9,
   getOptionEncoder as getOptionEncoder9,
   getProgramDerivedAddress as getProgramDerivedAddress7,
-  getStructDecoder as getStructDecoder72,
-  getStructEncoder as getStructEncoder72,
+  getStructDecoder as getStructDecoder73,
+  getStructEncoder as getStructEncoder73,
   getU64Decoder as getU64Decoder30,
   getU64Encoder as getU64Encoder30,
   getU8Decoder as getU8Decoder35,
@@ -6358,13 +6387,13 @@ function getCreateMarketDiscriminatorBytes() {
 }
 function getCreateMarketInstructionDataEncoder() {
   return transformEncoder25(
-    getStructEncoder72([
+    getStructEncoder73([
       ["discriminator", fixEncoderSize26(getBytesEncoder26(), 8)],
       ["marketIndex", getU64Encoder30()],
       ["rewardAmount", getU64Encoder30()],
       ["timeToStake", getU64Encoder30()],
       ["timeToReveal", getU64Encoder30()],
-      ["marketAuthority", getOptionEncoder9(getAddressEncoder42())],
+      ["marketAuthority", getOptionEncoder9(getAddressEncoder43())],
       ["unstakeDelaySeconds", getU64Encoder30()],
       ["authorizedReaderPubkey", getArrayEncoder28(getU8Encoder35(), { size: 32 })],
       ["allowClosingEarly", getBooleanEncoder13()]
@@ -6373,20 +6402,20 @@ function getCreateMarketInstructionDataEncoder() {
   );
 }
 function getCreateMarketInstructionDataDecoder() {
-  return getStructDecoder72([
+  return getStructDecoder73([
     ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)],
     ["marketIndex", getU64Decoder30()],
     ["rewardAmount", getU64Decoder30()],
     ["timeToStake", getU64Decoder30()],
     ["timeToReveal", getU64Decoder30()],
-    ["marketAuthority", getOptionDecoder9(getAddressDecoder36())],
+    ["marketAuthority", getOptionDecoder9(getAddressDecoder37())],
     ["unstakeDelaySeconds", getU64Decoder30()],
     ["authorizedReaderPubkey", getArrayDecoder28(getU8Decoder35(), { size: 32 })],
     ["allowClosingEarly", getBooleanDecoder13()]
   ]);
 }
 function getCreateMarketInstructionDataCodec() {
-  return combineCodec78(
+  return combineCodec79(
     getCreateMarketInstructionDataEncoder(),
     getCreateMarketInstructionDataDecoder()
   );
@@ -6458,7 +6487,7 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder42().encode(expectAddress(accounts.creator.value)),
+        getAddressEncoder43().encode(expectAddress(accounts.creator.value)),
         getU64Encoder30().encode(expectSome(args.marketIndex))
       ]
     });
@@ -6467,9 +6496,9 @@ async function getCreateMarketInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress7({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder42().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder43().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder43().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder43().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6566,16 +6595,16 @@ function parseCreateMarketInstruction(instruction) {
 
 // src/generated/instructions/doUnstakeEarly.ts
 import {
-  combineCodec as combineCodec79,
+  combineCodec as combineCodec80,
   fixDecoderSize as fixDecoderSize26,
   fixEncoderSize as fixEncoderSize27,
-  getAddressDecoder as getAddressDecoder37,
-  getAddressEncoder as getAddressEncoder43,
+  getAddressDecoder as getAddressDecoder38,
+  getAddressEncoder as getAddressEncoder44,
   getBytesDecoder as getBytesDecoder26,
   getBytesEncoder as getBytesEncoder27,
   getProgramDerivedAddress as getProgramDerivedAddress8,
-  getStructDecoder as getStructDecoder73,
-  getStructEncoder as getStructEncoder73,
+  getStructDecoder as getStructDecoder74,
+  getStructEncoder as getStructEncoder74,
   getU32Decoder as getU32Decoder11,
   getU32Encoder as getU32Encoder11,
   getU64Decoder as getU64Decoder31,
@@ -6599,25 +6628,25 @@ function getDoUnstakeEarlyDiscriminatorBytes() {
 }
 function getDoUnstakeEarlyInstructionDataEncoder() {
   return transformEncoder26(
-    getStructEncoder73([
+    getStructEncoder74([
       ["discriminator", fixEncoderSize27(getBytesEncoder27(), 8)],
       ["computationOffset", getU64Encoder31()],
       ["shareAccountId", getU32Encoder11()],
-      ["shareAccountOwner", getAddressEncoder43()]
+      ["shareAccountOwner", getAddressEncoder44()]
     ]),
     (value) => ({ ...value, discriminator: DO_UNSTAKE_EARLY_DISCRIMINATOR })
   );
 }
 function getDoUnstakeEarlyInstructionDataDecoder() {
-  return getStructDecoder73([
+  return getStructDecoder74([
     ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)],
     ["computationOffset", getU64Decoder31()],
     ["shareAccountId", getU32Decoder11()],
-    ["shareAccountOwner", getAddressDecoder37()]
+    ["shareAccountOwner", getAddressDecoder38()]
   ]);
 }
 function getDoUnstakeEarlyInstructionDataCodec() {
-  return combineCodec79(
+  return combineCodec80(
     getDoUnstakeEarlyInstructionDataEncoder(),
     getDoUnstakeEarlyInstructionDataDecoder()
   );
@@ -6667,8 +6696,8 @@ async function getDoUnstakeEarlyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder43().encode(expectSome(args.shareAccountOwner)),
-        getAddressEncoder43().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder44().encode(expectSome(args.shareAccountOwner)),
+        getAddressEncoder44().encode(expectAddress(accounts.market.value)),
         getU32Encoder11().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -6836,13 +6865,13 @@ function parseDoUnstakeEarlyInstruction(instruction) {
 
 // src/generated/instructions/extendRevealPeriod.ts
 import {
-  combineCodec as combineCodec80,
+  combineCodec as combineCodec81,
   fixDecoderSize as fixDecoderSize27,
   fixEncoderSize as fixEncoderSize28,
   getBytesDecoder as getBytesDecoder27,
   getBytesEncoder as getBytesEncoder28,
-  getStructDecoder as getStructDecoder74,
-  getStructEncoder as getStructEncoder74,
+  getStructDecoder as getStructDecoder75,
+  getStructEncoder as getStructEncoder75,
   getU64Decoder as getU64Decoder32,
   getU64Encoder as getU64Encoder32,
   transformEncoder as transformEncoder27
@@ -6864,7 +6893,7 @@ function getExtendRevealPeriodDiscriminatorBytes() {
 }
 function getExtendRevealPeriodInstructionDataEncoder() {
   return transformEncoder27(
-    getStructEncoder74([
+    getStructEncoder75([
       ["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)],
       ["newTimeToReveal", getU64Encoder32()]
     ]),
@@ -6872,13 +6901,13 @@ function getExtendRevealPeriodInstructionDataEncoder() {
   );
 }
 function getExtendRevealPeriodInstructionDataDecoder() {
-  return getStructDecoder74([
+  return getStructDecoder75([
     ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)],
     ["newTimeToReveal", getU64Decoder32()]
   ]);
 }
 function getExtendRevealPeriodInstructionDataCodec() {
-  return combineCodec80(
+  return combineCodec81(
     getExtendRevealPeriodInstructionDataEncoder(),
     getExtendRevealPeriodInstructionDataDecoder()
   );
@@ -6924,15 +6953,15 @@ function parseExtendRevealPeriodInstruction(instruction) {
 
 // src/generated/instructions/increaseRewardPool.ts
 import {
-  combineCodec as combineCodec81,
+  combineCodec as combineCodec82,
   fixDecoderSize as fixDecoderSize28,
   fixEncoderSize as fixEncoderSize29,
-  getAddressEncoder as getAddressEncoder44,
+  getAddressEncoder as getAddressEncoder45,
   getBytesDecoder as getBytesDecoder28,
   getBytesEncoder as getBytesEncoder29,
   getProgramDerivedAddress as getProgramDerivedAddress9,
-  getStructDecoder as getStructDecoder75,
-  getStructEncoder as getStructEncoder75,
+  getStructDecoder as getStructDecoder76,
+  getStructEncoder as getStructEncoder76,
   getU64Decoder as getU64Decoder33,
   getU64Encoder as getU64Encoder33,
   transformEncoder as transformEncoder28
@@ -6954,7 +6983,7 @@ function getIncreaseRewardPoolDiscriminatorBytes() {
 }
 function getIncreaseRewardPoolInstructionDataEncoder() {
   return transformEncoder28(
-    getStructEncoder75([
+    getStructEncoder76([
       ["discriminator", fixEncoderSize29(getBytesEncoder29(), 8)],
       ["newRewardAmount", getU64Encoder33()]
     ]),
@@ -6962,13 +6991,13 @@ function getIncreaseRewardPoolInstructionDataEncoder() {
   );
 }
 function getIncreaseRewardPoolInstructionDataDecoder() {
-  return getStructDecoder75([
+  return getStructDecoder76([
     ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)],
     ["newRewardAmount", getU64Decoder33()]
   ]);
 }
 function getIncreaseRewardPoolInstructionDataCodec() {
-  return combineCodec81(
+  return combineCodec82(
     getIncreaseRewardPoolInstructionDataEncoder(),
     getIncreaseRewardPoolInstructionDataDecoder()
   );
@@ -6988,9 +7017,9 @@ async function getIncreaseRewardPoolInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress9({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder44().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder45().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder45().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder45().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7062,15 +7091,15 @@ function parseIncreaseRewardPoolInstruction(instruction) {
 
 // src/generated/instructions/incrementOptionTally.ts
 import {
-  combineCodec as combineCodec82,
+  combineCodec as combineCodec83,
   fixDecoderSize as fixDecoderSize29,
   fixEncoderSize as fixEncoderSize30,
-  getAddressEncoder as getAddressEncoder45,
+  getAddressEncoder as getAddressEncoder46,
   getBytesDecoder as getBytesDecoder29,
   getBytesEncoder as getBytesEncoder30,
   getProgramDerivedAddress as getProgramDerivedAddress10,
-  getStructDecoder as getStructDecoder76,
-  getStructEncoder as getStructEncoder76,
+  getStructDecoder as getStructDecoder77,
+  getStructEncoder as getStructEncoder77,
   getU16Decoder as getU16Decoder16,
   getU16Encoder as getU16Encoder16,
   getU32Decoder as getU32Decoder12,
@@ -7094,7 +7123,7 @@ function getIncrementOptionTallyDiscriminatorBytes() {
 }
 function getIncrementOptionTallyInstructionDataEncoder() {
   return transformEncoder29(
-    getStructEncoder76([
+    getStructEncoder77([
       ["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)],
       ["optionIndex", getU16Encoder16()],
       ["shareAccountId", getU32Encoder12()]
@@ -7106,14 +7135,14 @@ function getIncrementOptionTallyInstructionDataEncoder() {
   );
 }
 function getIncrementOptionTallyInstructionDataDecoder() {
-  return getStructDecoder76([
+  return getStructDecoder77([
     ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)],
     ["optionIndex", getU16Decoder16()],
     ["shareAccountId", getU32Decoder12()]
   ]);
 }
 function getIncrementOptionTallyInstructionDataCodec() {
-  return combineCodec82(
+  return combineCodec83(
     getIncrementOptionTallyInstructionDataEncoder(),
     getIncrementOptionTallyInstructionDataDecoder()
   );
@@ -7151,8 +7180,8 @@ async function getIncrementOptionTallyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder45().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder45().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.market.value)),
         getU32Encoder12().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -7164,7 +7193,7 @@ async function getIncrementOptionTallyInstructionAsync(input, config) {
         getBytesEncoder30().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder45().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.market.value)),
         getU16Encoder16().encode(expectSome(args.optionIndex))
       ]
     });
@@ -7247,16 +7276,16 @@ function parseIncrementOptionTallyInstruction(instruction) {
 
 // src/generated/instructions/initCentralState.ts
 import {
-  combineCodec as combineCodec83,
+  combineCodec as combineCodec84,
   fixDecoderSize as fixDecoderSize30,
   fixEncoderSize as fixEncoderSize31,
-  getAddressDecoder as getAddressDecoder38,
-  getAddressEncoder as getAddressEncoder46,
+  getAddressDecoder as getAddressDecoder39,
+  getAddressEncoder as getAddressEncoder47,
   getBytesDecoder as getBytesDecoder30,
   getBytesEncoder as getBytesEncoder31,
   getProgramDerivedAddress as getProgramDerivedAddress11,
-  getStructDecoder as getStructDecoder77,
-  getStructEncoder as getStructEncoder77,
+  getStructDecoder as getStructDecoder78,
+  getStructEncoder as getStructEncoder78,
   getU16Decoder as getU16Decoder17,
   getU16Encoder as getU16Encoder17,
   getU64Decoder as getU64Decoder34,
@@ -7280,27 +7309,27 @@ function getInitCentralStateDiscriminatorBytes() {
 }
 function getInitCentralStateInstructionDataEncoder() {
   return transformEncoder30(
-    getStructEncoder77([
+    getStructEncoder78([
       ["discriminator", fixEncoderSize31(getBytesEncoder31(), 8)],
       ["earlinessCutoffSeconds", getU64Encoder34()],
       ["minOptionDeposit", getU64Encoder34()],
       ["protocolFeeBp", getU16Encoder17()],
-      ["feeRecipient", getAddressEncoder46()]
+      ["feeRecipient", getAddressEncoder47()]
     ]),
     (value) => ({ ...value, discriminator: INIT_CENTRAL_STATE_DISCRIMINATOR })
   );
 }
 function getInitCentralStateInstructionDataDecoder() {
-  return getStructDecoder77([
+  return getStructDecoder78([
     ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)],
     ["earlinessCutoffSeconds", getU64Decoder34()],
     ["minOptionDeposit", getU64Decoder34()],
     ["protocolFeeBp", getU16Decoder17()],
-    ["feeRecipient", getAddressDecoder38()]
+    ["feeRecipient", getAddressDecoder39()]
   ]);
 }
 function getInitCentralStateInstructionDataCodec() {
-  return combineCodec83(
+  return combineCodec84(
     getInitCentralStateInstructionDataEncoder(),
     getInitCentralStateInstructionDataDecoder()
   );
@@ -7402,17 +7431,17 @@ function parseInitCentralStateInstruction(instruction) {
 
 // src/generated/instructions/initEncryptedTokenAccount.ts
 import {
-  combineCodec as combineCodec84,
+  combineCodec as combineCodec85,
   fixDecoderSize as fixDecoderSize31,
   fixEncoderSize as fixEncoderSize32,
-  getAddressEncoder as getAddressEncoder47,
+  getAddressEncoder as getAddressEncoder48,
   getArrayDecoder as getArrayDecoder29,
   getArrayEncoder as getArrayEncoder29,
   getBytesDecoder as getBytesDecoder31,
   getBytesEncoder as getBytesEncoder32,
   getProgramDerivedAddress as getProgramDerivedAddress12,
-  getStructDecoder as getStructDecoder78,
-  getStructEncoder as getStructEncoder78,
+  getStructDecoder as getStructDecoder79,
+  getStructEncoder as getStructEncoder79,
   getU128Decoder as getU128Decoder15,
   getU128Encoder as getU128Encoder15,
   getU8Decoder as getU8Decoder36,
@@ -7436,7 +7465,7 @@ function getInitEncryptedTokenAccountDiscriminatorBytes() {
 }
 function getInitEncryptedTokenAccountInstructionDataEncoder() {
   return transformEncoder31(
-    getStructEncoder78([
+    getStructEncoder79([
       ["discriminator", fixEncoderSize32(getBytesEncoder32(), 8)],
       ["userPubkey", getArrayEncoder29(getU8Encoder36(), { size: 32 })],
       ["stateNonce", getU128Encoder15()]
@@ -7448,14 +7477,14 @@ function getInitEncryptedTokenAccountInstructionDataEncoder() {
   );
 }
 function getInitEncryptedTokenAccountInstructionDataDecoder() {
-  return getStructDecoder78([
+  return getStructDecoder79([
     ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)],
     ["userPubkey", getArrayDecoder29(getU8Decoder36(), { size: 32 })],
     ["stateNonce", getU128Decoder15()]
   ]);
 }
 function getInitEncryptedTokenAccountInstructionDataCodec() {
-  return combineCodec84(
+  return combineCodec85(
     getInitEncryptedTokenAccountInstructionDataEncoder(),
     getInitEncryptedTokenAccountInstructionDataDecoder()
   );
@@ -7504,8 +7533,8 @@ async function getInitEncryptedTokenAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder47().encode(expectAddress(accounts.tokenMint.value)),
-        getAddressEncoder47().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder48().encode(expectAddress(accounts.tokenMint.value)),
+        getAddressEncoder48().encode(expectAddress(accounts.signer.value)),
         getBytesEncoder32().encode(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
       ]
     });
@@ -7583,15 +7612,15 @@ function parseInitEncryptedTokenAccountInstruction(instruction) {
 
 // src/generated/instructions/initEphemeralEncryptedTokenAccount.ts
 import {
-  combineCodec as combineCodec85,
+  combineCodec as combineCodec86,
   fixDecoderSize as fixDecoderSize32,
   fixEncoderSize as fixEncoderSize33,
-  getAddressEncoder as getAddressEncoder48,
+  getAddressEncoder as getAddressEncoder49,
   getBytesDecoder as getBytesDecoder32,
   getBytesEncoder as getBytesEncoder33,
   getProgramDerivedAddress as getProgramDerivedAddress13,
-  getStructDecoder as getStructDecoder79,
-  getStructEncoder as getStructEncoder79,
+  getStructDecoder as getStructDecoder80,
+  getStructEncoder as getStructEncoder80,
   getU128Decoder as getU128Decoder16,
   getU128Encoder as getU128Encoder16,
   getU64Decoder as getU64Decoder35,
@@ -7606,7 +7635,7 @@ function getInitEphemeralEncryptedTokenAccountDiscriminatorBytes() {
 }
 function getInitEphemeralEncryptedTokenAccountInstructionDataEncoder() {
   return transformEncoder32(
-    getStructEncoder79([
+    getStructEncoder80([
       ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
       ["index", getU64Encoder35()],
       ["stateNonce", getU128Encoder16()]
@@ -7618,14 +7647,14 @@ function getInitEphemeralEncryptedTokenAccountInstructionDataEncoder() {
   );
 }
 function getInitEphemeralEncryptedTokenAccountInstructionDataDecoder() {
-  return getStructDecoder79([
+  return getStructDecoder80([
     ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
     ["index", getU64Decoder35()],
     ["stateNonce", getU128Decoder16()]
   ]);
 }
 function getInitEphemeralEncryptedTokenAccountInstructionDataCodec() {
-  return combineCodec85(
+  return combineCodec86(
     getInitEphemeralEncryptedTokenAccountInstructionDataEncoder(),
     getInitEphemeralEncryptedTokenAccountInstructionDataDecoder()
   );
@@ -7680,8 +7709,8 @@ async function getInitEphemeralEncryptedTokenAccountInstructionAsync(input, conf
               116
             ])
           ),
-          getAddressEncoder48().encode(expectAddress(accounts.tokenMint.value)),
-          getAddressEncoder48().encode(expectAddress(accounts.owner.value)),
+          getAddressEncoder49().encode(expectAddress(accounts.tokenMint.value)),
+          getAddressEncoder49().encode(expectAddress(accounts.owner.value)),
           getBytesEncoder33().encode(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
         ]
       }
@@ -7718,8 +7747,8 @@ async function getInitEphemeralEncryptedTokenAccountInstructionAsync(input, conf
             116
           ])
         ),
-        getAddressEncoder48().encode(expectAddress(accounts.tokenMint.value)),
-        getAddressEncoder48().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.tokenMint.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.owner.value)),
         getU64Encoder35().encode(expectSome(args.index))
       ]
     });
@@ -7808,15 +7837,15 @@ function parseInitEphemeralEncryptedTokenAccountInstruction(instruction) {
 
 // src/generated/instructions/initShareAccount.ts
 import {
-  combineCodec as combineCodec86,
+  combineCodec as combineCodec87,
   fixDecoderSize as fixDecoderSize33,
   fixEncoderSize as fixEncoderSize34,
-  getAddressEncoder as getAddressEncoder49,
+  getAddressEncoder as getAddressEncoder50,
   getBytesDecoder as getBytesDecoder33,
   getBytesEncoder as getBytesEncoder34,
   getProgramDerivedAddress as getProgramDerivedAddress14,
-  getStructDecoder as getStructDecoder80,
-  getStructEncoder as getStructEncoder80,
+  getStructDecoder as getStructDecoder81,
+  getStructEncoder as getStructEncoder81,
   getU128Decoder as getU128Decoder17,
   getU128Encoder as getU128Encoder17,
   getU32Decoder as getU32Decoder13,
@@ -7840,7 +7869,7 @@ function getInitShareAccountDiscriminatorBytes() {
 }
 function getInitShareAccountInstructionDataEncoder() {
   return transformEncoder33(
-    getStructEncoder80([
+    getStructEncoder81([
       ["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)],
       ["stateNonce", getU128Encoder17()],
       ["shareAccountId", getU32Encoder13()]
@@ -7849,14 +7878,14 @@ function getInitShareAccountInstructionDataEncoder() {
   );
 }
 function getInitShareAccountInstructionDataDecoder() {
-  return getStructDecoder80([
+  return getStructDecoder81([
     ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)],
     ["stateNonce", getU128Decoder17()],
     ["shareAccountId", getU32Decoder13()]
   ]);
 }
 function getInitShareAccountInstructionDataCodec() {
-  return combineCodec86(
+  return combineCodec87(
     getInitShareAccountInstructionDataEncoder(),
     getInitShareAccountInstructionDataDecoder()
   );
@@ -7892,8 +7921,8 @@ async function getInitShareAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder49().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder49().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder50().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder50().encode(expectAddress(accounts.market.value)),
         getU32Encoder13().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -7966,16 +7995,16 @@ function parseInitShareAccountInstruction(instruction) {
 
 // src/generated/instructions/initTokenVault.ts
 import {
-  combineCodec as combineCodec87,
+  combineCodec as combineCodec88,
   fixDecoderSize as fixDecoderSize34,
   fixEncoderSize as fixEncoderSize35,
-  getAddressDecoder as getAddressDecoder39,
-  getAddressEncoder as getAddressEncoder50,
+  getAddressDecoder as getAddressDecoder40,
+  getAddressEncoder as getAddressEncoder51,
   getBytesDecoder as getBytesDecoder34,
   getBytesEncoder as getBytesEncoder35,
   getProgramDerivedAddress as getProgramDerivedAddress15,
-  getStructDecoder as getStructDecoder81,
-  getStructEncoder as getStructEncoder81,
+  getStructDecoder as getStructDecoder82,
+  getStructEncoder as getStructEncoder82,
   transformEncoder as transformEncoder34
 } from "@solana/kit";
 var INIT_TOKEN_VAULT_DISCRIMINATOR = new Uint8Array([
@@ -7995,21 +8024,21 @@ function getInitTokenVaultDiscriminatorBytes() {
 }
 function getInitTokenVaultInstructionDataEncoder() {
   return transformEncoder34(
-    getStructEncoder81([
+    getStructEncoder82([
       ["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)],
-      ["fundManager", getAddressEncoder50()]
+      ["fundManager", getAddressEncoder51()]
     ]),
     (value) => ({ ...value, discriminator: INIT_TOKEN_VAULT_DISCRIMINATOR })
   );
 }
 function getInitTokenVaultInstructionDataDecoder() {
-  return getStructDecoder81([
+  return getStructDecoder82([
     ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
-    ["fundManager", getAddressDecoder39()]
+    ["fundManager", getAddressDecoder40()]
   ]);
 }
 function getInitTokenVaultInstructionDataCodec() {
-  return combineCodec87(
+  return combineCodec88(
     getInitTokenVaultInstructionDataEncoder(),
     getInitTokenVaultInstructionDataDecoder()
   );
@@ -8032,7 +8061,7 @@ async function getInitTokenVaultInstructionAsync(input, config) {
         getBytesEncoder35().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder50().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder51().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -8132,15 +8161,15 @@ function parseInitTokenVaultInstruction(instruction) {
 
 // src/generated/instructions/openMarket.ts
 import {
-  combineCodec as combineCodec88,
+  combineCodec as combineCodec89,
   fixDecoderSize as fixDecoderSize35,
   fixEncoderSize as fixEncoderSize36,
-  getAddressEncoder as getAddressEncoder51,
+  getAddressEncoder as getAddressEncoder52,
   getBytesDecoder as getBytesDecoder35,
   getBytesEncoder as getBytesEncoder36,
   getProgramDerivedAddress as getProgramDerivedAddress16,
-  getStructDecoder as getStructDecoder82,
-  getStructEncoder as getStructEncoder82,
+  getStructDecoder as getStructDecoder83,
+  getStructEncoder as getStructEncoder83,
   getU64Decoder as getU64Decoder36,
   getU64Encoder as getU64Encoder36,
   transformEncoder as transformEncoder35
@@ -8160,7 +8189,7 @@ function getOpenMarketDiscriminatorBytes() {
 }
 function getOpenMarketInstructionDataEncoder() {
   return transformEncoder35(
-    getStructEncoder82([
+    getStructEncoder83([
       ["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)],
       ["openTimestamp", getU64Encoder36()]
     ]),
@@ -8168,13 +8197,13 @@ function getOpenMarketInstructionDataEncoder() {
   );
 }
 function getOpenMarketInstructionDataDecoder() {
-  return getStructDecoder82([
+  return getStructDecoder83([
     ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
     ["openTimestamp", getU64Decoder36()]
   ]);
 }
 function getOpenMarketInstructionDataCodec() {
-  return combineCodec88(
+  return combineCodec89(
     getOpenMarketInstructionDataEncoder(),
     getOpenMarketInstructionDataDecoder()
   );
@@ -8194,9 +8223,9 @@ async function getOpenMarketInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress16({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder51().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder51().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder51().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder52().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder52().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder52().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -8266,15 +8295,15 @@ function parseOpenMarketInstruction(instruction) {
 
 // src/generated/instructions/revealShares.ts
 import {
-  combineCodec as combineCodec89,
+  combineCodec as combineCodec90,
   fixDecoderSize as fixDecoderSize36,
   fixEncoderSize as fixEncoderSize37,
-  getAddressEncoder as getAddressEncoder52,
+  getAddressEncoder as getAddressEncoder53,
   getBytesDecoder as getBytesDecoder36,
   getBytesEncoder as getBytesEncoder37,
   getProgramDerivedAddress as getProgramDerivedAddress17,
-  getStructDecoder as getStructDecoder83,
-  getStructEncoder as getStructEncoder83,
+  getStructDecoder as getStructDecoder84,
+  getStructEncoder as getStructEncoder84,
   getU32Decoder as getU32Decoder14,
   getU32Encoder as getU32Encoder14,
   getU64Decoder as getU64Decoder37,
@@ -8298,7 +8327,7 @@ function getRevealSharesDiscriminatorBytes() {
 }
 function getRevealSharesInstructionDataEncoder() {
   return transformEncoder36(
-    getStructEncoder83([
+    getStructEncoder84([
       ["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)],
       ["computationOffset", getU64Encoder37()],
       ["shareAccountId", getU32Encoder14()]
@@ -8307,14 +8336,14 @@ function getRevealSharesInstructionDataEncoder() {
   );
 }
 function getRevealSharesInstructionDataDecoder() {
-  return getStructDecoder83([
+  return getStructDecoder84([
     ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)],
     ["computationOffset", getU64Decoder37()],
     ["shareAccountId", getU32Decoder14()]
   ]);
 }
 function getRevealSharesInstructionDataCodec() {
-  return combineCodec89(
+  return combineCodec90(
     getRevealSharesInstructionDataEncoder(),
     getRevealSharesInstructionDataDecoder()
   );
@@ -8365,8 +8394,8 @@ async function getRevealSharesInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder52().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder52().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder53().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder53().encode(expectAddress(accounts.market.value)),
         getU32Encoder14().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -8538,7 +8567,7 @@ function parseRevealSharesInstruction(instruction) {
 
 // src/generated/instructions/revealSharesCallback.ts
 import {
-  combineCodec as combineCodec90,
+  combineCodec as combineCodec91,
   fixDecoderSize as fixDecoderSize37,
   fixEncoderSize as fixEncoderSize38,
   getArrayDecoder as getArrayDecoder30,
@@ -8547,8 +8576,8 @@ import {
   getBytesEncoder as getBytesEncoder38,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder7,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder7,
-  getStructDecoder as getStructDecoder84,
-  getStructEncoder as getStructEncoder84,
+  getStructDecoder as getStructDecoder85,
+  getStructEncoder as getStructEncoder85,
   getTupleDecoder as getTupleDecoder9,
   getTupleEncoder as getTupleEncoder9,
   getU8Decoder as getU8Decoder37,
@@ -8574,14 +8603,14 @@ function getRevealSharesCallbackDiscriminatorBytes() {
 }
 function getRevealSharesCallbackInstructionDataEncoder() {
   return transformEncoder37(
-    getStructEncoder84([
+    getStructEncoder85([
       ["discriminator", fixEncoderSize38(getBytesEncoder38(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder7([
           [
             "Success",
-            getStructEncoder84([
+            getStructEncoder85([
               [
                 "fields",
                 getTupleEncoder9([
@@ -8594,7 +8623,7 @@ function getRevealSharesCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder4()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder84([
+            getStructEncoder85([
               ["fields", getTupleEncoder9([getRevealSharesOutputEncoder()])]
             ])
           ]
@@ -8608,14 +8637,14 @@ function getRevealSharesCallbackInstructionDataEncoder() {
   );
 }
 function getRevealSharesCallbackInstructionDataDecoder() {
-  return getStructDecoder84([
+  return getStructDecoder85([
     ["discriminator", fixDecoderSize37(getBytesDecoder37(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder7([
         [
           "Success",
-          getStructDecoder84([
+          getStructDecoder85([
             [
               "fields",
               getTupleDecoder9([
@@ -8628,7 +8657,7 @@ function getRevealSharesCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder4()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder84([
+          getStructDecoder85([
             ["fields", getTupleDecoder9([getRevealSharesOutputDecoder()])]
           ])
         ]
@@ -8637,7 +8666,7 @@ function getRevealSharesCallbackInstructionDataDecoder() {
   ]);
 }
 function getRevealSharesCallbackInstructionDataCodec() {
-  return combineCodec90(
+  return combineCodec91(
     getRevealSharesCallbackInstructionDataEncoder(),
     getRevealSharesCallbackInstructionDataDecoder()
   );
@@ -8716,13 +8745,13 @@ function parseRevealSharesCallbackInstruction(instruction) {
 
 // src/generated/instructions/revealSharesCompDef.ts
 import {
-  combineCodec as combineCodec91,
+  combineCodec as combineCodec92,
   fixDecoderSize as fixDecoderSize38,
   fixEncoderSize as fixEncoderSize39,
   getBytesDecoder as getBytesDecoder38,
   getBytesEncoder as getBytesEncoder39,
-  getStructDecoder as getStructDecoder85,
-  getStructEncoder as getStructEncoder85,
+  getStructDecoder as getStructDecoder86,
+  getStructEncoder as getStructEncoder86,
   transformEncoder as transformEncoder38
 } from "@solana/kit";
 var REVEAL_SHARES_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -8742,7 +8771,7 @@ function getRevealSharesCompDefDiscriminatorBytes() {
 }
 function getRevealSharesCompDefInstructionDataEncoder() {
   return transformEncoder38(
-    getStructEncoder85([["discriminator", fixEncoderSize39(getBytesEncoder39(), 8)]]),
+    getStructEncoder86([["discriminator", fixEncoderSize39(getBytesEncoder39(), 8)]]),
     (value) => ({
       ...value,
       discriminator: REVEAL_SHARES_COMP_DEF_DISCRIMINATOR
@@ -8750,12 +8779,12 @@ function getRevealSharesCompDefInstructionDataEncoder() {
   );
 }
 function getRevealSharesCompDefInstructionDataDecoder() {
-  return getStructDecoder85([
+  return getStructDecoder86([
     ["discriminator", fixDecoderSize38(getBytesDecoder38(), 8)]
   ]);
 }
 function getRevealSharesCompDefInstructionDataCodec() {
-  return combineCodec91(
+  return combineCodec92(
     getRevealSharesCompDefInstructionDataEncoder(),
     getRevealSharesCompDefInstructionDataDecoder()
   );
@@ -8828,15 +8857,15 @@ function parseRevealSharesCompDefInstruction(instruction) {
 
 // src/generated/instructions/selectWinningOptions.ts
 import {
-  combineCodec as combineCodec92,
+  combineCodec as combineCodec93,
   fixDecoderSize as fixDecoderSize39,
   fixEncoderSize as fixEncoderSize40,
   getArrayDecoder as getArrayDecoder31,
   getArrayEncoder as getArrayEncoder31,
   getBytesDecoder as getBytesDecoder39,
   getBytesEncoder as getBytesEncoder40,
-  getStructDecoder as getStructDecoder86,
-  getStructEncoder as getStructEncoder86,
+  getStructDecoder as getStructDecoder87,
+  getStructEncoder as getStructEncoder87,
   transformEncoder as transformEncoder39
 } from "@solana/kit";
 var SELECT_WINNING_OPTIONS_DISCRIMINATOR = new Uint8Array([
@@ -8856,7 +8885,7 @@ function getSelectWinningOptionsDiscriminatorBytes() {
 }
 function getSelectWinningOptionsInstructionDataEncoder() {
   return transformEncoder39(
-    getStructEncoder86([
+    getStructEncoder87([
       ["discriminator", fixEncoderSize40(getBytesEncoder40(), 8)],
       ["selections", getArrayEncoder31(getWinningOptionEncoder())]
     ]),
@@ -8867,13 +8896,13 @@ function getSelectWinningOptionsInstructionDataEncoder() {
   );
 }
 function getSelectWinningOptionsInstructionDataDecoder() {
-  return getStructDecoder86([
+  return getStructDecoder87([
     ["discriminator", fixDecoderSize39(getBytesDecoder39(), 8)],
     ["selections", getArrayDecoder31(getWinningOptionDecoder())]
   ]);
 }
 function getSelectWinningOptionsInstructionDataCodec() {
-  return combineCodec92(
+  return combineCodec93(
     getSelectWinningOptionsInstructionDataEncoder(),
     getSelectWinningOptionsInstructionDataDecoder()
   );
@@ -8919,17 +8948,17 @@ function parseSelectWinningOptionsInstruction(instruction) {
 
 // src/generated/instructions/stake.ts
 import {
-  combineCodec as combineCodec93,
+  combineCodec as combineCodec94,
   fixDecoderSize as fixDecoderSize40,
   fixEncoderSize as fixEncoderSize41,
-  getAddressEncoder as getAddressEncoder53,
+  getAddressEncoder as getAddressEncoder54,
   getArrayDecoder as getArrayDecoder32,
   getArrayEncoder as getArrayEncoder32,
   getBytesDecoder as getBytesDecoder40,
   getBytesEncoder as getBytesEncoder41,
   getProgramDerivedAddress as getProgramDerivedAddress18,
-  getStructDecoder as getStructDecoder87,
-  getStructEncoder as getStructEncoder87,
+  getStructDecoder as getStructDecoder88,
+  getStructEncoder as getStructEncoder88,
   getU128Decoder as getU128Decoder18,
   getU128Encoder as getU128Encoder18,
   getU32Decoder as getU32Decoder15,
@@ -8955,7 +8984,7 @@ function getStakeDiscriminatorBytes() {
 }
 function getStakeInstructionDataEncoder() {
   return transformEncoder40(
-    getStructEncoder87([
+    getStructEncoder88([
       ["discriminator", fixEncoderSize41(getBytesEncoder41(), 8)],
       ["computationOffset", getU64Encoder38()],
       ["shareAccountId", getU32Encoder15()],
@@ -8971,7 +9000,7 @@ function getStakeInstructionDataEncoder() {
   );
 }
 function getStakeInstructionDataDecoder() {
-  return getStructDecoder87([
+  return getStructDecoder88([
     ["discriminator", fixDecoderSize40(getBytesDecoder40(), 8)],
     ["computationOffset", getU64Decoder38()],
     ["shareAccountId", getU32Decoder15()],
@@ -8982,7 +9011,7 @@ function getStakeInstructionDataDecoder() {
   ]);
 }
 function getStakeInstructionDataCodec() {
-  return combineCodec93(
+  return combineCodec94(
     getStakeInstructionDataEncoder(),
     getStakeInstructionDataDecoder()
   );
@@ -9032,8 +9061,8 @@ async function getStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder53().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder53().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder54().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder54().encode(expectAddress(accounts.market.value)),
         getU32Encoder15().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -9201,16 +9230,16 @@ function parseStakeInstruction(instruction) {
 
 // src/generated/instructions/transferCentralStateAuthority.ts
 import {
-  combineCodec as combineCodec94,
+  combineCodec as combineCodec95,
   fixDecoderSize as fixDecoderSize41,
   fixEncoderSize as fixEncoderSize42,
-  getAddressDecoder as getAddressDecoder40,
-  getAddressEncoder as getAddressEncoder54,
+  getAddressDecoder as getAddressDecoder41,
+  getAddressEncoder as getAddressEncoder55,
   getBytesDecoder as getBytesDecoder41,
   getBytesEncoder as getBytesEncoder42,
   getProgramDerivedAddress as getProgramDerivedAddress19,
-  getStructDecoder as getStructDecoder88,
-  getStructEncoder as getStructEncoder88,
+  getStructDecoder as getStructDecoder89,
+  getStructEncoder as getStructEncoder89,
   transformEncoder as transformEncoder41
 } from "@solana/kit";
 var TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
@@ -9230,9 +9259,9 @@ function getTransferCentralStateAuthorityDiscriminatorBytes() {
 }
 function getTransferCentralStateAuthorityInstructionDataEncoder() {
   return transformEncoder41(
-    getStructEncoder88([
+    getStructEncoder89([
       ["discriminator", fixEncoderSize42(getBytesEncoder42(), 8)],
-      ["newAuthority", getAddressEncoder54()]
+      ["newAuthority", getAddressEncoder55()]
     ]),
     (value) => ({
       ...value,
@@ -9241,13 +9270,13 @@ function getTransferCentralStateAuthorityInstructionDataEncoder() {
   );
 }
 function getTransferCentralStateAuthorityInstructionDataDecoder() {
-  return getStructDecoder88([
+  return getStructDecoder89([
     ["discriminator", fixDecoderSize41(getBytesDecoder41(), 8)],
-    ["newAuthority", getAddressDecoder40()]
+    ["newAuthority", getAddressDecoder41()]
   ]);
 }
 function getTransferCentralStateAuthorityInstructionDataCodec() {
-  return combineCodec94(
+  return combineCodec95(
     getTransferCentralStateAuthorityInstructionDataEncoder(),
     getTransferCentralStateAuthorityInstructionDataDecoder()
   );
@@ -9337,15 +9366,15 @@ function parseTransferCentralStateAuthorityInstruction(instruction) {
 
 // src/generated/instructions/unstakeEarly.ts
 import {
-  combineCodec as combineCodec95,
+  combineCodec as combineCodec96,
   fixDecoderSize as fixDecoderSize42,
   fixEncoderSize as fixEncoderSize43,
-  getAddressEncoder as getAddressEncoder55,
+  getAddressEncoder as getAddressEncoder56,
   getBytesDecoder as getBytesDecoder42,
   getBytesEncoder as getBytesEncoder43,
   getProgramDerivedAddress as getProgramDerivedAddress20,
-  getStructDecoder as getStructDecoder89,
-  getStructEncoder as getStructEncoder89,
+  getStructDecoder as getStructDecoder90,
+  getStructEncoder as getStructEncoder90,
   getU32Decoder as getU32Decoder16,
   getU32Encoder as getU32Encoder16,
   transformEncoder as transformEncoder42
@@ -9367,7 +9396,7 @@ function getUnstakeEarlyDiscriminatorBytes() {
 }
 function getUnstakeEarlyInstructionDataEncoder() {
   return transformEncoder42(
-    getStructEncoder89([
+    getStructEncoder90([
       ["discriminator", fixEncoderSize43(getBytesEncoder43(), 8)],
       ["shareAccountId", getU32Encoder16()]
     ]),
@@ -9375,13 +9404,13 @@ function getUnstakeEarlyInstructionDataEncoder() {
   );
 }
 function getUnstakeEarlyInstructionDataDecoder() {
-  return getStructDecoder89([
+  return getStructDecoder90([
     ["discriminator", fixDecoderSize42(getBytesDecoder42(), 8)],
     ["shareAccountId", getU32Decoder16()]
   ]);
 }
 function getUnstakeEarlyInstructionDataCodec() {
-  return combineCodec95(
+  return combineCodec96(
     getUnstakeEarlyInstructionDataEncoder(),
     getUnstakeEarlyInstructionDataDecoder()
   );
@@ -9416,8 +9445,8 @@ async function getUnstakeEarlyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder55().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder55().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder56().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder56().encode(expectAddress(accounts.market.value)),
         getU32Encoder16().encode(expectSome(args.shareAccountId))
       ]
     });
@@ -9480,7 +9509,7 @@ function parseUnstakeEarlyInstruction(instruction) {
 
 // src/generated/instructions/unstakeEarlyCallback.ts
 import {
-  combineCodec as combineCodec96,
+  combineCodec as combineCodec97,
   fixDecoderSize as fixDecoderSize43,
   fixEncoderSize as fixEncoderSize44,
   getArrayDecoder as getArrayDecoder33,
@@ -9489,8 +9518,8 @@ import {
   getBytesEncoder as getBytesEncoder44,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder8,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder8,
-  getStructDecoder as getStructDecoder90,
-  getStructEncoder as getStructEncoder90,
+  getStructDecoder as getStructDecoder91,
+  getStructEncoder as getStructEncoder91,
   getTupleDecoder as getTupleDecoder10,
   getTupleEncoder as getTupleEncoder10,
   getU8Decoder as getU8Decoder39,
@@ -9516,14 +9545,14 @@ function getUnstakeEarlyCallbackDiscriminatorBytes() {
 }
 function getUnstakeEarlyCallbackInstructionDataEncoder() {
   return transformEncoder43(
-    getStructEncoder90([
+    getStructEncoder91([
       ["discriminator", fixEncoderSize44(getBytesEncoder44(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder8([
           [
             "Success",
-            getStructEncoder90([
+            getStructEncoder91([
               [
                 "fields",
                 getTupleEncoder10([
@@ -9536,7 +9565,7 @@ function getUnstakeEarlyCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder5()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder90([
+            getStructEncoder91([
               ["fields", getTupleEncoder10([getUnstakeEarlyOutputEncoder()])]
             ])
           ]
@@ -9550,14 +9579,14 @@ function getUnstakeEarlyCallbackInstructionDataEncoder() {
   );
 }
 function getUnstakeEarlyCallbackInstructionDataDecoder() {
-  return getStructDecoder90([
+  return getStructDecoder91([
     ["discriminator", fixDecoderSize43(getBytesDecoder43(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder8([
         [
           "Success",
-          getStructDecoder90([
+          getStructDecoder91([
             [
               "fields",
               getTupleDecoder10([
@@ -9570,7 +9599,7 @@ function getUnstakeEarlyCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder5()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder90([
+          getStructDecoder91([
             ["fields", getTupleDecoder10([getUnstakeEarlyOutputDecoder()])]
           ])
         ]
@@ -9579,7 +9608,7 @@ function getUnstakeEarlyCallbackInstructionDataDecoder() {
   ]);
 }
 function getUnstakeEarlyCallbackInstructionDataCodec() {
-  return combineCodec96(
+  return combineCodec97(
     getUnstakeEarlyCallbackInstructionDataEncoder(),
     getUnstakeEarlyCallbackInstructionDataDecoder()
   );
@@ -9658,13 +9687,13 @@ function parseUnstakeEarlyCallbackInstruction(instruction) {
 
 // src/generated/instructions/unstakeEarlyCompDef.ts
 import {
-  combineCodec as combineCodec97,
+  combineCodec as combineCodec98,
   fixDecoderSize as fixDecoderSize44,
   fixEncoderSize as fixEncoderSize45,
   getBytesDecoder as getBytesDecoder44,
   getBytesEncoder as getBytesEncoder45,
-  getStructDecoder as getStructDecoder91,
-  getStructEncoder as getStructEncoder91,
+  getStructDecoder as getStructDecoder92,
+  getStructEncoder as getStructEncoder92,
   transformEncoder as transformEncoder44
 } from "@solana/kit";
 var UNSTAKE_EARLY_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -9684,7 +9713,7 @@ function getUnstakeEarlyCompDefDiscriminatorBytes() {
 }
 function getUnstakeEarlyCompDefInstructionDataEncoder() {
   return transformEncoder44(
-    getStructEncoder91([["discriminator", fixEncoderSize45(getBytesEncoder45(), 8)]]),
+    getStructEncoder92([["discriminator", fixEncoderSize45(getBytesEncoder45(), 8)]]),
     (value) => ({
       ...value,
       discriminator: UNSTAKE_EARLY_COMP_DEF_DISCRIMINATOR
@@ -9692,12 +9721,12 @@ function getUnstakeEarlyCompDefInstructionDataEncoder() {
   );
 }
 function getUnstakeEarlyCompDefInstructionDataDecoder() {
-  return getStructDecoder91([
+  return getStructDecoder92([
     ["discriminator", fixDecoderSize44(getBytesDecoder44(), 8)]
   ]);
 }
 function getUnstakeEarlyCompDefInstructionDataCodec() {
-  return combineCodec97(
+  return combineCodec98(
     getUnstakeEarlyCompDefInstructionDataEncoder(),
     getUnstakeEarlyCompDefInstructionDataDecoder()
   );
@@ -9770,15 +9799,15 @@ function parseUnstakeEarlyCompDefInstruction(instruction) {
 
 // src/generated/instructions/unwrapEncryptedTokens.ts
 import {
-  combineCodec as combineCodec98,
+  combineCodec as combineCodec99,
   fixDecoderSize as fixDecoderSize45,
   fixEncoderSize as fixEncoderSize46,
-  getAddressEncoder as getAddressEncoder56,
+  getAddressEncoder as getAddressEncoder57,
   getBytesDecoder as getBytesDecoder45,
   getBytesEncoder as getBytesEncoder46,
   getProgramDerivedAddress as getProgramDerivedAddress21,
-  getStructDecoder as getStructDecoder92,
-  getStructEncoder as getStructEncoder92,
+  getStructDecoder as getStructDecoder93,
+  getStructEncoder as getStructEncoder93,
   getU64Decoder as getU64Decoder39,
   getU64Encoder as getU64Encoder39,
   transformEncoder as transformEncoder45
@@ -9800,7 +9829,7 @@ function getUnwrapEncryptedTokensDiscriminatorBytes() {
 }
 function getUnwrapEncryptedTokensInstructionDataEncoder() {
   return transformEncoder45(
-    getStructEncoder92([
+    getStructEncoder93([
       ["discriminator", fixEncoderSize46(getBytesEncoder46(), 8)],
       ["computationOffset", getU64Encoder39()],
       ["amount", getU64Encoder39()]
@@ -9812,14 +9841,14 @@ function getUnwrapEncryptedTokensInstructionDataEncoder() {
   );
 }
 function getUnwrapEncryptedTokensInstructionDataDecoder() {
-  return getStructDecoder92([
+  return getStructDecoder93([
     ["discriminator", fixDecoderSize45(getBytesDecoder45(), 8)],
     ["computationOffset", getU64Decoder39()],
     ["amount", getU64Decoder39()]
   ]);
 }
 function getUnwrapEncryptedTokensInstructionDataCodec() {
-  return combineCodec98(
+  return combineCodec99(
     getUnwrapEncryptedTokensInstructionDataEncoder(),
     getUnwrapEncryptedTokensInstructionDataDecoder()
   );
@@ -9864,7 +9893,7 @@ async function getUnwrapEncryptedTokensInstructionAsync(input, config) {
         getBytesEncoder46().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder56().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder57().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -9872,9 +9901,9 @@ async function getUnwrapEncryptedTokensInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress21({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder56().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder56().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder56().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder57().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder57().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder57().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -10061,7 +10090,7 @@ function parseUnwrapEncryptedTokensInstruction(instruction) {
 
 // src/generated/instructions/unwrapEncryptedTokensCallback.ts
 import {
-  combineCodec as combineCodec99,
+  combineCodec as combineCodec100,
   fixDecoderSize as fixDecoderSize46,
   fixEncoderSize as fixEncoderSize47,
   getArrayDecoder as getArrayDecoder34,
@@ -10070,8 +10099,8 @@ import {
   getBytesEncoder as getBytesEncoder47,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder9,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder9,
-  getStructDecoder as getStructDecoder93,
-  getStructEncoder as getStructEncoder93,
+  getStructDecoder as getStructDecoder94,
+  getStructEncoder as getStructEncoder94,
   getTupleDecoder as getTupleDecoder11,
   getTupleEncoder as getTupleEncoder11,
   getU8Decoder as getU8Decoder40,
@@ -10097,14 +10126,14 @@ function getUnwrapEncryptedTokensCallbackDiscriminatorBytes() {
 }
 function getUnwrapEncryptedTokensCallbackInstructionDataEncoder() {
   return transformEncoder46(
-    getStructEncoder93([
+    getStructEncoder94([
       ["discriminator", fixEncoderSize47(getBytesEncoder47(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder9([
           [
             "Success",
-            getStructEncoder93([
+            getStructEncoder94([
               [
                 "fields",
                 getTupleEncoder11([
@@ -10117,7 +10146,7 @@ function getUnwrapEncryptedTokensCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder6()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder93([
+            getStructEncoder94([
               [
                 "fields",
                 getTupleEncoder11([getUnwrapEncryptedTokensOutputEncoder()])
@@ -10134,14 +10163,14 @@ function getUnwrapEncryptedTokensCallbackInstructionDataEncoder() {
   );
 }
 function getUnwrapEncryptedTokensCallbackInstructionDataDecoder() {
-  return getStructDecoder93([
+  return getStructDecoder94([
     ["discriminator", fixDecoderSize46(getBytesDecoder46(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder9([
         [
           "Success",
-          getStructDecoder93([
+          getStructDecoder94([
             [
               "fields",
               getTupleDecoder11([
@@ -10154,7 +10183,7 @@ function getUnwrapEncryptedTokensCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder6()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder93([
+          getStructDecoder94([
             [
               "fields",
               getTupleDecoder11([getUnwrapEncryptedTokensOutputDecoder()])
@@ -10166,7 +10195,7 @@ function getUnwrapEncryptedTokensCallbackInstructionDataDecoder() {
   ]);
 }
 function getUnwrapEncryptedTokensCallbackInstructionDataCodec() {
-  return combineCodec99(
+  return combineCodec100(
     getUnwrapEncryptedTokensCallbackInstructionDataEncoder(),
     getUnwrapEncryptedTokensCallbackInstructionDataDecoder()
   );
@@ -10263,13 +10292,13 @@ function parseUnwrapEncryptedTokensCallbackInstruction(instruction) {
 
 // src/generated/instructions/unwrapEncryptedTokensCompDef.ts
 import {
-  combineCodec as combineCodec100,
+  combineCodec as combineCodec101,
   fixDecoderSize as fixDecoderSize47,
   fixEncoderSize as fixEncoderSize48,
   getBytesDecoder as getBytesDecoder47,
   getBytesEncoder as getBytesEncoder48,
-  getStructDecoder as getStructDecoder94,
-  getStructEncoder as getStructEncoder94,
+  getStructDecoder as getStructDecoder95,
+  getStructEncoder as getStructEncoder95,
   transformEncoder as transformEncoder47
 } from "@solana/kit";
 var UNWRAP_ENCRYPTED_TOKENS_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -10289,7 +10318,7 @@ function getUnwrapEncryptedTokensCompDefDiscriminatorBytes() {
 }
 function getUnwrapEncryptedTokensCompDefInstructionDataEncoder() {
   return transformEncoder47(
-    getStructEncoder94([["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)]]),
+    getStructEncoder95([["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)]]),
     (value) => ({
       ...value,
       discriminator: UNWRAP_ENCRYPTED_TOKENS_COMP_DEF_DISCRIMINATOR
@@ -10297,12 +10326,12 @@ function getUnwrapEncryptedTokensCompDefInstructionDataEncoder() {
   );
 }
 function getUnwrapEncryptedTokensCompDefInstructionDataDecoder() {
-  return getStructDecoder94([
+  return getStructDecoder95([
     ["discriminator", fixDecoderSize47(getBytesDecoder47(), 8)]
   ]);
 }
 function getUnwrapEncryptedTokensCompDefInstructionDataCodec() {
-  return combineCodec100(
+  return combineCodec101(
     getUnwrapEncryptedTokensCompDefInstructionDataEncoder(),
     getUnwrapEncryptedTokensCompDefInstructionDataDecoder()
   );
@@ -10375,16 +10404,16 @@ function parseUnwrapEncryptedTokensCompDefInstruction(instruction) {
 
 // src/generated/instructions/updateCentralState.ts
 import {
-  combineCodec as combineCodec101,
+  combineCodec as combineCodec102,
   fixDecoderSize as fixDecoderSize48,
   fixEncoderSize as fixEncoderSize49,
-  getAddressDecoder as getAddressDecoder41,
-  getAddressEncoder as getAddressEncoder57,
+  getAddressDecoder as getAddressDecoder42,
+  getAddressEncoder as getAddressEncoder58,
   getBytesDecoder as getBytesDecoder48,
   getBytesEncoder as getBytesEncoder49,
   getProgramDerivedAddress as getProgramDerivedAddress22,
-  getStructDecoder as getStructDecoder95,
-  getStructEncoder as getStructEncoder95,
+  getStructDecoder as getStructDecoder96,
+  getStructEncoder as getStructEncoder96,
   getU16Decoder as getU16Decoder18,
   getU16Encoder as getU16Encoder18,
   getU64Decoder as getU64Decoder40,
@@ -10408,27 +10437,27 @@ function getUpdateCentralStateDiscriminatorBytes() {
 }
 function getUpdateCentralStateInstructionDataEncoder() {
   return transformEncoder48(
-    getStructEncoder95([
+    getStructEncoder96([
       ["discriminator", fixEncoderSize49(getBytesEncoder49(), 8)],
       ["earlinessCutoffSeconds", getU64Encoder40()],
       ["minOptionDeposit", getU64Encoder40()],
       ["protocolFeeBp", getU16Encoder18()],
-      ["feeRecipient", getAddressEncoder57()]
+      ["feeRecipient", getAddressEncoder58()]
     ]),
     (value) => ({ ...value, discriminator: UPDATE_CENTRAL_STATE_DISCRIMINATOR })
   );
 }
 function getUpdateCentralStateInstructionDataDecoder() {
-  return getStructDecoder95([
+  return getStructDecoder96([
     ["discriminator", fixDecoderSize48(getBytesDecoder48(), 8)],
     ["earlinessCutoffSeconds", getU64Decoder40()],
     ["minOptionDeposit", getU64Decoder40()],
     ["protocolFeeBp", getU16Decoder18()],
-    ["feeRecipient", getAddressDecoder41()]
+    ["feeRecipient", getAddressDecoder42()]
   ]);
 }
 function getUpdateCentralStateInstructionDataCodec() {
-  return combineCodec101(
+  return combineCodec102(
     getUpdateCentralStateInstructionDataEncoder(),
     getUpdateCentralStateInstructionDataDecoder()
   );
@@ -10518,15 +10547,15 @@ function parseUpdateCentralStateInstruction(instruction) {
 
 // src/generated/instructions/wrapEncryptedTokens.ts
 import {
-  combineCodec as combineCodec102,
+  combineCodec as combineCodec103,
   fixDecoderSize as fixDecoderSize49,
   fixEncoderSize as fixEncoderSize50,
-  getAddressEncoder as getAddressEncoder58,
+  getAddressEncoder as getAddressEncoder59,
   getBytesDecoder as getBytesDecoder49,
   getBytesEncoder as getBytesEncoder50,
   getProgramDerivedAddress as getProgramDerivedAddress23,
-  getStructDecoder as getStructDecoder96,
-  getStructEncoder as getStructEncoder96,
+  getStructDecoder as getStructDecoder97,
+  getStructEncoder as getStructEncoder97,
   getU64Decoder as getU64Decoder41,
   getU64Encoder as getU64Encoder41,
   transformEncoder as transformEncoder49
@@ -10548,7 +10577,7 @@ function getWrapEncryptedTokensDiscriminatorBytes() {
 }
 function getWrapEncryptedTokensInstructionDataEncoder() {
   return transformEncoder49(
-    getStructEncoder96([
+    getStructEncoder97([
       ["discriminator", fixEncoderSize50(getBytesEncoder50(), 8)],
       ["computationOffset", getU64Encoder41()],
       ["amount", getU64Encoder41()]
@@ -10560,14 +10589,14 @@ function getWrapEncryptedTokensInstructionDataEncoder() {
   );
 }
 function getWrapEncryptedTokensInstructionDataDecoder() {
-  return getStructDecoder96([
+  return getStructDecoder97([
     ["discriminator", fixDecoderSize49(getBytesDecoder49(), 8)],
     ["computationOffset", getU64Decoder41()],
     ["amount", getU64Decoder41()]
   ]);
 }
 function getWrapEncryptedTokensInstructionDataCodec() {
-  return combineCodec102(
+  return combineCodec103(
     getWrapEncryptedTokensInstructionDataEncoder(),
     getWrapEncryptedTokensInstructionDataDecoder()
   );
@@ -10612,7 +10641,7 @@ async function getWrapEncryptedTokensInstructionAsync(input, config) {
         getBytesEncoder50().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder58().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder59().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -10620,9 +10649,9 @@ async function getWrapEncryptedTokensInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress23({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder58().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder58().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder58().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder59().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder59().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder59().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -10809,7 +10838,7 @@ function parseWrapEncryptedTokensInstruction(instruction) {
 
 // src/generated/instructions/wrapEncryptedTokensCallback.ts
 import {
-  combineCodec as combineCodec103,
+  combineCodec as combineCodec104,
   fixDecoderSize as fixDecoderSize50,
   fixEncoderSize as fixEncoderSize51,
   getArrayDecoder as getArrayDecoder35,
@@ -10818,8 +10847,8 @@ import {
   getBytesEncoder as getBytesEncoder51,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder10,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder10,
-  getStructDecoder as getStructDecoder97,
-  getStructEncoder as getStructEncoder97,
+  getStructDecoder as getStructDecoder98,
+  getStructEncoder as getStructEncoder98,
   getTupleDecoder as getTupleDecoder12,
   getTupleEncoder as getTupleEncoder12,
   getU8Decoder as getU8Decoder41,
@@ -10845,14 +10874,14 @@ function getWrapEncryptedTokensCallbackDiscriminatorBytes() {
 }
 function getWrapEncryptedTokensCallbackInstructionDataEncoder() {
   return transformEncoder50(
-    getStructEncoder97([
+    getStructEncoder98([
       ["discriminator", fixEncoderSize51(getBytesEncoder51(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder10([
           [
             "Success",
-            getStructEncoder97([
+            getStructEncoder98([
               [
                 "fields",
                 getTupleEncoder12([
@@ -10865,7 +10894,7 @@ function getWrapEncryptedTokensCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder7()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder97([
+            getStructEncoder98([
               [
                 "fields",
                 getTupleEncoder12([getWrapEncryptedTokensOutputEncoder()])
@@ -10882,14 +10911,14 @@ function getWrapEncryptedTokensCallbackInstructionDataEncoder() {
   );
 }
 function getWrapEncryptedTokensCallbackInstructionDataDecoder() {
-  return getStructDecoder97([
+  return getStructDecoder98([
     ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder10([
         [
           "Success",
-          getStructDecoder97([
+          getStructDecoder98([
             [
               "fields",
               getTupleDecoder12([
@@ -10902,7 +10931,7 @@ function getWrapEncryptedTokensCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder7()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder97([
+          getStructDecoder98([
             [
               "fields",
               getTupleDecoder12([getWrapEncryptedTokensOutputDecoder()])
@@ -10914,7 +10943,7 @@ function getWrapEncryptedTokensCallbackInstructionDataDecoder() {
   ]);
 }
 function getWrapEncryptedTokensCallbackInstructionDataCodec() {
-  return combineCodec103(
+  return combineCodec104(
     getWrapEncryptedTokensCallbackInstructionDataEncoder(),
     getWrapEncryptedTokensCallbackInstructionDataDecoder()
   );
@@ -10993,13 +11022,13 @@ function parseWrapEncryptedTokensCallbackInstruction(instruction) {
 
 // src/generated/instructions/wrapEncryptedTokensCompDef.ts
 import {
-  combineCodec as combineCodec104,
+  combineCodec as combineCodec105,
   fixDecoderSize as fixDecoderSize51,
   fixEncoderSize as fixEncoderSize52,
   getBytesDecoder as getBytesDecoder51,
   getBytesEncoder as getBytesEncoder52,
-  getStructDecoder as getStructDecoder98,
-  getStructEncoder as getStructEncoder98,
+  getStructDecoder as getStructDecoder99,
+  getStructEncoder as getStructEncoder99,
   transformEncoder as transformEncoder51
 } from "@solana/kit";
 var WRAP_ENCRYPTED_TOKENS_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -11019,7 +11048,7 @@ function getWrapEncryptedTokensCompDefDiscriminatorBytes() {
 }
 function getWrapEncryptedTokensCompDefInstructionDataEncoder() {
   return transformEncoder51(
-    getStructEncoder98([["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)]]),
+    getStructEncoder99([["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)]]),
     (value) => ({
       ...value,
       discriminator: WRAP_ENCRYPTED_TOKENS_COMP_DEF_DISCRIMINATOR
@@ -11027,12 +11056,12 @@ function getWrapEncryptedTokensCompDefInstructionDataEncoder() {
   );
 }
 function getWrapEncryptedTokensCompDefInstructionDataDecoder() {
-  return getStructDecoder98([
+  return getStructDecoder99([
     ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)]
   ]);
 }
 function getWrapEncryptedTokensCompDefInstructionDataCodec() {
-  return combineCodec104(
+  return combineCodec105(
     getWrapEncryptedTokensCompDefInstructionDataEncoder(),
     getWrapEncryptedTokensCompDefInstructionDataDecoder()
   );
@@ -11589,7 +11618,7 @@ async function claimPendingDeposit(input) {
 
 // src/accounts/encryptedTokenAccount.ts
 import {
-  getAddressEncoder as getAddressEncoder59,
+  getAddressEncoder as getAddressEncoder60,
   getU64Encoder as getU64Encoder42,
   getProgramDerivedAddress as getProgramDerivedAddress25
 } from "@solana/kit";
@@ -11602,8 +11631,8 @@ async function getEncryptedTokenAccountAddressWithIndex(tokenMint, owner, index,
     programAddress: programId,
     seeds: [
       ENCRYPTED_TOKEN_ACCOUNT_SEED,
-      getAddressEncoder59().encode(tokenMint),
-      getAddressEncoder59().encode(owner),
+      getAddressEncoder60().encode(tokenMint),
+      getAddressEncoder60().encode(owner),
       getU64Encoder42().encode(index)
     ]
   });
@@ -11614,7 +11643,7 @@ async function getEphemeralEncryptedTokenAccountAddress(tokenMint, owner, index,
 
 // src/accounts/opportunityMarket.ts
 import {
-  getAddressEncoder as getAddressEncoder60,
+  getAddressEncoder as getAddressEncoder61,
   getU64Encoder as getU64Encoder43,
   getProgramDerivedAddress as getProgramDerivedAddress26
 } from "@solana/kit";
@@ -11624,7 +11653,7 @@ async function getOpportunityMarketAddress(creator, marketIndex, programId = OPP
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_SEED,
-      getAddressEncoder60().encode(creator),
+      getAddressEncoder61().encode(creator),
       getU64Encoder43().encode(BigInt(marketIndex))
     ]
   });
@@ -11632,7 +11661,7 @@ async function getOpportunityMarketAddress(creator, marketIndex, programId = OPP
 
 // src/accounts/opportunityMarketOption.ts
 import {
-  getAddressEncoder as getAddressEncoder61,
+  getAddressEncoder as getAddressEncoder62,
   getU16Encoder as getU16Encoder19,
   getProgramDerivedAddress as getProgramDerivedAddress27
 } from "@solana/kit";
@@ -11642,7 +11671,7 @@ async function getOpportunityMarketOptionAddress(market, optionIndex, programId
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_OPTION_SEED,
-      getAddressEncoder61().encode(market),
+      getAddressEncoder62().encode(market),
       getU16Encoder19().encode(optionIndex)
     ]
   });
@@ -11650,12 +11679,12 @@ async function getOpportunityMarketOptionAddress(market, optionIndex, programId
 
 // src/accounts/shareAccount.ts
 import {
-  getAddressEncoder as getAddressEncoder62,
+  getAddressEncoder as getAddressEncoder63,
   getProgramDerivedAddress as getProgramDerivedAddress28
 } from "@solana/kit";
 var SHARE_ACCOUNT_SEED = "share_account";
 async function getShareAccountAddress(owner, market, shareAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = getAddressEncoder62();
+  const addressEncoder = getAddressEncoder63();
   const idBytes = new Uint8Array(4);
   new DataView(idBytes.buffer).setUint32(0, shareAccountId, true);
   return getProgramDerivedAddress28({
@@ -11671,19 +11700,19 @@ async function getShareAccountAddress(owner, market, shareAccountId, programId =
 
 // src/accounts/tokenVault.ts
 import {
-  getAddressEncoder as getAddressEncoder63,
+  getAddressEncoder as getAddressEncoder64,
   getProgramDerivedAddress as getProgramDerivedAddress29
 } from "@solana/kit";
 var TOKEN_VAULT_SEED = "token_vault";
 async function getTokenVaultAddress(mint, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
   return getProgramDerivedAddress29({
     programAddress: programId,
-    seeds: [TOKEN_VAULT_SEED, getAddressEncoder63().encode(mint)]
+    seeds: [TOKEN_VAULT_SEED, getAddressEncoder64().encode(mint)]
   });
 }
 
 // src/arcium/awaitFinalizeComputation.ts
-import { getAddressEncoder as getAddressEncoder64 } from "@solana/kit";
+import { getAddressEncoder as getAddressEncoder65 } from "@solana/kit";
 
 // src/arcium/constants.ts
 var ARCIUM_PROGRAM_ID = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
@@ -11712,7 +11741,7 @@ var awaitBatchComputationFinalization = async (rpc, computationOffsets, options)
   }
   const mxeProgramId = options?.mxeProgramId ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const commitment = options?.commitment ?? "confirmed";
-  const mxeProgramIdBytes = getAddressEncoder64().encode(mxeProgramId);
+  const mxeProgramIdBytes = getAddressEncoder65().encode(mxeProgramId);
   const transactionCountLimit = options?.transactionCountLimit ?? 100;
   const pollInterval = options?.pollInterval ?? 1e3;
   const maxAttempts = options?.maxAttempts ?? 120;
@@ -12133,6 +12162,9 @@ export {
   getEncryptedTokensUnwrappedEventCodec,
   getEncryptedTokensUnwrappedEventDecoder,
   getEncryptedTokensUnwrappedEventEncoder,
+  getEncryptedTokensWrappedErrorCodec,
+  getEncryptedTokensWrappedErrorDecoder,
+  getEncryptedTokensWrappedErrorEncoder,
   getEncryptedTokensWrappedEventCodec,
   getEncryptedTokensWrappedEventDecoder,
   getEncryptedTokensWrappedEventEncoder,