@bench.games/opportunity-markets 0.2.9 → 0.2.12

package/dist/browser/index.js

@@ -110,8 +110,6 @@ import {
   getStructEncoder as getStructEncoder2,
   getU16Decoder,
   getU16Encoder,
-  getU64Decoder,
-  getU64Encoder,
   getU8Decoder as getU8Decoder2,
   getU8Encoder as getU8Encoder2,
   transformEncoder as transformEncoder2
@@ -136,12 +134,9 @@ function getCentralStateEncoder() {
     getStructEncoder2([
       ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
       ["bump", getU8Encoder2()],
-      ["earlinessCutoffSeconds", getU64Encoder()],
       ["authority", getAddressEncoder()],
-      ["minOptionDeposit", getU64Encoder()],
       ["protocolFeeBp", getU16Encoder()],
       ["feeRecipient", getAddressEncoder()],
-      ["minimumInitialRevealPeriod", getU64Encoder()],
       ["reserved", getArrayEncoder(getU8Encoder2(), { size: 128 })]
     ]),
     (value) => ({ ...value, discriminator: CENTRAL_STATE_DISCRIMINATOR })
@@ -151,12 +146,9 @@ function getCentralStateDecoder() {
   return getStructDecoder2([
     ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
     ["bump", getU8Decoder2()],
-    ["earlinessCutoffSeconds", getU64Decoder()],
     ["authority", getAddressDecoder()],
-    ["minOptionDeposit", getU64Decoder()],
     ["protocolFeeBp", getU16Decoder()],
     ["feeRecipient", getAddressDecoder()],
-    ["minimumInitialRevealPeriod", getU64Decoder()],
     ["reserved", getArrayDecoder(getU8Decoder2(), { size: 128 })]
   ]);
 }
@@ -192,7 +184,7 @@ async function fetchAllMaybeCentralState(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists3,
   assertAccountsExist as assertAccountsExist3,
-  combineCodec as combineCodec40,
+  combineCodec as combineCodec42,
   decodeAccount as decodeAccount3,
   fetchEncodedAccount as fetchEncodedAccount3,
   fetchEncodedAccounts as fetchEncodedAccounts3,
@@ -200,8 +192,8 @@ import {
   fixEncoderSize as fixEncoderSize3,
   getBytesDecoder as getBytesDecoder3,
   getBytesEncoder as getBytesEncoder3,
-  getStructDecoder as getStructDecoder34,
-  getStructEncoder as getStructEncoder34,
+  getStructDecoder as getStructDecoder36,
+  getStructEncoder as getStructEncoder36,
   getU8Decoder as getU8Decoder12,
   getU8Encoder as getU8Encoder12,
   transformEncoder as transformEncoder3
@@ -375,14 +367,14 @@ import {
   combineCodec as combineCodec8,
   getTupleDecoder as getTupleDecoder3,
   getTupleEncoder as getTupleEncoder3,
-  getU64Decoder as getU64Decoder2,
-  getU64Encoder as getU64Encoder2
+  getU64Decoder,
+  getU64Encoder
 } from "@solana/kit";
 function getEpochEncoder() {
-  return getTupleEncoder3([getU64Encoder2()]);
+  return getTupleEncoder3([getU64Encoder()]);
 }
 function getEpochDecoder() {
-  return getTupleDecoder3([getU64Decoder2()]);
+  return getTupleDecoder3([getU64Decoder()]);
 }
 function getEpochCodec() {
   return combineCodec8(getEpochEncoder(), getEpochDecoder());
@@ -397,15 +389,15 @@ import {
   getI64Encoder,
   getStructDecoder as getStructDecoder7,
   getStructEncoder as getStructEncoder7,
-  getU64Decoder as getU64Decoder3,
-  getU64Encoder as getU64Encoder3
+  getU64Decoder as getU64Decoder2,
+  getU64Encoder as getU64Encoder2
 } from "@solana/kit";
 function getFeesClaimedEventEncoder() {
   return getStructEncoder7([
     ["tokenVault", getAddressEncoder2()],
     ["mint", getAddressEncoder2()],
     ["feeRecipient", getAddressEncoder2()],
-    ["amount", getU64Encoder3()],
+    ["amount", getU64Encoder2()],
     ["timestamp", getI64Encoder()]
   ]);
 }
@@ -414,7 +406,7 @@ function getFeesClaimedEventDecoder() {
     ["tokenVault", getAddressDecoder2()],
     ["mint", getAddressDecoder2()],
     ["feeRecipient", getAddressDecoder2()],
-    ["amount", getU64Decoder3()],
+    ["amount", getU64Decoder2()],
     ["timestamp", getI64Decoder()]
   ]);
 }
@@ -465,8 +457,8 @@ import {
   getOptionEncoder,
   getStructDecoder as getStructDecoder8,
   getStructEncoder as getStructEncoder8,
-  getU64Decoder as getU64Decoder4,
-  getU64Encoder as getU64Encoder4,
+  getU64Decoder as getU64Decoder3,
+  getU64Encoder as getU64Encoder3,
   getU8Decoder as getU8Decoder4,
   getU8Encoder as getU8Encoder4
 } from "@solana/kit";
@@ -474,14 +466,14 @@ function getMarketCreatedEventEncoder() {
   return getStructEncoder8([
     ["market", getAddressEncoder3()],
     ["creator", getAddressEncoder3()],
-    ["index", getU64Encoder4()],
+    ["index", getU64Encoder3()],
     ["mint", getAddressEncoder3()],
-    ["timeToStake", getU64Encoder4()],
-    ["timeToReveal", getU64Encoder4()],
-    ["earlinessCutoffSeconds", getU64Encoder4()],
+    ["timeToStake", getU64Encoder3()],
+    ["timeToReveal", getU64Encoder3()],
+    ["earlinessCutoffSeconds", getU64Encoder3()],
     ["marketAuthority", getOptionEncoder(getAddressEncoder3())],
     ["authorizedReaderPubkey", getArrayEncoder4(getU8Encoder4(), { size: 32 })],
-    ["unstakeDelaySeconds", getU64Encoder4()],
+    ["unstakeDelaySeconds", getU64Encoder3()],
     ["allowClosingEarly", getBooleanEncoder()],
     ["timestamp", getI64Encoder2()]
   ]);
@@ -490,14 +482,14 @@ function getMarketCreatedEventDecoder() {
   return getStructDecoder8([
     ["market", getAddressDecoder3()],
     ["creator", getAddressDecoder3()],
-    ["index", getU64Decoder4()],
+    ["index", getU64Decoder3()],
     ["mint", getAddressDecoder3()],
-    ["timeToStake", getU64Decoder4()],
-    ["timeToReveal", getU64Decoder4()],
-    ["earlinessCutoffSeconds", getU64Decoder4()],
+    ["timeToStake", getU64Decoder3()],
+    ["timeToReveal", getU64Decoder3()],
+    ["earlinessCutoffSeconds", getU64Decoder3()],
     ["marketAuthority", getOptionDecoder(getAddressDecoder3())],
     ["authorizedReaderPubkey", getArrayDecoder4(getU8Decoder4(), { size: 32 })],
-    ["unstakeDelaySeconds", getU64Decoder4()],
+    ["unstakeDelaySeconds", getU64Decoder3()],
     ["allowClosingEarly", getBooleanDecoder()],
     ["timestamp", getI64Decoder2()]
   ]);
@@ -518,14 +510,14 @@ import {
   getI64Encoder as getI64Encoder3,
   getStructDecoder as getStructDecoder9,
   getStructEncoder as getStructEncoder9,
-  getU64Decoder as getU64Decoder5,
-  getU64Encoder as getU64Encoder5
+  getU64Decoder as getU64Decoder4,
+  getU64Encoder as getU64Encoder4
 } from "@solana/kit";
 function getMarketOpenedEventEncoder() {
   return getStructEncoder9([
     ["market", getAddressEncoder4()],
     ["creator", getAddressEncoder4()],
-    ["openTimestamp", getU64Encoder5()],
+    ["openTimestamp", getU64Encoder4()],
     ["timestamp", getI64Encoder3()]
   ]);
 }
@@ -533,7 +525,7 @@ function getMarketOpenedEventDecoder() {
   return getStructDecoder9([
     ["market", getAddressDecoder4()],
     ["creator", getAddressDecoder4()],
-    ["openTimestamp", getU64Decoder5()],
+    ["openTimestamp", getU64Decoder4()],
     ["timestamp", getI64Decoder3()]
   ]);
 }
@@ -553,15 +545,15 @@ import {
   getI64Encoder as getI64Encoder4,
   getStructDecoder as getStructDecoder10,
   getStructEncoder as getStructEncoder10,
-  getU64Decoder as getU64Decoder6,
-  getU64Encoder as getU64Encoder6
+  getU64Decoder as getU64Decoder5,
+  getU64Encoder as getU64Encoder5
 } from "@solana/kit";
 function getMarketOptionCreatedEventEncoder() {
   return getStructEncoder10([
     ["option", getAddressEncoder5()],
     ["market", getAddressEncoder5()],
     ["creator", getAddressEncoder5()],
-    ["id", getU64Encoder6()],
+    ["id", getU64Encoder5()],
     ["timestamp", getI64Encoder4()]
   ]);
 }
@@ -570,7 +562,7 @@ function getMarketOptionCreatedEventDecoder() {
     ["option", getAddressDecoder5()],
     ["market", getAddressDecoder5()],
     ["creator", getAddressDecoder5()],
-    ["id", getU64Decoder6()],
+    ["id", getU64Decoder5()],
     ["timestamp", getI64Decoder4()]
   ]);
 }
@@ -581,9 +573,67 @@ function getMarketOptionCreatedEventCodec() {
   );
 }
 
-// src/generated/types/mxeStatus.ts
+// src/generated/types/marketPausedEvent.ts
 import {
   combineCodec as combineCodec14,
+  getAddressDecoder as getAddressDecoder6,
+  getAddressEncoder as getAddressEncoder6,
+  getI64Decoder as getI64Decoder5,
+  getI64Encoder as getI64Encoder5,
+  getStructDecoder as getStructDecoder11,
+  getStructEncoder as getStructEncoder11
+} from "@solana/kit";
+function getMarketPausedEventEncoder() {
+  return getStructEncoder11([
+    ["market", getAddressEncoder6()],
+    ["timestamp", getI64Encoder5()]
+  ]);
+}
+function getMarketPausedEventDecoder() {
+  return getStructDecoder11([
+    ["market", getAddressDecoder6()],
+    ["timestamp", getI64Decoder5()]
+  ]);
+}
+function getMarketPausedEventCodec() {
+  return combineCodec14(
+    getMarketPausedEventEncoder(),
+    getMarketPausedEventDecoder()
+  );
+}
+
+// src/generated/types/marketResumedEvent.ts
+import {
+  combineCodec as combineCodec15,
+  getAddressDecoder as getAddressDecoder7,
+  getAddressEncoder as getAddressEncoder7,
+  getI64Decoder as getI64Decoder6,
+  getI64Encoder as getI64Encoder6,
+  getStructDecoder as getStructDecoder12,
+  getStructEncoder as getStructEncoder12
+} from "@solana/kit";
+function getMarketResumedEventEncoder() {
+  return getStructEncoder12([
+    ["market", getAddressEncoder7()],
+    ["timestamp", getI64Encoder6()]
+  ]);
+}
+function getMarketResumedEventDecoder() {
+  return getStructDecoder12([
+    ["market", getAddressDecoder7()],
+    ["timestamp", getI64Decoder6()]
+  ]);
+}
+function getMarketResumedEventCodec() {
+  return combineCodec15(
+    getMarketResumedEventEncoder(),
+    getMarketResumedEventDecoder()
+  );
+}
+
+// src/generated/types/mxeStatus.ts
+import {
+  combineCodec as combineCodec16,
   getEnumDecoder as getEnumDecoder2,
   getEnumEncoder as getEnumEncoder2
 } from "@solana/kit";
@@ -599,76 +649,76 @@ function getMxeStatusDecoder() {
   return getEnumDecoder2(MxeStatus);
 }
 function getMxeStatusCodec() {
-  return combineCodec14(getMxeStatusEncoder(), getMxeStatusDecoder());
+  return combineCodec16(getMxeStatusEncoder(), getMxeStatusDecoder());
 }
 
 // src/generated/types/nodeMetadata.ts
 import {
-  combineCodec as combineCodec15,
+  combineCodec as combineCodec17,
   getArrayDecoder as getArrayDecoder5,
   getArrayEncoder as getArrayEncoder5,
-  getStructDecoder as getStructDecoder11,
-  getStructEncoder as getStructEncoder11,
+  getStructDecoder as getStructDecoder13,
+  getStructEncoder as getStructEncoder13,
   getU8Decoder as getU8Decoder5,
   getU8Encoder as getU8Encoder5
 } from "@solana/kit";
 function getNodeMetadataEncoder() {
-  return getStructEncoder11([
+  return getStructEncoder13([
     ["ip", getArrayEncoder5(getU8Encoder5(), { size: 4 })],
     ["peerId", getArrayEncoder5(getU8Encoder5(), { size: 32 })],
     ["location", getU8Encoder5()]
   ]);
 }
 function getNodeMetadataDecoder() {
-  return getStructDecoder11([
+  return getStructDecoder13([
     ["ip", getArrayDecoder5(getU8Decoder5(), { size: 4 })],
     ["peerId", getArrayDecoder5(getU8Decoder5(), { size: 32 })],
     ["location", getU8Decoder5()]
   ]);
 }
 function getNodeMetadataCodec() {
-  return combineCodec15(getNodeMetadataEncoder(), getNodeMetadataDecoder());
+  return combineCodec17(getNodeMetadataEncoder(), getNodeMetadataDecoder());
 }
 
 // src/generated/types/nodeRef.ts
 import {
-  combineCodec as combineCodec16,
-  getStructDecoder as getStructDecoder12,
-  getStructEncoder as getStructEncoder12,
+  combineCodec as combineCodec18,
+  getStructDecoder as getStructDecoder14,
+  getStructEncoder as getStructEncoder14,
   getU32Decoder as getU32Decoder2,
   getU32Encoder as getU32Encoder2,
-  getU64Decoder as getU64Decoder7,
-  getU64Encoder as getU64Encoder7,
+  getU64Decoder as getU64Decoder6,
+  getU64Encoder as getU64Encoder6,
   getU8Decoder as getU8Decoder6,
   getU8Encoder as getU8Encoder6
 } from "@solana/kit";
 function getNodeRefEncoder() {
-  return getStructEncoder12([
+  return getStructEncoder14([
     ["offset", getU32Encoder2()],
-    ["currentTotalRewards", getU64Encoder7()],
+    ["currentTotalRewards", getU64Encoder6()],
     ["vote", getU8Encoder6()]
   ]);
 }
 function getNodeRefDecoder() {
-  return getStructDecoder12([
+  return getStructDecoder14([
     ["offset", getU32Decoder2()],
-    ["currentTotalRewards", getU64Decoder7()],
+    ["currentTotalRewards", getU64Decoder6()],
     ["vote", getU8Decoder6()]
   ]);
 }
 function getNodeRefCodec() {
-  return combineCodec16(getNodeRefEncoder(), getNodeRefDecoder());
+  return combineCodec18(getNodeRefEncoder(), getNodeRefDecoder());
 }
 
 // src/generated/types/offChainCircuitSource.ts
 import {
   addDecoderSizePrefix,
   addEncoderSizePrefix,
-  combineCodec as combineCodec17,
+  combineCodec as combineCodec19,
   getArrayDecoder as getArrayDecoder6,
   getArrayEncoder as getArrayEncoder6,
-  getStructDecoder as getStructDecoder13,
-  getStructEncoder as getStructEncoder13,
+  getStructDecoder as getStructDecoder15,
+  getStructEncoder as getStructEncoder15,
   getU32Decoder as getU32Decoder3,
   getU32Encoder as getU32Encoder3,
   getU8Decoder as getU8Decoder7,
@@ -677,19 +727,19 @@ import {
   getUtf8Encoder
 } from "@solana/kit";
 function getOffChainCircuitSourceEncoder() {
-  return getStructEncoder13([
+  return getStructEncoder15([
     ["source", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder3())],
     ["hash", getArrayEncoder6(getU8Encoder7(), { size: 32 })]
   ]);
 }
 function getOffChainCircuitSourceDecoder() {
-  return getStructDecoder13([
+  return getStructDecoder15([
     ["source", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder3())],
     ["hash", getArrayDecoder6(getU8Decoder7(), { size: 32 })]
   ]);
 }
 function getOffChainCircuitSourceCodec() {
-  return combineCodec17(
+  return combineCodec19(
     getOffChainCircuitSourceEncoder(),
     getOffChainCircuitSourceDecoder()
   );
@@ -697,28 +747,28 @@ function getOffChainCircuitSourceCodec() {
 
 // src/generated/types/onChainCircuitSource.ts
 import {
-  combineCodec as combineCodec18,
-  getAddressDecoder as getAddressDecoder6,
-  getAddressEncoder as getAddressEncoder6,
+  combineCodec as combineCodec20,
+  getAddressDecoder as getAddressDecoder8,
+  getAddressEncoder as getAddressEncoder8,
   getBooleanDecoder as getBooleanDecoder2,
   getBooleanEncoder as getBooleanEncoder2,
-  getStructDecoder as getStructDecoder14,
-  getStructEncoder as getStructEncoder14
+  getStructDecoder as getStructDecoder16,
+  getStructEncoder as getStructEncoder16
 } from "@solana/kit";
 function getOnChainCircuitSourceEncoder() {
-  return getStructEncoder14([
+  return getStructEncoder16([
     ["isCompleted", getBooleanEncoder2()],
-    ["uploadAuth", getAddressEncoder6()]
+    ["uploadAuth", getAddressEncoder8()]
   ]);
 }
 function getOnChainCircuitSourceDecoder() {
-  return getStructDecoder14([
+  return getStructDecoder16([
     ["isCompleted", getBooleanDecoder2()],
-    ["uploadAuth", getAddressDecoder6()]
+    ["uploadAuth", getAddressDecoder8()]
   ]);
 }
 function getOnChainCircuitSourceCodec() {
-  return combineCodec18(
+  return combineCodec20(
     getOnChainCircuitSourceEncoder(),
     getOnChainCircuitSourceDecoder()
   );
@@ -726,7 +776,7 @@ function getOnChainCircuitSourceCodec() {
 
 // src/generated/types/output.ts
 import {
-  combineCodec as combineCodec19,
+  combineCodec as combineCodec21,
   getEnumDecoder as getEnumDecoder3,
   getEnumEncoder as getEnumEncoder3
 } from "@solana/kit";
@@ -755,12 +805,12 @@ function getOutputDecoder() {
   return getEnumDecoder3(Output);
 }
 function getOutputCodec() {
-  return combineCodec19(getOutputEncoder(), getOutputDecoder());
+  return combineCodec21(getOutputEncoder(), getOutputDecoder());
 }
 
 // src/generated/types/parameter.ts
 import {
-  combineCodec as combineCodec20,
+  combineCodec as combineCodec22,
   getEnumDecoder as getEnumDecoder4,
   getEnumEncoder as getEnumEncoder4
 } from "@solana/kit";
@@ -790,60 +840,56 @@ function getParameterDecoder() {
   return getEnumDecoder4(Parameter);
 }
 function getParameterCodec() {
-  return combineCodec20(getParameterEncoder(), getParameterDecoder());
+  return combineCodec22(getParameterEncoder(), getParameterDecoder());
 }
 
-// src/generated/types/revealPeriodExtendedEvent.ts
+// src/generated/types/revealPeriodEndedEvent.ts
 import {
-  combineCodec as combineCodec21,
-  getAddressDecoder as getAddressDecoder7,
-  getAddressEncoder as getAddressEncoder7,
-  getI64Decoder as getI64Decoder5,
-  getI64Encoder as getI64Encoder5,
-  getStructDecoder as getStructDecoder15,
-  getStructEncoder as getStructEncoder15,
-  getU64Decoder as getU64Decoder8,
-  getU64Encoder as getU64Encoder8
+  combineCodec as combineCodec23,
+  getAddressDecoder as getAddressDecoder9,
+  getAddressEncoder as getAddressEncoder9,
+  getI64Decoder as getI64Decoder7,
+  getI64Encoder as getI64Encoder7,
+  getStructDecoder as getStructDecoder17,
+  getStructEncoder as getStructEncoder17
 } from "@solana/kit";
-function getRevealPeriodExtendedEventEncoder() {
-  return getStructEncoder15([
-    ["market", getAddressEncoder7()],
-    ["authority", getAddressEncoder7()],
-    ["newTimeToReveal", getU64Encoder8()],
-    ["timestamp", getI64Encoder5()]
+function getRevealPeriodEndedEventEncoder() {
+  return getStructEncoder17([
+    ["market", getAddressEncoder9()],
+    ["authority", getAddressEncoder9()],
+    ["timestamp", getI64Encoder7()]
   ]);
 }
-function getRevealPeriodExtendedEventDecoder() {
-  return getStructDecoder15([
-    ["market", getAddressDecoder7()],
-    ["authority", getAddressDecoder7()],
-    ["newTimeToReveal", getU64Decoder8()],
-    ["timestamp", getI64Decoder5()]
+function getRevealPeriodEndedEventDecoder() {
+  return getStructDecoder17([
+    ["market", getAddressDecoder9()],
+    ["authority", getAddressDecoder9()],
+    ["timestamp", getI64Decoder7()]
   ]);
 }
-function getRevealPeriodExtendedEventCodec() {
-  return combineCodec21(
-    getRevealPeriodExtendedEventEncoder(),
-    getRevealPeriodExtendedEventDecoder()
+function getRevealPeriodEndedEventCodec() {
+  return combineCodec23(
+    getRevealPeriodEndedEventEncoder(),
+    getRevealPeriodEndedEventDecoder()
   );
 }
 
 // src/generated/types/revealStakeOutput.ts
 import {
-  combineCodec as combineCodec22,
-  getStructDecoder as getStructDecoder16,
-  getStructEncoder as getStructEncoder16,
-  getU64Decoder as getU64Decoder9,
-  getU64Encoder as getU64Encoder9
+  combineCodec as combineCodec24,
+  getStructDecoder as getStructDecoder18,
+  getStructEncoder as getStructEncoder18,
+  getU64Decoder as getU64Decoder7,
+  getU64Encoder as getU64Encoder7
 } from "@solana/kit";
 function getRevealStakeOutputEncoder() {
-  return getStructEncoder16([["field0", getU64Encoder9()]]);
+  return getStructEncoder18([["field0", getU64Encoder7()]]);
 }
 function getRevealStakeOutputDecoder() {
-  return getStructDecoder16([["field0", getU64Decoder9()]]);
+  return getStructDecoder18([["field0", getU64Decoder7()]]);
 }
 function getRevealStakeOutputCodec() {
-  return combineCodec22(
+  return combineCodec24(
     getRevealStakeOutputEncoder(),
     getRevealStakeOutputDecoder()
   );
@@ -851,40 +897,40 @@ function getRevealStakeOutputCodec() {
 
 // src/generated/types/rewardAddedEvent.ts
 import {
-  combineCodec as combineCodec23,
-  getAddressDecoder as getAddressDecoder8,
-  getAddressEncoder as getAddressEncoder8,
+  combineCodec as combineCodec25,
+  getAddressDecoder as getAddressDecoder10,
+  getAddressEncoder as getAddressEncoder10,
   getBooleanDecoder as getBooleanDecoder3,
   getBooleanEncoder as getBooleanEncoder3,
-  getI64Decoder as getI64Decoder6,
-  getI64Encoder as getI64Encoder6,
-  getStructDecoder as getStructDecoder17,
-  getStructEncoder as getStructEncoder17,
-  getU64Decoder as getU64Decoder10,
-  getU64Encoder as getU64Encoder10
+  getI64Decoder as getI64Decoder8,
+  getI64Encoder as getI64Encoder8,
+  getStructDecoder as getStructDecoder19,
+  getStructEncoder as getStructEncoder19,
+  getU64Decoder as getU64Decoder8,
+  getU64Encoder as getU64Encoder8
 } from "@solana/kit";
 function getRewardAddedEventEncoder() {
-  return getStructEncoder17([
-    ["market", getAddressEncoder8()],
-    ["sponsor", getAddressEncoder8()],
-    ["amount", getU64Encoder10()],
-    ["totalRewardAmount", getU64Encoder10()],
+  return getStructEncoder19([
+    ["market", getAddressEncoder10()],
+    ["sponsor", getAddressEncoder10()],
+    ["amount", getU64Encoder8()],
+    ["totalRewardAmount", getU64Encoder8()],
     ["locked", getBooleanEncoder3()],
-    ["timestamp", getI64Encoder6()]
+    ["timestamp", getI64Encoder8()]
   ]);
 }
 function getRewardAddedEventDecoder() {
-  return getStructDecoder17([
-    ["market", getAddressDecoder8()],
-    ["sponsor", getAddressDecoder8()],
-    ["amount", getU64Decoder10()],
-    ["totalRewardAmount", getU64Decoder10()],
+  return getStructDecoder19([
+    ["market", getAddressDecoder10()],
+    ["sponsor", getAddressDecoder10()],
+    ["amount", getU64Decoder8()],
+    ["totalRewardAmount", getU64Decoder8()],
     ["locked", getBooleanDecoder3()],
-    ["timestamp", getI64Decoder6()]
+    ["timestamp", getI64Decoder8()]
   ]);
 }
 function getRewardAddedEventCodec() {
-  return combineCodec23(
+  return combineCodec25(
     getRewardAddedEventEncoder(),
     getRewardAddedEventDecoder()
   );
@@ -892,50 +938,50 @@ function getRewardAddedEventCodec() {
 
 // src/generated/types/rewardClaimedEvent.ts
 import {
-  combineCodec as combineCodec24,
-  getAddressDecoder as getAddressDecoder9,
-  getAddressEncoder as getAddressEncoder9,
-  getI64Decoder as getI64Decoder7,
-  getI64Encoder as getI64Encoder7,
-  getStructDecoder as getStructDecoder18,
-  getStructEncoder as getStructEncoder18,
+  combineCodec as combineCodec26,
+  getAddressDecoder as getAddressDecoder11,
+  getAddressEncoder as getAddressEncoder11,
+  getI64Decoder as getI64Decoder9,
+  getI64Encoder as getI64Encoder9,
+  getStructDecoder as getStructDecoder20,
+  getStructEncoder as getStructEncoder20,
   getU32Decoder as getU32Decoder4,
   getU32Encoder as getU32Encoder4,
-  getU64Decoder as getU64Decoder11,
-  getU64Encoder as getU64Encoder11
+  getU64Decoder as getU64Decoder9,
+  getU64Encoder as getU64Encoder9
 } from "@solana/kit";
 function getRewardClaimedEventEncoder() {
-  return getStructEncoder18([
-    ["owner", getAddressEncoder9()],
-    ["market", getAddressEncoder9()],
-    ["stakeAccount", getAddressEncoder9()],
+  return getStructEncoder20([
+    ["owner", getAddressEncoder11()],
+    ["market", getAddressEncoder11()],
+    ["stakeAccount", getAddressEncoder11()],
     ["stakeAccountId", getU32Encoder4()],
-    ["optionId", getU64Encoder11()],
-    ["rewardAmount", getU64Encoder11()],
-    ["stakedAtTimestamp", getU64Encoder11()],
-    ["unstakedAtTimestamp", getU64Encoder11()],
-    ["stakeAmount", getU64Encoder11()],
-    ["score", getU64Encoder11()],
-    ["timestamp", getI64Encoder7()]
+    ["optionId", getU64Encoder9()],
+    ["rewardAmount", getU64Encoder9()],
+    ["stakedAtTimestamp", getU64Encoder9()],
+    ["unstakedAtTimestamp", getU64Encoder9()],
+    ["stakeAmount", getU64Encoder9()],
+    ["score", getU64Encoder9()],
+    ["timestamp", getI64Encoder9()]
   ]);
 }
 function getRewardClaimedEventDecoder() {
-  return getStructDecoder18([
-    ["owner", getAddressDecoder9()],
-    ["market", getAddressDecoder9()],
-    ["stakeAccount", getAddressDecoder9()],
+  return getStructDecoder20([
+    ["owner", getAddressDecoder11()],
+    ["market", getAddressDecoder11()],
+    ["stakeAccount", getAddressDecoder11()],
     ["stakeAccountId", getU32Decoder4()],
-    ["optionId", getU64Decoder11()],
-    ["rewardAmount", getU64Decoder11()],
-    ["stakedAtTimestamp", getU64Decoder11()],
-    ["unstakedAtTimestamp", getU64Decoder11()],
-    ["stakeAmount", getU64Decoder11()],
-    ["score", getU64Decoder11()],
-    ["timestamp", getI64Decoder7()]
+    ["optionId", getU64Decoder9()],
+    ["rewardAmount", getU64Decoder9()],
+    ["stakedAtTimestamp", getU64Decoder9()],
+    ["unstakedAtTimestamp", getU64Decoder9()],
+    ["stakeAmount", getU64Decoder9()],
+    ["score", getU64Decoder9()],
+    ["timestamp", getI64Decoder9()]
   ]);
 }
 function getRewardClaimedEventCodec() {
-  return combineCodec24(
+  return combineCodec26(
     getRewardClaimedEventEncoder(),
     getRewardClaimedEventDecoder()
   );
@@ -943,36 +989,36 @@ function getRewardClaimedEventCodec() {
 
 // src/generated/types/rewardWithdrawnEvent.ts
 import {
-  combineCodec as combineCodec25,
-  getAddressDecoder as getAddressDecoder10,
-  getAddressEncoder as getAddressEncoder10,
-  getI64Decoder as getI64Decoder8,
-  getI64Encoder as getI64Encoder8,
-  getStructDecoder as getStructDecoder19,
-  getStructEncoder as getStructEncoder19,
-  getU64Decoder as getU64Decoder12,
-  getU64Encoder as getU64Encoder12
+  combineCodec as combineCodec27,
+  getAddressDecoder as getAddressDecoder12,
+  getAddressEncoder as getAddressEncoder12,
+  getI64Decoder as getI64Decoder10,
+  getI64Encoder as getI64Encoder10,
+  getStructDecoder as getStructDecoder21,
+  getStructEncoder as getStructEncoder21,
+  getU64Decoder as getU64Decoder10,
+  getU64Encoder as getU64Encoder10
 } from "@solana/kit";
 function getRewardWithdrawnEventEncoder() {
-  return getStructEncoder19([
-    ["market", getAddressEncoder10()],
-    ["sponsor", getAddressEncoder10()],
-    ["rewardAmount", getU64Encoder12()],
-    ["refundTokenAccount", getAddressEncoder10()],
-    ["timestamp", getI64Encoder8()]
+  return getStructEncoder21([
+    ["market", getAddressEncoder12()],
+    ["sponsor", getAddressEncoder12()],
+    ["rewardAmount", getU64Encoder10()],
+    ["refundTokenAccount", getAddressEncoder12()],
+    ["timestamp", getI64Encoder10()]
   ]);
 }
 function getRewardWithdrawnEventDecoder() {
-  return getStructDecoder19([
-    ["market", getAddressDecoder10()],
-    ["sponsor", getAddressDecoder10()],
-    ["rewardAmount", getU64Decoder12()],
-    ["refundTokenAccount", getAddressDecoder10()],
-    ["timestamp", getI64Decoder8()]
+  return getStructDecoder21([
+    ["market", getAddressDecoder12()],
+    ["sponsor", getAddressDecoder12()],
+    ["rewardAmount", getU64Decoder10()],
+    ["refundTokenAccount", getAddressDecoder12()],
+    ["timestamp", getI64Decoder10()]
   ]);
 }
 function getRewardWithdrawnEventCodec() {
-  return combineCodec25(
+  return combineCodec27(
     getRewardWithdrawnEventEncoder(),
     getRewardWithdrawnEventDecoder()
   );
@@ -980,36 +1026,36 @@ function getRewardWithdrawnEventCodec() {
 
 // src/generated/types/stakeAccountInitializedEvent.ts
 import {
-  combineCodec as combineCodec26,
-  getAddressDecoder as getAddressDecoder11,
-  getAddressEncoder as getAddressEncoder11,
-  getI64Decoder as getI64Decoder9,
-  getI64Encoder as getI64Encoder9,
-  getStructDecoder as getStructDecoder20,
-  getStructEncoder as getStructEncoder20,
+  combineCodec as combineCodec28,
+  getAddressDecoder as getAddressDecoder13,
+  getAddressEncoder as getAddressEncoder13,
+  getI64Decoder as getI64Decoder11,
+  getI64Encoder as getI64Encoder11,
+  getStructDecoder as getStructDecoder22,
+  getStructEncoder as getStructEncoder22,
   getU32Decoder as getU32Decoder5,
   getU32Encoder as getU32Encoder5
 } from "@solana/kit";
 function getStakeAccountInitializedEventEncoder() {
-  return getStructEncoder20([
-    ["stakeAccount", getAddressEncoder11()],
-    ["owner", getAddressEncoder11()],
-    ["market", getAddressEncoder11()],
+  return getStructEncoder22([
+    ["stakeAccount", getAddressEncoder13()],
+    ["owner", getAddressEncoder13()],
+    ["market", getAddressEncoder13()],
     ["accountId", getU32Encoder5()],
-    ["timestamp", getI64Encoder9()]
+    ["timestamp", getI64Encoder11()]
   ]);
 }
 function getStakeAccountInitializedEventDecoder() {
-  return getStructDecoder20([
-    ["stakeAccount", getAddressDecoder11()],
-    ["owner", getAddressDecoder11()],
-    ["market", getAddressDecoder11()],
+  return getStructDecoder22([
+    ["stakeAccount", getAddressDecoder13()],
+    ["owner", getAddressDecoder13()],
+    ["market", getAddressDecoder13()],
     ["accountId", getU32Decoder5()],
-    ["timestamp", getI64Decoder9()]
+    ["timestamp", getI64Decoder11()]
   ]);
 }
 function getStakeAccountInitializedEventCodec() {
-  return combineCodec26(
+  return combineCodec28(
     getStakeAccountInitializedEventEncoder(),
     getStakeAccountInitializedEventDecoder()
   );
@@ -1017,29 +1063,29 @@ function getStakeAccountInitializedEventCodec() {
 
 // src/generated/types/stakedEvent.ts
 import {
-  combineCodec as combineCodec27,
-  getAddressDecoder as getAddressDecoder12,
-  getAddressEncoder as getAddressEncoder12,
+  combineCodec as combineCodec29,
+  getAddressDecoder as getAddressDecoder14,
+  getAddressEncoder as getAddressEncoder14,
   getArrayDecoder as getArrayDecoder7,
   getArrayEncoder as getArrayEncoder7,
-  getI64Decoder as getI64Decoder10,
-  getI64Encoder as getI64Encoder10,
-  getStructDecoder as getStructDecoder21,
-  getStructEncoder as getStructEncoder21,
+  getI64Decoder as getI64Decoder12,
+  getI64Encoder as getI64Encoder12,
+  getStructDecoder as getStructDecoder23,
+  getStructEncoder as getStructEncoder23,
   getU128Decoder,
   getU128Encoder,
   getU32Decoder as getU32Decoder6,
   getU32Encoder as getU32Encoder6,
-  getU64Decoder as getU64Decoder13,
-  getU64Encoder as getU64Encoder13,
+  getU64Decoder as getU64Decoder11,
+  getU64Encoder as getU64Encoder11,
   getU8Decoder as getU8Decoder8,
   getU8Encoder as getU8Encoder8
 } from "@solana/kit";
 function getStakedEventEncoder() {
-  return getStructEncoder21([
-    ["user", getAddressEncoder12()],
-    ["market", getAddressEncoder12()],
-    ["stakeAccount", getAddressEncoder12()],
+  return getStructEncoder23([
+    ["user", getAddressEncoder14()],
+    ["market", getAddressEncoder14()],
+    ["stakeAccount", getAddressEncoder14()],
     ["stakeAccountId", getU32Encoder6()],
     ["stakeEncryptedOption", getArrayEncoder7(getU8Encoder8(), { size: 32 })],
     ["stakeStateNonce", getU128Encoder()],
@@ -1048,15 +1094,15 @@ function getStakedEventEncoder() {
       getArrayEncoder7(getU8Encoder8(), { size: 32 })
     ],
     ["stakeStateDisclosureNonce", getU128Encoder()],
-    ["amount", getU64Encoder13()],
-    ["timestamp", getI64Encoder10()]
+    ["amount", getU64Encoder11()],
+    ["timestamp", getI64Encoder12()]
   ]);
 }
 function getStakedEventDecoder() {
-  return getStructDecoder21([
-    ["user", getAddressDecoder12()],
-    ["market", getAddressDecoder12()],
-    ["stakeAccount", getAddressDecoder12()],
+  return getStructDecoder23([
+    ["user", getAddressDecoder14()],
+    ["market", getAddressDecoder14()],
+    ["stakeAccount", getAddressDecoder14()],
     ["stakeAccountId", getU32Decoder6()],
     ["stakeEncryptedOption", getArrayDecoder7(getU8Decoder8(), { size: 32 })],
     ["stakeStateNonce", getU128Decoder()],
@@ -1065,47 +1111,47 @@ function getStakedEventDecoder() {
       getArrayDecoder7(getU8Decoder8(), { size: 32 })
     ],
     ["stakeStateDisclosureNonce", getU128Decoder()],
-    ["amount", getU64Decoder13()],
-    ["timestamp", getI64Decoder10()]
+    ["amount", getU64Decoder11()],
+    ["timestamp", getI64Decoder12()]
   ]);
 }
 function getStakedEventCodec() {
-  return combineCodec27(getStakedEventEncoder(), getStakedEventDecoder());
+  return combineCodec29(getStakedEventEncoder(), getStakedEventDecoder());
 }
 
 // src/generated/types/stakeOutput.ts
 import {
-  combineCodec as combineCodec28,
-  getStructDecoder as getStructDecoder22,
-  getStructEncoder as getStructEncoder22
+  combineCodec as combineCodec30,
+  getStructDecoder as getStructDecoder24,
+  getStructEncoder as getStructEncoder24
 } from "@solana/kit";
 function getStakeOutputEncoder() {
-  return getStructEncoder22([["field0", getStakeOutputStruct0Encoder()]]);
+  return getStructEncoder24([["field0", getStakeOutputStruct0Encoder()]]);
 }
 function getStakeOutputDecoder() {
-  return getStructDecoder22([["field0", getStakeOutputStruct0Decoder()]]);
+  return getStructDecoder24([["field0", getStakeOutputStruct0Decoder()]]);
 }
 function getStakeOutputCodec() {
-  return combineCodec28(getStakeOutputEncoder(), getStakeOutputDecoder());
+  return combineCodec30(getStakeOutputEncoder(), getStakeOutputDecoder());
 }
 
 // src/generated/types/stakeOutputStruct0.ts
 import {
-  combineCodec as combineCodec29,
+  combineCodec as combineCodec31,
   getArrayDecoder as getArrayDecoder8,
   getArrayEncoder as getArrayEncoder8,
-  getStructDecoder as getStructDecoder23,
-  getStructEncoder as getStructEncoder23,
+  getStructDecoder as getStructDecoder25,
+  getStructEncoder as getStructEncoder25,
   getU128Decoder as getU128Decoder2,
   getU128Encoder as getU128Encoder2,
   getU8Decoder as getU8Decoder9,
   getU8Encoder as getU8Encoder9
 } from "@solana/kit";
 function getStakeOutputStruct0Encoder() {
-  return getStructEncoder23([
+  return getStructEncoder25([
     [
       "field0",
-      getStructEncoder23([
+      getStructEncoder25([
         ["encryptionKey", getArrayEncoder8(getU8Encoder9(), { size: 32 })],
         ["nonce", getU128Encoder2()],
         [
@@ -1118,7 +1164,7 @@ function getStakeOutputStruct0Encoder() {
     ],
     [
       "field1",
-      getStructEncoder23([
+      getStructEncoder25([
         ["encryptionKey", getArrayEncoder8(getU8Encoder9(), { size: 32 })],
         ["nonce", getU128Encoder2()],
         [
@@ -1132,10 +1178,10 @@ function getStakeOutputStruct0Encoder() {
   ]);
 }
 function getStakeOutputStruct0Decoder() {
-  return getStructDecoder23([
+  return getStructDecoder25([
     [
       "field0",
-      getStructDecoder23([
+      getStructDecoder25([
         ["encryptionKey", getArrayDecoder8(getU8Decoder9(), { size: 32 })],
         ["nonce", getU128Decoder2()],
         [
@@ -1148,7 +1194,7 @@ function getStakeOutputStruct0Decoder() {
     ],
     [
       "field1",
-      getStructDecoder23([
+      getStructDecoder25([
         ["encryptionKey", getArrayDecoder8(getU8Decoder9(), { size: 32 })],
         ["nonce", getU128Decoder2()],
         [
@@ -1162,7 +1208,7 @@ function getStakeOutputStruct0Decoder() {
   ]);
 }
 function getStakeOutputStruct0Codec() {
-  return combineCodec29(
+  return combineCodec31(
     getStakeOutputStruct0Encoder(),
     getStakeOutputStruct0Decoder()
   );
@@ -1170,40 +1216,40 @@ function getStakeOutputStruct0Codec() {
 
 // src/generated/types/stakeReclaimedEvent.ts
 import {
-  combineCodec as combineCodec30,
-  getAddressDecoder as getAddressDecoder13,
-  getAddressEncoder as getAddressEncoder13,
-  getI64Decoder as getI64Decoder11,
-  getI64Encoder as getI64Encoder11,
-  getStructDecoder as getStructDecoder24,
-  getStructEncoder as getStructEncoder24,
+  combineCodec as combineCodec32,
+  getAddressDecoder as getAddressDecoder15,
+  getAddressEncoder as getAddressEncoder15,
+  getI64Decoder as getI64Decoder13,
+  getI64Encoder as getI64Encoder13,
+  getStructDecoder as getStructDecoder26,
+  getStructEncoder as getStructEncoder26,
   getU32Decoder as getU32Decoder7,
   getU32Encoder as getU32Encoder7,
-  getU64Decoder as getU64Decoder14,
-  getU64Encoder as getU64Encoder14
+  getU64Decoder as getU64Decoder12,
+  getU64Encoder as getU64Encoder12
 } from "@solana/kit";
 function getStakeReclaimedEventEncoder() {
-  return getStructEncoder24([
-    ["owner", getAddressEncoder13()],
-    ["market", getAddressEncoder13()],
-    ["stakeAccount", getAddressEncoder13()],
+  return getStructEncoder26([
+    ["owner", getAddressEncoder15()],
+    ["market", getAddressEncoder15()],
+    ["stakeAccount", getAddressEncoder15()],
     ["stakeAccountId", getU32Encoder7()],
-    ["amount", getU64Encoder14()],
-    ["timestamp", getI64Encoder11()]
+    ["amount", getU64Encoder12()],
+    ["timestamp", getI64Encoder13()]
   ]);
 }
 function getStakeReclaimedEventDecoder() {
-  return getStructDecoder24([
-    ["owner", getAddressDecoder13()],
-    ["market", getAddressDecoder13()],
-    ["stakeAccount", getAddressDecoder13()],
+  return getStructDecoder26([
+    ["owner", getAddressDecoder15()],
+    ["market", getAddressDecoder15()],
+    ["stakeAccount", getAddressDecoder15()],
     ["stakeAccountId", getU32Decoder7()],
-    ["amount", getU64Decoder14()],
-    ["timestamp", getI64Decoder11()]
+    ["amount", getU64Decoder12()],
+    ["timestamp", getI64Decoder13()]
   ]);
 }
 function getStakeReclaimedEventCodec() {
-  return combineCodec30(
+  return combineCodec32(
     getStakeReclaimedEventEncoder(),
     getStakeReclaimedEventDecoder()
   );
@@ -1211,42 +1257,42 @@ function getStakeReclaimedEventCodec() {
 
 // src/generated/types/stakeRevealedEvent.ts
 import {
-  combineCodec as combineCodec31,
-  getAddressDecoder as getAddressDecoder14,
-  getAddressEncoder as getAddressEncoder14,
-  getI64Decoder as getI64Decoder12,
-  getI64Encoder as getI64Encoder12,
-  getStructDecoder as getStructDecoder25,
-  getStructEncoder as getStructEncoder25,
+  combineCodec as combineCodec33,
+  getAddressDecoder as getAddressDecoder16,
+  getAddressEncoder as getAddressEncoder16,
+  getI64Decoder as getI64Decoder14,
+  getI64Encoder as getI64Encoder14,
+  getStructDecoder as getStructDecoder27,
+  getStructEncoder as getStructEncoder27,
   getU32Decoder as getU32Decoder8,
   getU32Encoder as getU32Encoder8,
-  getU64Decoder as getU64Decoder15,
-  getU64Encoder as getU64Encoder15
+  getU64Decoder as getU64Decoder13,
+  getU64Encoder as getU64Encoder13
 } from "@solana/kit";
 function getStakeRevealedEventEncoder() {
-  return getStructEncoder25([
-    ["user", getAddressEncoder14()],
-    ["market", getAddressEncoder14()],
-    ["stakeAccount", getAddressEncoder14()],
+  return getStructEncoder27([
+    ["user", getAddressEncoder16()],
+    ["market", getAddressEncoder16()],
+    ["stakeAccount", getAddressEncoder16()],
     ["stakeAccountId", getU32Encoder8()],
-    ["stakeAmount", getU64Encoder15()],
-    ["selectedOption", getU64Encoder15()],
-    ["timestamp", getI64Encoder12()]
+    ["stakeAmount", getU64Encoder13()],
+    ["selectedOption", getU64Encoder13()],
+    ["timestamp", getI64Encoder14()]
   ]);
 }
 function getStakeRevealedEventDecoder() {
-  return getStructDecoder25([
-    ["user", getAddressDecoder14()],
-    ["market", getAddressDecoder14()],
-    ["stakeAccount", getAddressDecoder14()],
+  return getStructDecoder27([
+    ["user", getAddressDecoder16()],
+    ["market", getAddressDecoder16()],
+    ["stakeAccount", getAddressDecoder16()],
     ["stakeAccountId", getU32Decoder8()],
-    ["stakeAmount", getU64Decoder15()],
-    ["selectedOption", getU64Decoder15()],
-    ["timestamp", getI64Decoder12()]
+    ["stakeAmount", getU64Decoder13()],
+    ["selectedOption", getU64Decoder13()],
+    ["timestamp", getI64Decoder14()]
   ]);
 }
 function getStakeRevealedEventCodec() {
-  return combineCodec31(
+  return combineCodec33(
     getStakeRevealedEventEncoder(),
     getStakeRevealedEventDecoder()
   );
@@ -1254,42 +1300,42 @@ function getStakeRevealedEventCodec() {
 
 // src/generated/types/stuckStakeClosedEvent.ts
 import {
-  combineCodec as combineCodec32,
-  getAddressDecoder as getAddressDecoder15,
-  getAddressEncoder as getAddressEncoder15,
-  getI64Decoder as getI64Decoder13,
-  getI64Encoder as getI64Encoder13,
-  getStructDecoder as getStructDecoder26,
-  getStructEncoder as getStructEncoder26,
+  combineCodec as combineCodec34,
+  getAddressDecoder as getAddressDecoder17,
+  getAddressEncoder as getAddressEncoder17,
+  getI64Decoder as getI64Decoder15,
+  getI64Encoder as getI64Encoder15,
+  getStructDecoder as getStructDecoder28,
+  getStructEncoder as getStructEncoder28,
   getU32Decoder as getU32Decoder9,
   getU32Encoder as getU32Encoder9,
-  getU64Decoder as getU64Decoder16,
-  getU64Encoder as getU64Encoder16
+  getU64Decoder as getU64Decoder14,
+  getU64Encoder as getU64Encoder14
 } from "@solana/kit";
 function getStuckStakeClosedEventEncoder() {
-  return getStructEncoder26([
-    ["owner", getAddressEncoder15()],
-    ["market", getAddressEncoder15()],
-    ["stakeAccount", getAddressEncoder15()],
+  return getStructEncoder28([
+    ["owner", getAddressEncoder17()],
+    ["market", getAddressEncoder17()],
+    ["stakeAccount", getAddressEncoder17()],
     ["stakeAccountId", getU32Encoder9()],
-    ["refundedAmount", getU64Encoder16()],
-    ["refundedFee", getU64Encoder16()],
-    ["timestamp", getI64Encoder13()]
+    ["refundedAmount", getU64Encoder14()],
+    ["refundedFee", getU64Encoder14()],
+    ["timestamp", getI64Encoder15()]
   ]);
 }
 function getStuckStakeClosedEventDecoder() {
-  return getStructDecoder26([
-    ["owner", getAddressDecoder15()],
-    ["market", getAddressDecoder15()],
-    ["stakeAccount", getAddressDecoder15()],
+  return getStructDecoder28([
+    ["owner", getAddressDecoder17()],
+    ["market", getAddressDecoder17()],
+    ["stakeAccount", getAddressDecoder17()],
     ["stakeAccountId", getU32Decoder9()],
-    ["refundedAmount", getU64Decoder16()],
-    ["refundedFee", getU64Decoder16()],
-    ["timestamp", getI64Decoder13()]
+    ["refundedAmount", getU64Decoder14()],
+    ["refundedFee", getU64Decoder14()],
+    ["timestamp", getI64Decoder15()]
   ]);
 }
 function getStuckStakeClosedEventCodec() {
-  return combineCodec32(
+  return combineCodec34(
     getStuckStakeClosedEventEncoder(),
     getStuckStakeClosedEventDecoder()
   );
@@ -1297,48 +1343,48 @@ function getStuckStakeClosedEventCodec() {
 
 // src/generated/types/tallyIncrementedEvent.ts
 import {
-  combineCodec as combineCodec33,
-  getAddressDecoder as getAddressDecoder16,
-  getAddressEncoder as getAddressEncoder16,
-  getI64Decoder as getI64Decoder14,
-  getI64Encoder as getI64Encoder14,
-  getStructDecoder as getStructDecoder27,
-  getStructEncoder as getStructEncoder27,
+  combineCodec as combineCodec35,
+  getAddressDecoder as getAddressDecoder18,
+  getAddressEncoder as getAddressEncoder18,
+  getI64Decoder as getI64Decoder16,
+  getI64Encoder as getI64Encoder16,
+  getStructDecoder as getStructDecoder29,
+  getStructEncoder as getStructEncoder29,
   getU32Decoder as getU32Decoder10,
   getU32Encoder as getU32Encoder10,
-  getU64Decoder as getU64Decoder17,
-  getU64Encoder as getU64Encoder17
+  getU64Decoder as getU64Decoder15,
+  getU64Encoder as getU64Encoder15
 } from "@solana/kit";
 function getTallyIncrementedEventEncoder() {
-  return getStructEncoder27([
-    ["owner", getAddressEncoder16()],
-    ["market", getAddressEncoder16()],
-    ["stakeAccount", getAddressEncoder16()],
+  return getStructEncoder29([
+    ["owner", getAddressEncoder18()],
+    ["market", getAddressEncoder18()],
+    ["stakeAccount", getAddressEncoder18()],
     ["stakeAccountId", getU32Encoder10()],
-    ["optionId", getU64Encoder17()],
-    ["userStake", getU64Encoder17()],
-    ["userScore", getU64Encoder17()],
-    ["totalScore", getU64Encoder17()],
-    ["totalStake", getU64Encoder17()],
-    ["timestamp", getI64Encoder14()]
+    ["optionId", getU64Encoder15()],
+    ["userStake", getU64Encoder15()],
+    ["userScore", getU64Encoder15()],
+    ["totalScore", getU64Encoder15()],
+    ["totalStake", getU64Encoder15()],
+    ["timestamp", getI64Encoder16()]
   ]);
 }
 function getTallyIncrementedEventDecoder() {
-  return getStructDecoder27([
-    ["owner", getAddressDecoder16()],
-    ["market", getAddressDecoder16()],
-    ["stakeAccount", getAddressDecoder16()],
+  return getStructDecoder29([
+    ["owner", getAddressDecoder18()],
+    ["market", getAddressDecoder18()],
+    ["stakeAccount", getAddressDecoder18()],
     ["stakeAccountId", getU32Decoder10()],
-    ["optionId", getU64Decoder17()],
-    ["userStake", getU64Decoder17()],
-    ["userScore", getU64Decoder17()],
-    ["totalScore", getU64Decoder17()],
-    ["totalStake", getU64Decoder17()],
-    ["timestamp", getI64Decoder14()]
+    ["optionId", getU64Decoder15()],
+    ["userStake", getU64Decoder15()],
+    ["userScore", getU64Decoder15()],
+    ["totalScore", getU64Decoder15()],
+    ["totalStake", getU64Decoder15()],
+    ["timestamp", getI64Decoder16()]
   ]);
 }
 function getTallyIncrementedEventCodec() {
-  return combineCodec33(
+  return combineCodec35(
     getTallyIncrementedEventEncoder(),
     getTallyIncrementedEventDecoder()
   );
@@ -1346,92 +1392,92 @@ function getTallyIncrementedEventCodec() {
 
 // src/generated/types/timestamp.ts
 import {
-  combineCodec as combineCodec34,
-  getStructDecoder as getStructDecoder28,
-  getStructEncoder as getStructEncoder28,
-  getU64Decoder as getU64Decoder18,
-  getU64Encoder as getU64Encoder18
+  combineCodec as combineCodec36,
+  getStructDecoder as getStructDecoder30,
+  getStructEncoder as getStructEncoder30,
+  getU64Decoder as getU64Decoder16,
+  getU64Encoder as getU64Encoder16
 } from "@solana/kit";
 function getTimestampEncoder() {
-  return getStructEncoder28([["timestamp", getU64Encoder18()]]);
+  return getStructEncoder30([["timestamp", getU64Encoder16()]]);
 }
 function getTimestampDecoder() {
-  return getStructDecoder28([["timestamp", getU64Decoder18()]]);
-}
-function getTimestampCodec() {
-  return combineCodec34(getTimestampEncoder(), getTimestampDecoder());
+  return getStructDecoder30([["timestamp", getU64Decoder16()]]);
 }
-
-// src/generated/types/unstakedEvent.ts
-import {
-  combineCodec as combineCodec35,
-  getAddressDecoder as getAddressDecoder17,
-  getAddressEncoder as getAddressEncoder17,
-  getI64Decoder as getI64Decoder15,
-  getI64Encoder as getI64Encoder15,
-  getStructDecoder as getStructDecoder29,
-  getStructEncoder as getStructEncoder29,
+function getTimestampCodec() {
+  return combineCodec36(getTimestampEncoder(), getTimestampDecoder());
+}
+
+// src/generated/types/unstakedEvent.ts
+import {
+  combineCodec as combineCodec37,
+  getAddressDecoder as getAddressDecoder19,
+  getAddressEncoder as getAddressEncoder19,
+  getI64Decoder as getI64Decoder17,
+  getI64Encoder as getI64Encoder17,
+  getStructDecoder as getStructDecoder31,
+  getStructEncoder as getStructEncoder31,
   getU32Decoder as getU32Decoder11,
   getU32Encoder as getU32Encoder11
 } from "@solana/kit";
 function getUnstakedEventEncoder() {
-  return getStructEncoder29([
-    ["user", getAddressEncoder17()],
-    ["market", getAddressEncoder17()],
-    ["stakeAccount", getAddressEncoder17()],
+  return getStructEncoder31([
+    ["user", getAddressEncoder19()],
+    ["market", getAddressEncoder19()],
+    ["stakeAccount", getAddressEncoder19()],
     ["stakeAccountId", getU32Encoder11()],
-    ["timestamp", getI64Encoder15()]
+    ["timestamp", getI64Encoder17()]
   ]);
 }
 function getUnstakedEventDecoder() {
-  return getStructDecoder29([
-    ["user", getAddressDecoder17()],
-    ["market", getAddressDecoder17()],
-    ["stakeAccount", getAddressDecoder17()],
+  return getStructDecoder31([
+    ["user", getAddressDecoder19()],
+    ["market", getAddressDecoder19()],
+    ["stakeAccount", getAddressDecoder19()],
     ["stakeAccountId", getU32Decoder11()],
-    ["timestamp", getI64Decoder15()]
+    ["timestamp", getI64Decoder17()]
   ]);
 }
 function getUnstakedEventCodec() {
-  return combineCodec35(getUnstakedEventEncoder(), getUnstakedEventDecoder());
+  return combineCodec37(getUnstakedEventEncoder(), getUnstakedEventDecoder());
 }
 
 // src/generated/types/unstakeInitiatedEvent.ts
 import {
-  combineCodec as combineCodec36,
-  getAddressDecoder as getAddressDecoder18,
-  getAddressEncoder as getAddressEncoder18,
-  getI64Decoder as getI64Decoder16,
-  getI64Encoder as getI64Encoder16,
-  getStructDecoder as getStructDecoder30,
-  getStructEncoder as getStructEncoder30,
+  combineCodec as combineCodec38,
+  getAddressDecoder as getAddressDecoder20,
+  getAddressEncoder as getAddressEncoder20,
+  getI64Decoder as getI64Decoder18,
+  getI64Encoder as getI64Encoder18,
+  getStructDecoder as getStructDecoder32,
+  getStructEncoder as getStructEncoder32,
   getU32Decoder as getU32Decoder12,
   getU32Encoder as getU32Encoder12,
-  getU64Decoder as getU64Decoder19,
-  getU64Encoder as getU64Encoder19
+  getU64Decoder as getU64Decoder17,
+  getU64Encoder as getU64Encoder17
 } from "@solana/kit";
 function getUnstakeInitiatedEventEncoder() {
-  return getStructEncoder30([
-    ["user", getAddressEncoder18()],
-    ["market", getAddressEncoder18()],
-    ["stakeAccount", getAddressEncoder18()],
+  return getStructEncoder32([
+    ["user", getAddressEncoder20()],
+    ["market", getAddressEncoder20()],
+    ["stakeAccount", getAddressEncoder20()],
     ["stakeAccountId", getU32Encoder12()],
-    ["unstakeableAtTimestamp", getU64Encoder19()],
-    ["timestamp", getI64Encoder16()]
+    ["unstakeableAtTimestamp", getU64Encoder17()],
+    ["timestamp", getI64Encoder18()]
   ]);
 }
 function getUnstakeInitiatedEventDecoder() {
-  return getStructDecoder30([
-    ["user", getAddressDecoder18()],
-    ["market", getAddressDecoder18()],
-    ["stakeAccount", getAddressDecoder18()],
+  return getStructDecoder32([
+    ["user", getAddressDecoder20()],
+    ["market", getAddressDecoder20()],
+    ["stakeAccount", getAddressDecoder20()],
     ["stakeAccountId", getU32Decoder12()],
-    ["unstakeableAtTimestamp", getU64Decoder19()],
-    ["timestamp", getI64Decoder16()]
+    ["unstakeableAtTimestamp", getU64Decoder17()],
+    ["timestamp", getI64Decoder18()]
   ]);
 }
 function getUnstakeInitiatedEventCodec() {
-  return combineCodec36(
+  return combineCodec38(
     getUnstakeInitiatedEventEncoder(),
     getUnstakeInitiatedEventDecoder()
   );
@@ -1439,16 +1485,16 @@ function getUnstakeInitiatedEventCodec() {
 
 // src/generated/types/utilityPubkeys.ts
 import {
-  combineCodec as combineCodec37,
+  combineCodec as combineCodec39,
   getArrayDecoder as getArrayDecoder9,
   getArrayEncoder as getArrayEncoder9,
-  getStructDecoder as getStructDecoder31,
-  getStructEncoder as getStructEncoder31,
+  getStructDecoder as getStructDecoder33,
+  getStructEncoder as getStructEncoder33,
   getU8Decoder as getU8Decoder10,
   getU8Encoder as getU8Encoder10
 } from "@solana/kit";
 function getUtilityPubkeysEncoder() {
-  return getStructEncoder31([
+  return getStructEncoder33([
     ["x25519Pubkey", getArrayEncoder9(getU8Encoder10(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayEncoder9(getU8Encoder10(), { size: 32 })],
     ["elgamalPubkey", getArrayEncoder9(getU8Encoder10(), { size: 32 })],
@@ -1456,7 +1502,7 @@ function getUtilityPubkeysEncoder() {
   ]);
 }
 function getUtilityPubkeysDecoder() {
-  return getStructDecoder31([
+  return getStructDecoder33([
     ["x25519Pubkey", getArrayDecoder9(getU8Decoder10(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayDecoder9(getU8Decoder10(), { size: 32 })],
     ["elgamalPubkey", getArrayDecoder9(getU8Decoder10(), { size: 32 })],
@@ -1464,65 +1510,65 @@ function getUtilityPubkeysDecoder() {
   ]);
 }
 function getUtilityPubkeysCodec() {
-  return combineCodec37(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
+  return combineCodec39(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
 }
 
 // src/generated/types/winningOption.ts
 import {
-  combineCodec as combineCodec38,
-  getStructDecoder as getStructDecoder32,
-  getStructEncoder as getStructEncoder32,
-  getU64Decoder as getU64Decoder20,
-  getU64Encoder as getU64Encoder20,
+  combineCodec as combineCodec40,
+  getStructDecoder as getStructDecoder34,
+  getStructEncoder as getStructEncoder34,
+  getU64Decoder as getU64Decoder18,
+  getU64Encoder as getU64Encoder18,
   getU8Decoder as getU8Decoder11,
   getU8Encoder as getU8Encoder11
 } from "@solana/kit";
 function getWinningOptionEncoder() {
-  return getStructEncoder32([
-    ["optionId", getU64Encoder20()],
+  return getStructEncoder34([
+    ["optionId", getU64Encoder18()],
     ["rewardPercentage", getU8Encoder11()]
   ]);
 }
 function getWinningOptionDecoder() {
-  return getStructDecoder32([
-    ["optionId", getU64Decoder20()],
+  return getStructDecoder34([
+    ["optionId", getU64Decoder18()],
     ["rewardPercentage", getU8Decoder11()]
   ]);
 }
 function getWinningOptionCodec() {
-  return combineCodec38(getWinningOptionEncoder(), getWinningOptionDecoder());
+  return combineCodec40(getWinningOptionEncoder(), getWinningOptionDecoder());
 }
 
 // src/generated/types/winningOptionsSelectedEvent.ts
 import {
-  combineCodec as combineCodec39,
-  getAddressDecoder as getAddressDecoder19,
-  getAddressEncoder as getAddressEncoder19,
+  combineCodec as combineCodec41,
+  getAddressDecoder as getAddressDecoder21,
+  getAddressEncoder as getAddressEncoder21,
   getArrayDecoder as getArrayDecoder10,
   getArrayEncoder as getArrayEncoder10,
-  getI64Decoder as getI64Decoder17,
-  getI64Encoder as getI64Encoder17,
-  getStructDecoder as getStructDecoder33,
-  getStructEncoder as getStructEncoder33
+  getI64Decoder as getI64Decoder19,
+  getI64Encoder as getI64Encoder19,
+  getStructDecoder as getStructDecoder35,
+  getStructEncoder as getStructEncoder35
 } from "@solana/kit";
 function getWinningOptionsSelectedEventEncoder() {
-  return getStructEncoder33([
-    ["market", getAddressEncoder19()],
-    ["authority", getAddressEncoder19()],
+  return getStructEncoder35([
+    ["market", getAddressEncoder21()],
+    ["authority", getAddressEncoder21()],
     ["selectedOptions", getArrayEncoder10(getWinningOptionEncoder())],
-    ["timestamp", getI64Encoder17()]
+    ["timestamp", getI64Encoder19()]
   ]);
 }
 function getWinningOptionsSelectedEventDecoder() {
-  return getStructDecoder33([
-    ["market", getAddressDecoder19()],
-    ["authority", getAddressDecoder19()],
+  return getStructDecoder35([
+    ["market", getAddressDecoder21()],
+    ["authority", getAddressDecoder21()],
     ["selectedOptions", getArrayDecoder10(getWinningOptionDecoder())],
-    ["timestamp", getI64Decoder17()]
+    ["timestamp", getI64Decoder19()]
   ]);
 }
 function getWinningOptionsSelectedEventCodec() {
-  return combineCodec39(
+  return combineCodec41(
     getWinningOptionsSelectedEventEncoder(),
     getWinningOptionsSelectedEventDecoder()
   );
@@ -1546,7 +1592,7 @@ function getClockAccountDiscriminatorBytes() {
 }
 function getClockAccountEncoder() {
   return transformEncoder3(
-    getStructEncoder34([
+    getStructEncoder36([
       ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
       ["startEpoch", getEpochEncoder()],
       ["currentEpoch", getEpochEncoder()],
@@ -1557,7 +1603,7 @@ function getClockAccountEncoder() {
   );
 }
 function getClockAccountDecoder() {
-  return getStructDecoder34([
+  return getStructDecoder36([
     ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
     ["startEpoch", getEpochDecoder()],
     ["currentEpoch", getEpochDecoder()],
@@ -1566,7 +1612,7 @@ function getClockAccountDecoder() {
   ]);
 }
 function getClockAccountCodec() {
-  return combineCodec40(getClockAccountEncoder(), getClockAccountDecoder());
+  return combineCodec42(getClockAccountEncoder(), getClockAccountDecoder());
 }
 function decodeClockAccount(encodedAccount) {
   return decodeAccount3(
@@ -1597,14 +1643,14 @@ async function fetchAllMaybeClockAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists4,
   assertAccountsExist as assertAccountsExist4,
-  combineCodec as combineCodec41,
+  combineCodec as combineCodec43,
   decodeAccount as decodeAccount4,
   fetchEncodedAccount as fetchEncodedAccount4,
   fetchEncodedAccounts as fetchEncodedAccounts4,
   fixDecoderSize as fixDecoderSize4,
   fixEncoderSize as fixEncoderSize4,
-  getAddressDecoder as getAddressDecoder20,
-  getAddressEncoder as getAddressEncoder20,
+  getAddressDecoder as getAddressDecoder22,
+  getAddressEncoder as getAddressEncoder22,
   getArrayDecoder as getArrayDecoder11,
   getArrayEncoder as getArrayEncoder11,
   getBooleanDecoder as getBooleanDecoder4,
@@ -1615,16 +1661,16 @@ import {
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder2,
   getOptionDecoder as getOptionDecoder2,
   getOptionEncoder as getOptionEncoder2,
-  getStructDecoder as getStructDecoder35,
-  getStructEncoder as getStructEncoder35,
+  getStructDecoder as getStructDecoder37,
+  getStructEncoder as getStructEncoder37,
   getTupleDecoder as getTupleDecoder4,
   getTupleEncoder as getTupleEncoder4,
   getU16Decoder as getU16Decoder2,
   getU16Encoder as getU16Encoder2,
   getU32Decoder as getU32Decoder13,
   getU32Encoder as getU32Encoder13,
-  getU64Decoder as getU64Decoder21,
-  getU64Encoder as getU64Encoder21,
+  getU64Decoder as getU64Decoder19,
+  getU64Encoder as getU64Encoder19,
   getU8Decoder as getU8Decoder13,
   getU8Encoder as getU8Encoder13,
   transformEncoder as transformEncoder4
@@ -1644,15 +1690,15 @@ function getClusterDiscriminatorBytes() {
 }
 function getClusterEncoder() {
   return transformEncoder4(
-    getStructEncoder35([
+    getStructEncoder37([
       ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
       ["tdInfo", getOptionEncoder2(getNodeMetadataEncoder())],
-      ["authority", getOptionEncoder2(getAddressEncoder20())],
+      ["authority", getOptionEncoder2(getAddressEncoder22())],
       ["clusterSize", getU16Encoder2()],
       ["activation", getActivationEncoder()],
-      ["maxCapacity", getU64Encoder21()],
-      ["cuPrice", getU64Encoder21()],
-      ["cuPriceProposals", getArrayEncoder11(getU64Encoder21(), { size: 32 })],
+      ["maxCapacity", getU64Encoder19()],
+      ["cuPrice", getU64Encoder19()],
+      ["cuPriceProposals", getArrayEncoder11(getU64Encoder19(), { size: 32 })],
       ["lastUpdatedEpoch", getEpochEncoder()],
       ["nodes", getArrayEncoder11(getNodeRefEncoder())],
       ["pendingNodes", getArrayEncoder11(getU32Encoder13())],
@@ -1661,13 +1707,13 @@ function getClusterEncoder() {
         getDiscriminatedUnionEncoder2([
           [
             "Set",
-            getStructEncoder35([
+            getStructEncoder37([
               ["fields", getTupleEncoder4([getBN254G2BLSPublicKeyEncoder()])]
             ])
           ],
           [
             "Unset",
-            getStructEncoder35([
+            getStructEncoder37([
               [
                 "fields",
                 getTupleEncoder4([
@@ -1685,15 +1731,15 @@ function getClusterEncoder() {
   );
 }
 function getClusterDecoder() {
-  return getStructDecoder35([
+  return getStructDecoder37([
     ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
     ["tdInfo", getOptionDecoder2(getNodeMetadataDecoder())],
-    ["authority", getOptionDecoder2(getAddressDecoder20())],
+    ["authority", getOptionDecoder2(getAddressDecoder22())],
     ["clusterSize", getU16Decoder2()],
     ["activation", getActivationDecoder()],
-    ["maxCapacity", getU64Decoder21()],
-    ["cuPrice", getU64Decoder21()],
-    ["cuPriceProposals", getArrayDecoder11(getU64Decoder21(), { size: 32 })],
+    ["maxCapacity", getU64Decoder19()],
+    ["cuPrice", getU64Decoder19()],
+    ["cuPriceProposals", getArrayDecoder11(getU64Decoder19(), { size: 32 })],
     ["lastUpdatedEpoch", getEpochDecoder()],
     ["nodes", getArrayDecoder11(getNodeRefDecoder())],
     ["pendingNodes", getArrayDecoder11(getU32Decoder13())],
@@ -1702,13 +1748,13 @@ function getClusterDecoder() {
       getDiscriminatedUnionDecoder2([
         [
           "Set",
-          getStructDecoder35([
+          getStructDecoder37([
             ["fields", getTupleDecoder4([getBN254G2BLSPublicKeyDecoder()])]
           ])
         ],
         [
           "Unset",
-          getStructDecoder35([
+          getStructDecoder37([
             [
               "fields",
               getTupleDecoder4([
@@ -1724,7 +1770,7 @@ function getClusterDecoder() {
   ]);
 }
 function getClusterCodec() {
-  return combineCodec41(getClusterEncoder(), getClusterDecoder());
+  return combineCodec43(getClusterEncoder(), getClusterDecoder());
 }
 function decodeCluster(encodedAccount) {
   return decodeAccount4(
@@ -1755,22 +1801,22 @@ async function fetchAllMaybeCluster(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists5,
   assertAccountsExist as assertAccountsExist5,
-  combineCodec as combineCodec42,
+  combineCodec as combineCodec44,
   decodeAccount as decodeAccount5,
   fetchEncodedAccount as fetchEncodedAccount5,
   fetchEncodedAccounts as fetchEncodedAccounts5,
   fixDecoderSize as fixDecoderSize5,
   fixEncoderSize as fixEncoderSize5,
-  getAddressDecoder as getAddressDecoder21,
-  getAddressEncoder as getAddressEncoder21,
+  getAddressDecoder as getAddressDecoder23,
+  getAddressEncoder as getAddressEncoder23,
   getBytesDecoder as getBytesDecoder5,
   getBytesEncoder as getBytesEncoder5,
   getOptionDecoder as getOptionDecoder3,
   getOptionEncoder as getOptionEncoder3,
-  getStructDecoder as getStructDecoder36,
-  getStructEncoder as getStructEncoder36,
-  getU64Decoder as getU64Decoder22,
-  getU64Encoder as getU64Encoder22,
+  getStructDecoder as getStructDecoder38,
+  getStructEncoder as getStructEncoder38,
+  getU64Decoder as getU64Decoder20,
+  getU64Encoder as getU64Encoder20,
   getU8Decoder as getU8Decoder14,
   getU8Encoder as getU8Encoder14,
   transformEncoder as transformEncoder5
@@ -1792,10 +1838,10 @@ function getComputationDefinitionAccountDiscriminatorBytes() {
 }
 function getComputationDefinitionAccountEncoder() {
   return transformEncoder5(
-    getStructEncoder36([
+    getStructEncoder38([
       ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
-      ["finalizationAuthority", getOptionEncoder3(getAddressEncoder21())],
-      ["cuAmount", getU64Encoder22()],
+      ["finalizationAuthority", getOptionEncoder3(getAddressEncoder23())],
+      ["cuAmount", getU64Encoder20()],
       ["definition", getComputationDefinitionMetaEncoder()],
       ["circuitSource", getCircuitSourceEncoder()],
       ["bump", getU8Encoder14()]
@@ -1807,17 +1853,17 @@ function getComputationDefinitionAccountEncoder() {
   );
 }
 function getComputationDefinitionAccountDecoder() {
-  return getStructDecoder36([
+  return getStructDecoder38([
     ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
-    ["finalizationAuthority", getOptionDecoder3(getAddressDecoder21())],
-    ["cuAmount", getU64Decoder22()],
+    ["finalizationAuthority", getOptionDecoder3(getAddressDecoder23())],
+    ["cuAmount", getU64Decoder20()],
     ["definition", getComputationDefinitionMetaDecoder()],
     ["circuitSource", getCircuitSourceDecoder()],
     ["bump", getU8Decoder14()]
   ]);
 }
 function getComputationDefinitionAccountCodec() {
-  return combineCodec42(
+  return combineCodec44(
     getComputationDefinitionAccountEncoder(),
     getComputationDefinitionAccountDecoder()
   );
@@ -1861,7 +1907,7 @@ async function fetchAllMaybeComputationDefinitionAccount(rpc, addresses, config)
 import {
   assertAccountExists as assertAccountExists6,
   assertAccountsExist as assertAccountsExist6,
-  combineCodec as combineCodec43,
+  combineCodec as combineCodec45,
   decodeAccount as decodeAccount6,
   fetchEncodedAccount as fetchEncodedAccount6,
   fetchEncodedAccounts as fetchEncodedAccounts6,
@@ -1869,8 +1915,8 @@ import {
   fixEncoderSize as fixEncoderSize6,
   getBytesDecoder as getBytesDecoder6,
   getBytesEncoder as getBytesEncoder6,
-  getStructDecoder as getStructDecoder37,
-  getStructEncoder as getStructEncoder37,
+  getStructDecoder as getStructDecoder39,
+  getStructEncoder as getStructEncoder39,
   getU8Decoder as getU8Decoder15,
   getU8Encoder as getU8Encoder15,
   transformEncoder as transformEncoder6
@@ -1890,7 +1936,7 @@ function getFeePoolDiscriminatorBytes() {
 }
 function getFeePoolEncoder() {
   return transformEncoder6(
-    getStructEncoder37([
+    getStructEncoder39([
       ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
       ["bump", getU8Encoder15()]
     ]),
@@ -1898,13 +1944,13 @@ function getFeePoolEncoder() {
   );
 }
 function getFeePoolDecoder() {
-  return getStructDecoder37([
+  return getStructDecoder39([
     ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
     ["bump", getU8Decoder15()]
   ]);
 }
 function getFeePoolCodec() {
-  return combineCodec43(getFeePoolEncoder(), getFeePoolDecoder());
+  return combineCodec45(getFeePoolEncoder(), getFeePoolDecoder());
 }
 function decodeFeePool(encodedAccount) {
   return decodeAccount6(
@@ -1935,14 +1981,14 @@ async function fetchAllMaybeFeePool(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists7,
   assertAccountsExist as assertAccountsExist7,
-  combineCodec as combineCodec44,
+  combineCodec as combineCodec46,
   decodeAccount as decodeAccount7,
   fetchEncodedAccount as fetchEncodedAccount7,
   fetchEncodedAccounts as fetchEncodedAccounts7,
   fixDecoderSize as fixDecoderSize7,
   fixEncoderSize as fixEncoderSize7,
-  getAddressDecoder as getAddressDecoder22,
-  getAddressEncoder as getAddressEncoder22,
+  getAddressDecoder as getAddressDecoder24,
+  getAddressEncoder as getAddressEncoder24,
   getArrayDecoder as getArrayDecoder12,
   getArrayEncoder as getArrayEncoder12,
   getBooleanDecoder as getBooleanDecoder5,
@@ -1953,14 +1999,14 @@ import {
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder3,
   getOptionDecoder as getOptionDecoder4,
   getOptionEncoder as getOptionEncoder4,
-  getStructDecoder as getStructDecoder38,
-  getStructEncoder as getStructEncoder38,
+  getStructDecoder as getStructDecoder40,
+  getStructEncoder as getStructEncoder40,
   getTupleDecoder as getTupleDecoder5,
   getTupleEncoder as getTupleEncoder5,
   getU32Decoder as getU32Decoder14,
   getU32Encoder as getU32Encoder14,
-  getU64Decoder as getU64Decoder23,
-  getU64Encoder as getU64Encoder23,
+  getU64Decoder as getU64Decoder21,
+  getU64Encoder as getU64Encoder21,
   getU8Decoder as getU8Decoder16,
   getU8Encoder as getU8Encoder16,
   transformEncoder as transformEncoder7
@@ -1982,25 +2028,25 @@ function getMXEAccountDiscriminatorBytes() {
 }
 function getMXEAccountEncoder() {
   return transformEncoder7(
-    getStructEncoder38([
+    getStructEncoder40([
       ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
       ["cluster", getOptionEncoder4(getU32Encoder14())],
-      ["keygenOffset", getU64Encoder23()],
-      ["keyRecoveryInitOffset", getU64Encoder23()],
-      ["mxeProgramId", getAddressEncoder22()],
-      ["authority", getOptionEncoder4(getAddressEncoder22())],
+      ["keygenOffset", getU64Encoder21()],
+      ["keyRecoveryInitOffset", getU64Encoder21()],
+      ["mxeProgramId", getAddressEncoder24()],
+      ["authority", getOptionEncoder4(getAddressEncoder24())],
       [
         "utilityPubkeys",
         getDiscriminatedUnionEncoder3([
           [
             "Set",
-            getStructEncoder38([
+            getStructEncoder40([
               ["fields", getTupleEncoder5([getUtilityPubkeysEncoder()])]
             ])
           ],
           [
             "Unset",
-            getStructEncoder38([
+            getStructEncoder40([
               [
                 "fields",
                 getTupleEncoder5([
@@ -2012,7 +2058,7 @@ function getMXEAccountEncoder() {
           ]
         ])
       ],
-      ["lutOffsetSlot", getU64Encoder23()],
+      ["lutOffsetSlot", getU64Encoder21()],
       ["computationDefinitions", getArrayEncoder12(getU32Encoder14())],
       ["status", getMxeStatusEncoder()],
       ["bump", getU8Encoder16()]
@@ -2021,25 +2067,25 @@ function getMXEAccountEncoder() {
   );
 }
 function getMXEAccountDecoder() {
-  return getStructDecoder38([
+  return getStructDecoder40([
     ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
     ["cluster", getOptionDecoder4(getU32Decoder14())],
-    ["keygenOffset", getU64Decoder23()],
-    ["keyRecoveryInitOffset", getU64Decoder23()],
-    ["mxeProgramId", getAddressDecoder22()],
-    ["authority", getOptionDecoder4(getAddressDecoder22())],
+    ["keygenOffset", getU64Decoder21()],
+    ["keyRecoveryInitOffset", getU64Decoder21()],
+    ["mxeProgramId", getAddressDecoder24()],
+    ["authority", getOptionDecoder4(getAddressDecoder24())],
     [
       "utilityPubkeys",
       getDiscriminatedUnionDecoder3([
         [
           "Set",
-          getStructDecoder38([
+          getStructDecoder40([
             ["fields", getTupleDecoder5([getUtilityPubkeysDecoder()])]
           ])
         ],
         [
           "Unset",
-          getStructDecoder38([
+          getStructDecoder40([
             [
               "fields",
               getTupleDecoder5([
@@ -2051,14 +2097,14 @@ function getMXEAccountDecoder() {
         ]
       ])
     ],
-    ["lutOffsetSlot", getU64Decoder23()],
+    ["lutOffsetSlot", getU64Decoder21()],
     ["computationDefinitions", getArrayDecoder12(getU32Decoder14())],
     ["status", getMxeStatusDecoder()],
     ["bump", getU8Decoder16()]
   ]);
 }
 function getMXEAccountCodec() {
-  return combineCodec44(getMXEAccountEncoder(), getMXEAccountDecoder());
+  return combineCodec46(getMXEAccountEncoder(), getMXEAccountDecoder());
 }
 function decodeMXEAccount(encodedAccount) {
   return decodeAccount7(
@@ -2089,14 +2135,14 @@ async function fetchAllMaybeMXEAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists8,
   assertAccountsExist as assertAccountsExist8,
-  combineCodec as combineCodec45,
+  combineCodec as combineCodec47,
   decodeAccount as decodeAccount8,
   fetchEncodedAccount as fetchEncodedAccount8,
   fetchEncodedAccounts as fetchEncodedAccounts8,
   fixDecoderSize as fixDecoderSize8,
   fixEncoderSize as fixEncoderSize8,
-  getAddressDecoder as getAddressDecoder23,
-  getAddressEncoder as getAddressEncoder23,
+  getAddressDecoder as getAddressDecoder25,
+  getAddressEncoder as getAddressEncoder25,
   getArrayDecoder as getArrayDecoder13,
   getArrayEncoder as getArrayEncoder13,
   getBooleanDecoder as getBooleanDecoder6,
@@ -2105,10 +2151,10 @@ import {
   getBytesEncoder as getBytesEncoder8,
   getOptionDecoder as getOptionDecoder5,
   getOptionEncoder as getOptionEncoder5,
-  getStructDecoder as getStructDecoder39,
-  getStructEncoder as getStructEncoder39,
-  getU64Decoder as getU64Decoder24,
-  getU64Encoder as getU64Encoder24,
+  getStructDecoder as getStructDecoder41,
+  getStructEncoder as getStructEncoder41,
+  getU64Decoder as getU64Decoder22,
+  getU64Encoder as getU64Encoder22,
   getU8Decoder as getU8Decoder17,
   getU8Encoder as getU8Encoder17,
   transformEncoder as transformEncoder8
@@ -2130,57 +2176,59 @@ function getOpportunityMarketDiscriminatorBytes() {
 }
 function getOpportunityMarketEncoder() {
   return transformEncoder8(
-    getStructEncoder39([
+    getStructEncoder41([
       ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
       ["bump", getU8Encoder17()],
-      ["creator", getAddressEncoder23()],
-      ["index", getU64Encoder24()],
-      ["totalOptions", getU64Encoder24()],
-      ["openTimestamp", getOptionEncoder5(getU64Encoder24())],
-      ["timeToStake", getU64Encoder24()],
-      ["timeToReveal", getU64Encoder24()],
+      ["creator", getAddressEncoder25()],
+      ["index", getU64Encoder22()],
+      ["totalOptions", getU64Encoder22()],
+      ["openTimestamp", getOptionEncoder5(getU64Encoder22())],
+      ["timeToStake", getU64Encoder22()],
+      ["timeToReveal", getU64Encoder22()],
       [
         "selectedOptions",
         getOptionEncoder5(getArrayEncoder13(getWinningOptionEncoder()))
       ],
-      ["rewardAmount", getU64Encoder24()],
-      ["marketAuthority", getAddressEncoder23()],
-      ["revealPeriodAuthority", getAddressEncoder23()],
-      ["mint", getAddressEncoder23()],
-      ["earlinessCutoffSeconds", getU64Encoder24()],
-      ["unstakeDelaySeconds", getU64Encoder24()],
+      ["rewardAmount", getU64Encoder22()],
+      ["marketAuthority", getAddressEncoder25()],
+      ["revealPeriodAuthority", getAddressEncoder25()],
+      ["mint", getAddressEncoder25()],
+      ["earlinessCutoffSeconds", getU64Encoder22()],
+      ["unstakeDelaySeconds", getU64Encoder22()],
       ["authorizedReaderPubkey", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
-      ["allowClosingEarly", getBooleanEncoder6()]
+      ["allowClosingEarly", getBooleanEncoder6()],
+      ["paused", getBooleanEncoder6()]
     ]),
     (value) => ({ ...value, discriminator: OPPORTUNITY_MARKET_DISCRIMINATOR })
   );
 }
 function getOpportunityMarketDecoder() {
-  return getStructDecoder39([
+  return getStructDecoder41([
     ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
     ["bump", getU8Decoder17()],
-    ["creator", getAddressDecoder23()],
-    ["index", getU64Decoder24()],
-    ["totalOptions", getU64Decoder24()],
-    ["openTimestamp", getOptionDecoder5(getU64Decoder24())],
-    ["timeToStake", getU64Decoder24()],
-    ["timeToReveal", getU64Decoder24()],
+    ["creator", getAddressDecoder25()],
+    ["index", getU64Decoder22()],
+    ["totalOptions", getU64Decoder22()],
+    ["openTimestamp", getOptionDecoder5(getU64Decoder22())],
+    ["timeToStake", getU64Decoder22()],
+    ["timeToReveal", getU64Decoder22()],
     [
       "selectedOptions",
       getOptionDecoder5(getArrayDecoder13(getWinningOptionDecoder()))
     ],
-    ["rewardAmount", getU64Decoder24()],
-    ["marketAuthority", getAddressDecoder23()],
-    ["revealPeriodAuthority", getAddressDecoder23()],
-    ["mint", getAddressDecoder23()],
-    ["earlinessCutoffSeconds", getU64Decoder24()],
-    ["unstakeDelaySeconds", getU64Decoder24()],
+    ["rewardAmount", getU64Decoder22()],
+    ["marketAuthority", getAddressDecoder25()],
+    ["revealPeriodAuthority", getAddressDecoder25()],
+    ["mint", getAddressDecoder25()],
+    ["earlinessCutoffSeconds", getU64Decoder22()],
+    ["unstakeDelaySeconds", getU64Decoder22()],
     ["authorizedReaderPubkey", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
-    ["allowClosingEarly", getBooleanDecoder6()]
+    ["allowClosingEarly", getBooleanDecoder6()],
+    ["paused", getBooleanDecoder6()]
   ]);
 }
 function getOpportunityMarketCodec() {
-  return combineCodec45(
+  return combineCodec47(
     getOpportunityMarketEncoder(),
     getOpportunityMarketDecoder()
   );
@@ -2220,7 +2268,7 @@ async function fetchAllMaybeOpportunityMarket(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists9,
   assertAccountsExist as assertAccountsExist9,
-  combineCodec as combineCodec46,
+  combineCodec as combineCodec48,
   decodeAccount as decodeAccount9,
   fetchEncodedAccount as fetchEncodedAccount9,
   fetchEncodedAccounts as fetchEncodedAccounts9,
@@ -2228,10 +2276,10 @@ import {
   fixEncoderSize as fixEncoderSize9,
   getBytesDecoder as getBytesDecoder9,
   getBytesEncoder as getBytesEncoder9,
-  getStructDecoder as getStructDecoder40,
-  getStructEncoder as getStructEncoder40,
-  getU64Decoder as getU64Decoder25,
-  getU64Encoder as getU64Encoder25,
+  getStructDecoder as getStructDecoder42,
+  getStructEncoder as getStructEncoder42,
+  getU64Decoder as getU64Decoder23,
+  getU64Encoder as getU64Encoder23,
   getU8Decoder as getU8Decoder18,
   getU8Encoder as getU8Encoder18,
   transformEncoder as transformEncoder9
@@ -2253,12 +2301,12 @@ function getOpportunityMarketOptionDiscriminatorBytes() {
 }
 function getOpportunityMarketOptionEncoder() {
   return transformEncoder9(
-    getStructEncoder40([
+    getStructEncoder42([
       ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
       ["bump", getU8Encoder18()],
-      ["id", getU64Encoder25()],
-      ["totalStaked", getU64Encoder25()],
-      ["totalScore", getU64Encoder25()]
+      ["id", getU64Encoder23()],
+      ["totalStaked", getU64Encoder23()],
+      ["totalScore", getU64Encoder23()]
     ]),
     (value) => ({
       ...value,
@@ -2267,16 +2315,16 @@ function getOpportunityMarketOptionEncoder() {
   );
 }
 function getOpportunityMarketOptionDecoder() {
-  return getStructDecoder40([
+  return getStructDecoder42([
     ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
     ["bump", getU8Decoder18()],
-    ["id", getU64Decoder25()],
-    ["totalStaked", getU64Decoder25()],
-    ["totalScore", getU64Decoder25()]
+    ["id", getU64Decoder23()],
+    ["totalStaked", getU64Decoder23()],
+    ["totalScore", getU64Decoder23()]
   ]);
 }
 function getOpportunityMarketOptionCodec() {
-  return combineCodec46(
+  return combineCodec48(
     getOpportunityMarketOptionEncoder(),
     getOpportunityMarketOptionDecoder()
   );
@@ -2320,22 +2368,22 @@ async function fetchAllMaybeOpportunityMarketOption(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists10,
   assertAccountsExist as assertAccountsExist10,
-  combineCodec as combineCodec47,
+  combineCodec as combineCodec49,
   decodeAccount as decodeAccount10,
   fetchEncodedAccount as fetchEncodedAccount10,
   fetchEncodedAccounts as fetchEncodedAccounts10,
   fixDecoderSize as fixDecoderSize10,
   fixEncoderSize as fixEncoderSize10,
-  getAddressDecoder as getAddressDecoder24,
-  getAddressEncoder as getAddressEncoder24,
+  getAddressDecoder as getAddressDecoder26,
+  getAddressEncoder as getAddressEncoder26,
   getBooleanDecoder as getBooleanDecoder7,
   getBooleanEncoder as getBooleanEncoder7,
   getBytesDecoder as getBytesDecoder10,
   getBytesEncoder as getBytesEncoder10,
-  getStructDecoder as getStructDecoder41,
-  getStructEncoder as getStructEncoder41,
-  getU64Decoder as getU64Decoder26,
-  getU64Encoder as getU64Encoder26,
+  getStructDecoder as getStructDecoder43,
+  getStructEncoder as getStructEncoder43,
+  getU64Decoder as getU64Decoder24,
+  getU64Encoder as getU64Encoder24,
   getU8Decoder as getU8Decoder19,
   getU8Encoder as getU8Encoder19,
   transformEncoder as transformEncoder10
@@ -2357,12 +2405,12 @@ function getOpportunityMarketSponsorDiscriminatorBytes() {
 }
 function getOpportunityMarketSponsorEncoder() {
   return transformEncoder10(
-    getStructEncoder41([
+    getStructEncoder43([
       ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
       ["bump", getU8Encoder19()],
-      ["sponsor", getAddressEncoder24()],
-      ["market", getAddressEncoder24()],
-      ["rewardDeposited", getU64Encoder26()],
+      ["sponsor", getAddressEncoder26()],
+      ["market", getAddressEncoder26()],
+      ["rewardDeposited", getU64Encoder24()],
       ["rewardLocked", getBooleanEncoder7()]
     ]),
     (value) => ({
@@ -2372,17 +2420,17 @@ function getOpportunityMarketSponsorEncoder() {
   );
 }
 function getOpportunityMarketSponsorDecoder() {
-  return getStructDecoder41([
+  return getStructDecoder43([
     ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
     ["bump", getU8Decoder19()],
-    ["sponsor", getAddressDecoder24()],
-    ["market", getAddressDecoder24()],
-    ["rewardDeposited", getU64Decoder26()],
+    ["sponsor", getAddressDecoder26()],
+    ["market", getAddressDecoder26()],
+    ["rewardDeposited", getU64Decoder24()],
     ["rewardLocked", getBooleanDecoder7()]
   ]);
 }
 function getOpportunityMarketSponsorCodec() {
-  return combineCodec47(
+  return combineCodec49(
     getOpportunityMarketSponsorEncoder(),
     getOpportunityMarketSponsorDecoder()
   );
@@ -2426,14 +2474,14 @@ async function fetchAllMaybeOpportunityMarketSponsor(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists11,
   assertAccountsExist as assertAccountsExist11,
-  combineCodec as combineCodec48,
+  combineCodec as combineCodec50,
   decodeAccount as decodeAccount11,
   fetchEncodedAccount as fetchEncodedAccount11,
   fetchEncodedAccounts as fetchEncodedAccounts11,
   fixDecoderSize as fixDecoderSize11,
   fixEncoderSize as fixEncoderSize11,
-  getAddressDecoder as getAddressDecoder25,
-  getAddressEncoder as getAddressEncoder25,
+  getAddressDecoder as getAddressDecoder27,
+  getAddressEncoder as getAddressEncoder27,
   getArrayDecoder as getArrayDecoder14,
   getArrayEncoder as getArrayEncoder14,
   getBooleanDecoder as getBooleanDecoder8,
@@ -2442,14 +2490,14 @@ import {
   getBytesEncoder as getBytesEncoder11,
   getOptionDecoder as getOptionDecoder6,
   getOptionEncoder as getOptionEncoder6,
-  getStructDecoder as getStructDecoder42,
-  getStructEncoder as getStructEncoder42,
+  getStructDecoder as getStructDecoder44,
+  getStructEncoder as getStructEncoder44,
   getU128Decoder as getU128Decoder3,
   getU128Encoder as getU128Encoder3,
   getU32Decoder as getU32Decoder15,
   getU32Encoder as getU32Encoder15,
-  getU64Decoder as getU64Decoder27,
-  getU64Encoder as getU64Encoder27,
+  getU64Decoder as getU64Decoder25,
+  getU64Encoder as getU64Encoder25,
   getU8Decoder as getU8Decoder20,
   getU8Encoder as getU8Encoder20,
   transformEncoder as transformEncoder11
@@ -2471,27 +2519,27 @@ function getStakeAccountDiscriminatorBytes() {
 }
 function getStakeAccountEncoder() {
   return transformEncoder11(
-    getStructEncoder42([
+    getStructEncoder44([
       ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
       ["encryptedOption", getArrayEncoder14(getU8Encoder20(), { size: 32 })],
       ["stateNonce", getU128Encoder3()],
       ["bump", getU8Encoder20()],
-      ["owner", getAddressEncoder25()],
-      ["market", getAddressEncoder25()],
+      ["owner", getAddressEncoder27()],
+      ["market", getAddressEncoder27()],
       ["userPubkey", getArrayEncoder14(getU8Encoder20(), { size: 32 })],
       [
         "encryptedOptionDisclosure",
         getArrayEncoder14(getU8Encoder20(), { size: 32 })
       ],
       ["stateNonceDisclosure", getU128Encoder3()],
-      ["stakedAtTimestamp", getOptionEncoder6(getU64Encoder27())],
-      ["unstakedAtTimestamp", getOptionEncoder6(getU64Encoder27())],
-      ["amount", getU64Encoder27()],
-      ["fee", getU64Encoder27()],
-      ["revealedOption", getOptionEncoder6(getU64Encoder27())],
-      ["score", getOptionEncoder6(getU64Encoder27())],
+      ["stakedAtTimestamp", getOptionEncoder6(getU64Encoder25())],
+      ["unstakedAtTimestamp", getOptionEncoder6(getU64Encoder25())],
+      ["amount", getU64Encoder25()],
+      ["fee", getU64Encoder25()],
+      ["revealedOption", getOptionEncoder6(getU64Encoder25())],
+      ["score", getOptionEncoder6(getU64Encoder25())],
       ["totalIncremented", getBooleanEncoder8()],
-      ["unstakeableAtTimestamp", getOptionEncoder6(getU64Encoder27())],
+      ["unstakeableAtTimestamp", getOptionEncoder6(getU64Encoder25())],
       ["locked", getBooleanEncoder8()],
       ["stakeReclaimed", getBooleanEncoder8()],
       ["pendingStake", getBooleanEncoder8()],
@@ -2502,27 +2550,27 @@ function getStakeAccountEncoder() {
   );
 }
 function getStakeAccountDecoder() {
-  return getStructDecoder42([
+  return getStructDecoder44([
     ["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)],
     ["encryptedOption", getArrayDecoder14(getU8Decoder20(), { size: 32 })],
     ["stateNonce", getU128Decoder3()],
     ["bump", getU8Decoder20()],
-    ["owner", getAddressDecoder25()],
-    ["market", getAddressDecoder25()],
+    ["owner", getAddressDecoder27()],
+    ["market", getAddressDecoder27()],
     ["userPubkey", getArrayDecoder14(getU8Decoder20(), { size: 32 })],
     [
       "encryptedOptionDisclosure",
       getArrayDecoder14(getU8Decoder20(), { size: 32 })
     ],
     ["stateNonceDisclosure", getU128Decoder3()],
-    ["stakedAtTimestamp", getOptionDecoder6(getU64Decoder27())],
-    ["unstakedAtTimestamp", getOptionDecoder6(getU64Decoder27())],
-    ["amount", getU64Decoder27()],
-    ["fee", getU64Decoder27()],
-    ["revealedOption", getOptionDecoder6(getU64Decoder27())],
-    ["score", getOptionDecoder6(getU64Decoder27())],
+    ["stakedAtTimestamp", getOptionDecoder6(getU64Decoder25())],
+    ["unstakedAtTimestamp", getOptionDecoder6(getU64Decoder25())],
+    ["amount", getU64Decoder25()],
+    ["fee", getU64Decoder25()],
+    ["revealedOption", getOptionDecoder6(getU64Decoder25())],
+    ["score", getOptionDecoder6(getU64Decoder25())],
     ["totalIncremented", getBooleanDecoder8()],
-    ["unstakeableAtTimestamp", getOptionDecoder6(getU64Decoder27())],
+    ["unstakeableAtTimestamp", getOptionDecoder6(getU64Decoder25())],
     ["locked", getBooleanDecoder8()],
     ["stakeReclaimed", getBooleanDecoder8()],
     ["pendingStake", getBooleanDecoder8()],
@@ -2531,7 +2579,7 @@ function getStakeAccountDecoder() {
   ]);
 }
 function getStakeAccountCodec() {
-  return combineCodec48(getStakeAccountEncoder(), getStakeAccountDecoder());
+  return combineCodec50(getStakeAccountEncoder(), getStakeAccountDecoder());
 }
 function decodeStakeAccount(encodedAccount) {
   return decodeAccount11(
@@ -2562,24 +2610,24 @@ async function fetchAllMaybeStakeAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists12,
   assertAccountsExist as assertAccountsExist12,
-  combineCodec as combineCodec49,
+  combineCodec as combineCodec51,
   decodeAccount as decodeAccount12,
   fetchEncodedAccount as fetchEncodedAccount12,
   fetchEncodedAccounts as fetchEncodedAccounts12,
   fixDecoderSize as fixDecoderSize12,
   fixEncoderSize as fixEncoderSize12,
-  getAddressDecoder as getAddressDecoder26,
-  getAddressEncoder as getAddressEncoder26,
+  getAddressDecoder as getAddressDecoder28,
+  getAddressEncoder as getAddressEncoder28,
   getArrayDecoder as getArrayDecoder15,
   getArrayEncoder as getArrayEncoder15,
   getBytesDecoder as getBytesDecoder12,
   getBytesEncoder as getBytesEncoder12,
-  getStructDecoder as getStructDecoder43,
-  getStructEncoder as getStructEncoder43,
+  getStructDecoder as getStructDecoder45,
+  getStructEncoder as getStructEncoder45,
   getU16Decoder as getU16Decoder3,
   getU16Encoder as getU16Encoder3,
-  getU64Decoder as getU64Decoder28,
-  getU64Encoder as getU64Encoder28,
+  getU64Decoder as getU64Decoder26,
+  getU64Encoder as getU64Encoder26,
   getU8Decoder as getU8Decoder21,
   getU8Encoder as getU8Encoder21,
   transformEncoder as transformEncoder12
@@ -2599,11 +2647,11 @@ function getTokenVaultDiscriminatorBytes() {
 }
 function getTokenVaultEncoder() {
   return transformEncoder12(
-    getStructEncoder43([
+    getStructEncoder45([
       ["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)],
       ["bump", getU8Encoder21()],
-      ["mint", getAddressEncoder26()],
-      ["collectedFees", getU64Encoder28()],
+      ["mint", getAddressEncoder28()],
+      ["collectedFees", getU64Encoder26()],
       ["protocolFeeBp", getU16Encoder3()],
       ["reserved", getArrayEncoder15(getU8Encoder21(), { size: 128 })]
     ]),
@@ -2611,17 +2659,17 @@ function getTokenVaultEncoder() {
   );
 }
 function getTokenVaultDecoder() {
-  return getStructDecoder43([
+  return getStructDecoder45([
     ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
     ["bump", getU8Decoder21()],
-    ["mint", getAddressDecoder26()],
-    ["collectedFees", getU64Decoder28()],
+    ["mint", getAddressDecoder28()],
+    ["collectedFees", getU64Decoder26()],
     ["protocolFeeBp", getU16Decoder3()],
     ["reserved", getArrayDecoder15(getU8Decoder21(), { size: 128 })]
   ]);
 }
 function getTokenVaultCodec() {
-  return combineCodec49(getTokenVaultEncoder(), getTokenVaultDecoder());
+  return combineCodec51(getTokenVaultEncoder(), getTokenVaultDecoder());
 }
 function decodeTokenVault(encodedAccount) {
   return decodeAccount12(
@@ -2659,7 +2707,7 @@ import {
   fixEncoderSize as fixEncoderSize13,
   getBytesEncoder as getBytesEncoder13
 } from "@solana/kit";
-var OPPORTUNITY_MARKET_PROGRAM_ADDRESS = "BencHEXKYZ8HJ9LCrihgCWAmnqBT1abpsa9FYRs8fK1D";
+var OPPORTUNITY_MARKET_PROGRAM_ADDRESS = "BENCHauvSzMY39khAvj43LHRpbVewb76Wv8ETsVuHn8C";
 var OpportunityMarketAccount = /* @__PURE__ */ ((OpportunityMarketAccount2) => {
   OpportunityMarketAccount2[OpportunityMarketAccount2["ArciumSignerAccount"] = 0] = "ArciumSignerAccount";
   OpportunityMarketAccount2[OpportunityMarketAccount2["CentralState"] = 1] = "CentralState";
@@ -2803,18 +2851,20 @@ var OpportunityMarketInstruction = /* @__PURE__ */ ((OpportunityMarketInstructio
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitStakeAccount"] = 10] = "InitStakeAccount";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitTokenVault"] = 11] = "InitTokenVault";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["OpenMarket"] = 12] = "OpenMarket";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ReclaimStake"] = 13] = "ReclaimStake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStake"] = 14] = "RevealStake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 15] = "RevealStakeCallback";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 16] = "RevealStakeCompDef";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SelectWinningOptions"] = 17] = "SelectWinningOptions";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Stake"] = 18] = "Stake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCallback"] = 19] = "StakeCallback";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCompDef"] = 20] = "StakeCompDef";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["TransferCentralStateAuthority"] = 21] = "TransferCentralStateAuthority";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UnstakeEarly"] = 22] = "UnstakeEarly";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UpdateCentralState"] = 23] = "UpdateCentralState";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawReward"] = 24] = "WithdrawReward";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["PauseMarket"] = 13] = "PauseMarket";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ReclaimStake"] = 14] = "ReclaimStake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResumeMarket"] = 15] = "ResumeMarket";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStake"] = 16] = "RevealStake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 17] = "RevealStakeCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 18] = "RevealStakeCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SelectWinningOptions"] = 19] = "SelectWinningOptions";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Stake"] = 20] = "Stake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCallback"] = 21] = "StakeCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCompDef"] = 22] = "StakeCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["TransferCentralStateAuthority"] = 23] = "TransferCentralStateAuthority";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UnstakeEarly"] = 24] = "UnstakeEarly";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UpdateCentralState"] = 25] = "UpdateCentralState";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawReward"] = 26] = "WithdrawReward";
   return OpportunityMarketInstruction2;
 })(OpportunityMarketInstruction || {});
 function identifyOpportunityMarketInstruction(instruction) {
@@ -2921,29 +2971,47 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize13(getBytesEncoder13(), 8).encode(
-      new Uint8Array([203, 26, 194, 169, 252, 226, 179, 180])
+      new Uint8Array([203, 26, 194, 169, 252, 226, 179, 180])
+    ),
+    0
+  )) {
+    return 11 /* InitTokenVault */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize13(getBytesEncoder13(), 8).encode(
+      new Uint8Array([116, 19, 123, 75, 217, 244, 69, 44])
+    ),
+    0
+  )) {
+    return 12 /* OpenMarket */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize13(getBytesEncoder13(), 8).encode(
+      new Uint8Array([216, 238, 4, 164, 65, 11, 162, 91])
     ),
     0
   )) {
-    return 11 /* InitTokenVault */;
+    return 13 /* PauseMarket */;
   }
   if (containsBytes(
     data,
     fixEncoderSize13(getBytesEncoder13(), 8).encode(
-      new Uint8Array([116, 19, 123, 75, 217, 244, 69, 44])
+      new Uint8Array([237, 113, 219, 76, 6, 246, 223, 84])
     ),
     0
   )) {
-    return 12 /* OpenMarket */;
+    return 14 /* ReclaimStake */;
   }
   if (containsBytes(
     data,
     fixEncoderSize13(getBytesEncoder13(), 8).encode(
-      new Uint8Array([237, 113, 219, 76, 6, 246, 223, 84])
+      new Uint8Array([198, 120, 104, 87, 44, 103, 108, 143])
     ),
     0
   )) {
-    return 13 /* ReclaimStake */;
+    return 15 /* ResumeMarket */;
   }
   if (containsBytes(
     data,
@@ -2952,7 +3020,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 14 /* RevealStake */;
+    return 16 /* RevealStake */;
   }
   if (containsBytes(
     data,
@@ -2961,7 +3029,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 15 /* RevealStakeCallback */;
+    return 17 /* RevealStakeCallback */;
   }
   if (containsBytes(
     data,
@@ -2970,7 +3038,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 16 /* RevealStakeCompDef */;
+    return 18 /* RevealStakeCompDef */;
   }
   if (containsBytes(
     data,
@@ -2979,7 +3047,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 17 /* SelectWinningOptions */;
+    return 19 /* SelectWinningOptions */;
   }
   if (containsBytes(
     data,
@@ -2988,7 +3056,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 18 /* Stake */;
+    return 20 /* Stake */;
   }
   if (containsBytes(
     data,
@@ -2997,7 +3065,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 19 /* StakeCallback */;
+    return 21 /* StakeCallback */;
   }
   if (containsBytes(
     data,
@@ -3006,7 +3074,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 20 /* StakeCompDef */;
+    return 22 /* StakeCompDef */;
   }
   if (containsBytes(
     data,
@@ -3015,7 +3083,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 21 /* TransferCentralStateAuthority */;
+    return 23 /* TransferCentralStateAuthority */;
   }
   if (containsBytes(
     data,
@@ -3024,7 +3092,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 22 /* UnstakeEarly */;
+    return 24 /* UnstakeEarly */;
   }
   if (containsBytes(
     data,
@@ -3033,7 +3101,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 23 /* UpdateCentralState */;
+    return 25 /* UpdateCentralState */;
   }
   if (containsBytes(
     data,
@@ -3042,7 +3110,7 @@ function identifyOpportunityMarketInstruction(instruction) {
     ),
     0
   )) {
-    return 24 /* WithdrawReward */;
+    return 26 /* WithdrawReward */;
   }
   throw new Error(
     "The provided instruction could not be identified as a opportunityMarket instruction."
@@ -3080,6 +3148,10 @@ var OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED = 6026;
 var OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6027;
 var OPPORTUNITY_MARKET_ERROR__INVALID_WINNING_OPTIONS_INPUT = 6028;
 var OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6029;
+var OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH = 6030;
+var OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6031;
+var OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6032;
+var OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE = 6033;
 var opportunityMarketErrorMessages;
 if (true) {
   opportunityMarketErrorMessages = {
@@ -3091,6 +3163,7 @@ if (true) {
     [OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED]: `Market cannot be closed before stake period ends`,
     [OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET]: `Cluster not set`,
     [OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM]: `Deposit amount below minimum required for option creation`,
+    [OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE]: `Earliness cutoff exceeds staking period`,
     [OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE]: `Insufficient balance`,
     [OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING]: `Insufficient reward funding`,
     [OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE]: `Invalid account state`,
@@ -3101,10 +3174,13 @@ if (true) {
     [OPPORTUNITY_MARKET_ERROR__LOCKED]: `Account is locked`,
     [OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN]: `Market is already open`,
     [OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN]: `Market is not open`,
+    [OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED]: `Market is not paused`,
     [OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED]: `Market not yet resolved`,
+    [OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED]: `Market staking is currently paused`,
     [OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM]: `No fees to claim`,
     [OPPORTUNITY_MARKET_ERROR__NOT_REVEALED]: `Stake not yet revealed`,
     [OPPORTUNITY_MARKET_ERROR__OVERFLOW]: `Arithmetic overflow`,
+    [OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH]: `Protocol fee exceeds maximum 500 bp`,
     [OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED]: `Reveal period has already ended`,
     [OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK]: `Stake account is not in a stuck or failed state`,
     [OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE]: `Staking period is not active`,
@@ -3132,17 +3208,17 @@ function isOpportunityMarketError(error, transactionMessage, code) {
 
 // src/generated/instructions/addMarketOption.ts
 import {
-  combineCodec as combineCodec50,
+  combineCodec as combineCodec52,
   fixDecoderSize as fixDecoderSize13,
   fixEncoderSize as fixEncoderSize14,
-  getAddressEncoder as getAddressEncoder27,
+  getAddressEncoder as getAddressEncoder29,
   getBytesDecoder as getBytesDecoder13,
   getBytesEncoder as getBytesEncoder14,
   getProgramDerivedAddress,
-  getStructDecoder as getStructDecoder44,
-  getStructEncoder as getStructEncoder44,
-  getU64Decoder as getU64Decoder29,
-  getU64Encoder as getU64Encoder29,
+  getStructDecoder as getStructDecoder46,
+  getStructEncoder as getStructEncoder46,
+  getU64Decoder as getU64Decoder27,
+  getU64Encoder as getU64Encoder27,
   transformEncoder as transformEncoder13
 } from "@solana/kit";
 
@@ -3210,21 +3286,21 @@ function getAddMarketOptionDiscriminatorBytes() {
 }
 function getAddMarketOptionInstructionDataEncoder() {
   return transformEncoder13(
-    getStructEncoder44([
+    getStructEncoder46([
       ["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
-      ["optionId", getU64Encoder29()]
+      ["optionId", getU64Encoder27()]
     ]),
     (value) => ({ ...value, discriminator: ADD_MARKET_OPTION_DISCRIMINATOR })
   );
 }
 function getAddMarketOptionInstructionDataDecoder() {
-  return getStructDecoder44([
+  return getStructDecoder46([
     ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
-    ["optionId", getU64Decoder29()]
+    ["optionId", getU64Decoder27()]
   ]);
 }
 function getAddMarketOptionInstructionDataCodec() {
-  return combineCodec50(
+  return combineCodec52(
     getAddMarketOptionInstructionDataEncoder(),
     getAddMarketOptionInstructionDataDecoder()
   );
@@ -3246,8 +3322,8 @@ async function getAddMarketOptionInstructionAsync(input, config) {
         getBytesEncoder14().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder27().encode(expectAddress(accounts.market.value)),
-        getU64Encoder29().encode(expectSome(args.optionId))
+        getAddressEncoder29().encode(expectAddress(accounts.market.value)),
+        getU64Encoder27().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3319,19 +3395,19 @@ function parseAddMarketOptionInstruction(instruction) {
 
 // src/generated/instructions/addReward.ts
 import {
-  combineCodec as combineCodec51,
+  combineCodec as combineCodec53,
   fixDecoderSize as fixDecoderSize14,
   fixEncoderSize as fixEncoderSize15,
-  getAddressEncoder as getAddressEncoder28,
+  getAddressEncoder as getAddressEncoder30,
   getBooleanDecoder as getBooleanDecoder9,
   getBooleanEncoder as getBooleanEncoder9,
   getBytesDecoder as getBytesDecoder14,
   getBytesEncoder as getBytesEncoder15,
   getProgramDerivedAddress as getProgramDerivedAddress2,
-  getStructDecoder as getStructDecoder45,
-  getStructEncoder as getStructEncoder45,
-  getU64Decoder as getU64Decoder30,
-  getU64Encoder as getU64Encoder30,
+  getStructDecoder as getStructDecoder47,
+  getStructEncoder as getStructEncoder47,
+  getU64Decoder as getU64Decoder28,
+  getU64Encoder as getU64Encoder28,
   transformEncoder as transformEncoder14
 } from "@solana/kit";
 var ADD_REWARD_DISCRIMINATOR = new Uint8Array([
@@ -3349,23 +3425,23 @@ function getAddRewardDiscriminatorBytes() {
 }
 function getAddRewardInstructionDataEncoder() {
   return transformEncoder14(
-    getStructEncoder45([
+    getStructEncoder47([
       ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
-      ["amount", getU64Encoder30()],
+      ["amount", getU64Encoder28()],
       ["lock", getBooleanEncoder9()]
     ]),
     (value) => ({ ...value, discriminator: ADD_REWARD_DISCRIMINATOR })
   );
 }
 function getAddRewardInstructionDataDecoder() {
-  return getStructDecoder45([
+  return getStructDecoder47([
     ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
-    ["amount", getU64Decoder30()],
+    ["amount", getU64Decoder28()],
     ["lock", getBooleanDecoder9()]
   ]);
 }
 function getAddRewardInstructionDataCodec() {
-  return combineCodec51(
+  return combineCodec53(
     getAddRewardInstructionDataEncoder(),
     getAddRewardInstructionDataDecoder()
   );
@@ -3394,8 +3470,8 @@ async function getAddRewardInstructionAsync(input, config) {
         getBytesEncoder15().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        getAddressEncoder28().encode(expectAddress(accounts.sponsor.value)),
-        getAddressEncoder28().encode(expectAddress(accounts.market.value))
+        getAddressEncoder30().encode(expectAddress(accounts.sponsor.value)),
+        getAddressEncoder30().encode(expectAddress(accounts.market.value))
       ]
     });
   }
@@ -3403,9 +3479,9 @@ async function getAddRewardInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress2({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder28().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder28().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder28().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder30().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder30().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder30().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3496,15 +3572,15 @@ function parseAddRewardInstruction(instruction) {
 
 // src/generated/instructions/claimFees.ts
 import {
-  combineCodec as combineCodec52,
+  combineCodec as combineCodec54,
   fixDecoderSize as fixDecoderSize15,
   fixEncoderSize as fixEncoderSize16,
-  getAddressEncoder as getAddressEncoder29,
+  getAddressEncoder as getAddressEncoder31,
   getBytesDecoder as getBytesDecoder15,
   getBytesEncoder as getBytesEncoder16,
   getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder46,
-  getStructEncoder as getStructEncoder46,
+  getStructDecoder as getStructDecoder48,
+  getStructEncoder as getStructEncoder48,
   transformEncoder as transformEncoder15
 } from "@solana/kit";
 var CLAIM_FEES_DISCRIMINATOR = new Uint8Array([
@@ -3522,17 +3598,17 @@ function getClaimFeesDiscriminatorBytes() {
 }
 function getClaimFeesInstructionDataEncoder() {
   return transformEncoder15(
-    getStructEncoder46([["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)]]),
+    getStructEncoder48([["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_FEES_DISCRIMINATOR })
   );
 }
 function getClaimFeesInstructionDataDecoder() {
-  return getStructDecoder46([
+  return getStructDecoder48([
     ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)]
   ]);
 }
 function getClaimFeesInstructionDataCodec() {
-  return combineCodec52(
+  return combineCodec54(
     getClaimFeesInstructionDataEncoder(),
     getClaimFeesInstructionDataDecoder()
   );
@@ -3583,7 +3659,7 @@ async function getClaimFeesInstructionAsync(input, config) {
         getBytesEncoder16().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder29().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder31().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3591,9 +3667,9 @@ async function getClaimFeesInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress3({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder29().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder29().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder29().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder31().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder31().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder31().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3669,19 +3745,19 @@ function parseClaimFeesInstruction(instruction) {
 
 // src/generated/instructions/closeStakeAccount.ts
 import {
-  combineCodec as combineCodec53,
+  combineCodec as combineCodec55,
   fixDecoderSize as fixDecoderSize16,
   fixEncoderSize as fixEncoderSize17,
-  getAddressEncoder as getAddressEncoder30,
+  getAddressEncoder as getAddressEncoder32,
   getBytesDecoder as getBytesDecoder16,
   getBytesEncoder as getBytesEncoder17,
   getProgramDerivedAddress as getProgramDerivedAddress4,
-  getStructDecoder as getStructDecoder47,
-  getStructEncoder as getStructEncoder47,
+  getStructDecoder as getStructDecoder49,
+  getStructEncoder as getStructEncoder49,
   getU32Decoder as getU32Decoder16,
   getU32Encoder as getU32Encoder16,
-  getU64Decoder as getU64Decoder31,
-  getU64Encoder as getU64Encoder31,
+  getU64Decoder as getU64Decoder29,
+  getU64Encoder as getU64Encoder29,
   transformEncoder as transformEncoder16
 } from "@solana/kit";
 var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
@@ -3701,23 +3777,23 @@ function getCloseStakeAccountDiscriminatorBytes() {
 }
 function getCloseStakeAccountInstructionDataEncoder() {
   return transformEncoder16(
-    getStructEncoder47([
+    getStructEncoder49([
       ["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)],
-      ["optionId", getU64Encoder31()],
+      ["optionId", getU64Encoder29()],
       ["stakeAccountId", getU32Encoder16()]
     ]),
     (value) => ({ ...value, discriminator: CLOSE_STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getCloseStakeAccountInstructionDataDecoder() {
-  return getStructDecoder47([
+  return getStructDecoder49([
     ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)],
-    ["optionId", getU64Decoder31()],
+    ["optionId", getU64Decoder29()],
     ["stakeAccountId", getU32Decoder16()]
   ]);
 }
 function getCloseStakeAccountInstructionDataCodec() {
-  return combineCodec53(
+  return combineCodec55(
     getCloseStakeAccountInstructionDataEncoder(),
     getCloseStakeAccountInstructionDataDecoder()
   );
@@ -3761,8 +3837,8 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder30().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder30().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder32().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder32().encode(expectAddress(accounts.market.value)),
         getU32Encoder16().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -3774,8 +3850,8 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
         getBytesEncoder17().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder30().encode(expectAddress(accounts.market.value)),
-        getU64Encoder31().encode(expectSome(args.optionId))
+        getAddressEncoder32().encode(expectAddress(accounts.market.value)),
+        getU64Encoder29().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3783,9 +3859,9 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress4({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder30().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder30().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder30().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder32().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder32().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder32().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3880,15 +3956,15 @@ function parseCloseStakeAccountInstruction(instruction) {
 
 // src/generated/instructions/closeStuckStakeAccount.ts
 import {
-  combineCodec as combineCodec54,
+  combineCodec as combineCodec56,
   fixDecoderSize as fixDecoderSize17,
   fixEncoderSize as fixEncoderSize18,
-  getAddressEncoder as getAddressEncoder31,
+  getAddressEncoder as getAddressEncoder33,
   getBytesDecoder as getBytesDecoder17,
   getBytesEncoder as getBytesEncoder18,
   getProgramDerivedAddress as getProgramDerivedAddress5,
-  getStructDecoder as getStructDecoder48,
-  getStructEncoder as getStructEncoder48,
+  getStructDecoder as getStructDecoder50,
+  getStructEncoder as getStructEncoder50,
   getU32Decoder as getU32Decoder17,
   getU32Encoder as getU32Encoder17,
   transformEncoder as transformEncoder17
@@ -3910,7 +3986,7 @@ function getCloseStuckStakeAccountDiscriminatorBytes() {
 }
 function getCloseStuckStakeAccountInstructionDataEncoder() {
   return transformEncoder17(
-    getStructEncoder48([
+    getStructEncoder50([
       ["discriminator", fixEncoderSize18(getBytesEncoder18(), 8)],
       ["stakeAccountId", getU32Encoder17()]
     ]),
@@ -3921,13 +3997,13 @@ function getCloseStuckStakeAccountInstructionDataEncoder() {
   );
 }
 function getCloseStuckStakeAccountInstructionDataDecoder() {
-  return getStructDecoder48([
+  return getStructDecoder50([
     ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)],
     ["stakeAccountId", getU32Decoder17()]
   ]);
 }
 function getCloseStuckStakeAccountInstructionDataCodec() {
-  return combineCodec54(
+  return combineCodec56(
     getCloseStuckStakeAccountInstructionDataEncoder(),
     getCloseStuckStakeAccountInstructionDataDecoder()
   );
@@ -3972,8 +4048,8 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder31().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder31().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
         getU32Encoder17().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -3982,9 +4058,9 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress5({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder31().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder31().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder31().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3995,7 +4071,7 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
         getBytesEncoder18().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder31().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder33().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4003,9 +4079,9 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress5({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder31().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder31().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder31().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder33().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4106,11 +4182,11 @@ function parseCloseStuckStakeAccountInstruction(instruction) {
 
 // src/generated/instructions/createMarket.ts
 import {
-  combineCodec as combineCodec55,
+  combineCodec as combineCodec57,
   fixDecoderSize as fixDecoderSize18,
   fixEncoderSize as fixEncoderSize19,
-  getAddressDecoder as getAddressDecoder27,
-  getAddressEncoder as getAddressEncoder32,
+  getAddressDecoder as getAddressDecoder29,
+  getAddressEncoder as getAddressEncoder34,
   getArrayDecoder as getArrayDecoder16,
   getArrayEncoder as getArrayEncoder16,
   getBooleanDecoder as getBooleanDecoder10,
@@ -4120,10 +4196,10 @@ import {
   getOptionDecoder as getOptionDecoder7,
   getOptionEncoder as getOptionEncoder7,
   getProgramDerivedAddress as getProgramDerivedAddress6,
-  getStructDecoder as getStructDecoder49,
-  getStructEncoder as getStructEncoder49,
-  getU64Decoder as getU64Decoder32,
-  getU64Encoder as getU64Encoder32,
+  getStructDecoder as getStructDecoder51,
+  getStructEncoder as getStructEncoder51,
+  getU64Decoder as getU64Decoder30,
+  getU64Encoder as getU64Encoder30,
   getU8Decoder as getU8Decoder22,
   getU8Encoder as getU8Encoder22,
   transformEncoder as transformEncoder18
@@ -4145,35 +4221,37 @@ function getCreateMarketDiscriminatorBytes() {
 }
 function getCreateMarketInstructionDataEncoder() {
   return transformEncoder18(
-    getStructEncoder49([
+    getStructEncoder51([
       ["discriminator", fixEncoderSize19(getBytesEncoder19(), 8)],
-      ["marketIndex", getU64Encoder32()],
-      ["timeToStake", getU64Encoder32()],
-      ["timeToReveal", getU64Encoder32()],
-      ["marketAuthority", getOptionEncoder7(getAddressEncoder32())],
-      ["unstakeDelaySeconds", getU64Encoder32()],
+      ["marketIndex", getU64Encoder30()],
+      ["timeToStake", getU64Encoder30()],
+      ["timeToReveal", getU64Encoder30()],
+      ["marketAuthority", getOptionEncoder7(getAddressEncoder34())],
+      ["unstakeDelaySeconds", getU64Encoder30()],
       ["authorizedReaderPubkey", getArrayEncoder16(getU8Encoder22(), { size: 32 })],
       ["allowClosingEarly", getBooleanEncoder10()],
-      ["revealPeriodAuthority", getAddressEncoder32()]
+      ["revealPeriodAuthority", getAddressEncoder34()],
+      ["earlinessCutoffSeconds", getU64Encoder30()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_MARKET_DISCRIMINATOR })
   );
 }
 function getCreateMarketInstructionDataDecoder() {
-  return getStructDecoder49([
+  return getStructDecoder51([
     ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)],
-    ["marketIndex", getU64Decoder32()],
-    ["timeToStake", getU64Decoder32()],
-    ["timeToReveal", getU64Decoder32()],
-    ["marketAuthority", getOptionDecoder7(getAddressDecoder27())],
-    ["unstakeDelaySeconds", getU64Decoder32()],
+    ["marketIndex", getU64Decoder30()],
+    ["timeToStake", getU64Decoder30()],
+    ["timeToReveal", getU64Decoder30()],
+    ["marketAuthority", getOptionDecoder7(getAddressDecoder29())],
+    ["unstakeDelaySeconds", getU64Decoder30()],
     ["authorizedReaderPubkey", getArrayDecoder16(getU8Decoder22(), { size: 32 })],
     ["allowClosingEarly", getBooleanDecoder10()],
-    ["revealPeriodAuthority", getAddressDecoder27()]
+    ["revealPeriodAuthority", getAddressDecoder29()],
+    ["earlinessCutoffSeconds", getU64Decoder30()]
   ]);
 }
 function getCreateMarketInstructionDataCodec() {
-  return combineCodec55(
+  return combineCodec57(
     getCreateMarketInstructionDataEncoder(),
     getCreateMarketInstructionDataDecoder()
   );
@@ -4183,7 +4261,6 @@ async function getCreateMarketInstructionAsync(input, config) {
   const originalAccounts = {
     creator: { value: input.creator ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    centralState: { value: input.centralState ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: true },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false },
@@ -4195,30 +4272,6 @@ async function getCreateMarketInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  if (!accounts.centralState.value) {
-    accounts.centralState.value = await getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder19().encode(
-          new Uint8Array([
-            99,
-            101,
-            110,
-            116,
-            114,
-            97,
-            108,
-            95,
-            115,
-            116,
-            97,
-            116,
-            101
-          ])
-        )
-      ]
-    });
-  }
   if (!accounts.market.value) {
     accounts.market.value = await getProgramDerivedAddress6({
       programAddress,
@@ -4245,8 +4298,8 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder32().encode(expectAddress(accounts.creator.value)),
-        getU64Encoder32().encode(expectSome(args.marketIndex))
+        getAddressEncoder34().encode(expectAddress(accounts.creator.value)),
+        getU64Encoder30().encode(expectSome(args.marketIndex))
       ]
     });
   }
@@ -4254,9 +4307,9 @@ async function getCreateMarketInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress6({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder32().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder32().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder32().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder34().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder34().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder34().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4271,7 +4324,6 @@ async function getCreateMarketInstructionAsync(input, config) {
     accounts: [
       getAccountMeta(accounts.creator),
       getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.centralState),
       getAccountMeta(accounts.market),
       getAccountMeta(accounts.marketTokenAta),
       getAccountMeta(accounts.systemProgram),
@@ -4289,7 +4341,6 @@ function getCreateMarketInstruction(input, config) {
   const originalAccounts = {
     creator: { value: input.creator ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    centralState: { value: input.centralState ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: true },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false },
@@ -4312,7 +4363,6 @@ function getCreateMarketInstruction(input, config) {
     accounts: [
       getAccountMeta(accounts.creator),
       getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.centralState),
       getAccountMeta(accounts.market),
       getAccountMeta(accounts.marketTokenAta),
       getAccountMeta(accounts.systemProgram),
@@ -4326,7 +4376,7 @@ function getCreateMarketInstruction(input, config) {
   });
 }
 function parseCreateMarketInstruction(instruction) {
-  if (instruction.accounts.length < 8) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -4340,7 +4390,6 @@ function parseCreateMarketInstruction(instruction) {
     accounts: {
       creator: getNextAccount(),
       tokenMint: getNextAccount(),
-      centralState: getNextAccount(),
       market: getNextAccount(),
       marketTokenAta: getNextAccount(),
       systemProgram: getNextAccount(),
@@ -4353,16 +4402,16 @@ function parseCreateMarketInstruction(instruction) {
 
 // src/generated/instructions/doUnstakeEarly.ts
 import {
-  combineCodec as combineCodec56,
+  combineCodec as combineCodec58,
   fixDecoderSize as fixDecoderSize19,
   fixEncoderSize as fixEncoderSize20,
-  getAddressDecoder as getAddressDecoder28,
-  getAddressEncoder as getAddressEncoder33,
+  getAddressDecoder as getAddressDecoder30,
+  getAddressEncoder as getAddressEncoder35,
   getBytesDecoder as getBytesDecoder19,
   getBytesEncoder as getBytesEncoder20,
   getProgramDerivedAddress as getProgramDerivedAddress7,
-  getStructDecoder as getStructDecoder50,
-  getStructEncoder as getStructEncoder50,
+  getStructDecoder as getStructDecoder52,
+  getStructEncoder as getStructEncoder52,
   getU32Decoder as getU32Decoder18,
   getU32Encoder as getU32Encoder18,
   transformEncoder as transformEncoder19
@@ -4384,23 +4433,23 @@ function getDoUnstakeEarlyDiscriminatorBytes() {
 }
 function getDoUnstakeEarlyInstructionDataEncoder() {
   return transformEncoder19(
-    getStructEncoder50([
+    getStructEncoder52([
       ["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)],
       ["stakeAccountId", getU32Encoder18()],
-      ["stakeAccountOwner", getAddressEncoder33()]
+      ["stakeAccountOwner", getAddressEncoder35()]
     ]),
     (value) => ({ ...value, discriminator: DO_UNSTAKE_EARLY_DISCRIMINATOR })
   );
 }
 function getDoUnstakeEarlyInstructionDataDecoder() {
-  return getStructDecoder50([
+  return getStructDecoder52([
     ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)],
     ["stakeAccountId", getU32Decoder18()],
-    ["stakeAccountOwner", getAddressDecoder28()]
+    ["stakeAccountOwner", getAddressDecoder30()]
   ]);
 }
 function getDoUnstakeEarlyInstructionDataCodec() {
-  return combineCodec56(
+  return combineCodec58(
     getDoUnstakeEarlyInstructionDataEncoder(),
     getDoUnstakeEarlyInstructionDataDecoder()
   );
@@ -4443,8 +4492,8 @@ async function getDoUnstakeEarlyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder33().encode(expectSome(args.stakeAccountOwner)),
-        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder35().encode(expectSome(args.stakeAccountOwner)),
+        getAddressEncoder35().encode(expectAddress(accounts.market.value)),
         getU32Encoder18().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -4453,9 +4502,9 @@ async function getDoUnstakeEarlyInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress7({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder33().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder33().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder35().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder35().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder35().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4546,13 +4595,13 @@ function parseDoUnstakeEarlyInstruction(instruction) {
 
 // src/generated/instructions/endRevealPeriod.ts
 import {
-  combineCodec as combineCodec57,
+  combineCodec as combineCodec59,
   fixDecoderSize as fixDecoderSize20,
   fixEncoderSize as fixEncoderSize21,
   getBytesDecoder as getBytesDecoder20,
   getBytesEncoder as getBytesEncoder21,
-  getStructDecoder as getStructDecoder51,
-  getStructEncoder as getStructEncoder51,
+  getStructDecoder as getStructDecoder53,
+  getStructEncoder as getStructEncoder53,
   transformEncoder as transformEncoder20
 } from "@solana/kit";
 var END_REVEAL_PERIOD_DISCRIMINATOR = new Uint8Array([
@@ -4572,17 +4621,17 @@ function getEndRevealPeriodDiscriminatorBytes() {
 }
 function getEndRevealPeriodInstructionDataEncoder() {
   return transformEncoder20(
-    getStructEncoder51([["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)]]),
+    getStructEncoder53([["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)]]),
     (value) => ({ ...value, discriminator: END_REVEAL_PERIOD_DISCRIMINATOR })
   );
 }
 function getEndRevealPeriodInstructionDataDecoder() {
-  return getStructDecoder51([
+  return getStructDecoder53([
     ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)]
   ]);
 }
 function getEndRevealPeriodInstructionDataCodec() {
-  return combineCodec57(
+  return combineCodec59(
     getEndRevealPeriodInstructionDataEncoder(),
     getEndRevealPeriodInstructionDataDecoder()
   );
@@ -4623,19 +4672,19 @@ function parseEndRevealPeriodInstruction(instruction) {
 
 // src/generated/instructions/incrementOptionTally.ts
 import {
-  combineCodec as combineCodec58,
+  combineCodec as combineCodec60,
   fixDecoderSize as fixDecoderSize21,
   fixEncoderSize as fixEncoderSize22,
-  getAddressEncoder as getAddressEncoder34,
+  getAddressEncoder as getAddressEncoder36,
   getBytesDecoder as getBytesDecoder21,
   getBytesEncoder as getBytesEncoder22,
   getProgramDerivedAddress as getProgramDerivedAddress8,
-  getStructDecoder as getStructDecoder52,
-  getStructEncoder as getStructEncoder52,
+  getStructDecoder as getStructDecoder54,
+  getStructEncoder as getStructEncoder54,
   getU32Decoder as getU32Decoder19,
   getU32Encoder as getU32Encoder19,
-  getU64Decoder as getU64Decoder33,
-  getU64Encoder as getU64Encoder33,
+  getU64Decoder as getU64Decoder31,
+  getU64Encoder as getU64Encoder31,
   transformEncoder as transformEncoder21
 } from "@solana/kit";
 var INCREMENT_OPTION_TALLY_DISCRIMINATOR = new Uint8Array([
@@ -4655,9 +4704,9 @@ function getIncrementOptionTallyDiscriminatorBytes() {
 }
 function getIncrementOptionTallyInstructionDataEncoder() {
   return transformEncoder21(
-    getStructEncoder52([
+    getStructEncoder54([
       ["discriminator", fixEncoderSize22(getBytesEncoder22(), 8)],
-      ["optionId", getU64Encoder33()],
+      ["optionId", getU64Encoder31()],
       ["stakeAccountId", getU32Encoder19()]
     ]),
     (value) => ({
@@ -4667,14 +4716,14 @@ function getIncrementOptionTallyInstructionDataEncoder() {
   );
 }
 function getIncrementOptionTallyInstructionDataDecoder() {
-  return getStructDecoder52([
+  return getStructDecoder54([
     ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)],
-    ["optionId", getU64Decoder33()],
+    ["optionId", getU64Decoder31()],
     ["stakeAccountId", getU32Decoder19()]
   ]);
 }
 function getIncrementOptionTallyInstructionDataCodec() {
-  return combineCodec58(
+  return combineCodec60(
     getIncrementOptionTallyInstructionDataEncoder(),
     getIncrementOptionTallyInstructionDataDecoder()
   );
@@ -4712,8 +4761,8 @@ async function getIncrementOptionTallyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder34().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder34().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder36().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
         getU32Encoder19().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -4725,8 +4774,8 @@ async function getIncrementOptionTallyInstructionAsync(input, config) {
         getBytesEncoder22().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder34().encode(expectAddress(accounts.market.value)),
-        getU64Encoder33().encode(expectSome(args.optionId))
+        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
+        getU64Encoder31().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -4808,20 +4857,18 @@ function parseIncrementOptionTallyInstruction(instruction) {
 
 // src/generated/instructions/initCentralState.ts
 import {
-  combineCodec as combineCodec59,
+  combineCodec as combineCodec61,
   fixDecoderSize as fixDecoderSize22,
   fixEncoderSize as fixEncoderSize23,
-  getAddressDecoder as getAddressDecoder29,
-  getAddressEncoder as getAddressEncoder35,
+  getAddressDecoder as getAddressDecoder31,
+  getAddressEncoder as getAddressEncoder37,
   getBytesDecoder as getBytesDecoder22,
   getBytesEncoder as getBytesEncoder23,
   getProgramDerivedAddress as getProgramDerivedAddress9,
-  getStructDecoder as getStructDecoder53,
-  getStructEncoder as getStructEncoder53,
+  getStructDecoder as getStructDecoder55,
+  getStructEncoder as getStructEncoder55,
   getU16Decoder as getU16Decoder4,
   getU16Encoder as getU16Encoder4,
-  getU64Decoder as getU64Decoder34,
-  getU64Encoder as getU64Encoder34,
   transformEncoder as transformEncoder22
 } from "@solana/kit";
 var INIT_CENTRAL_STATE_DISCRIMINATOR = new Uint8Array([
@@ -4841,29 +4888,23 @@ function getInitCentralStateDiscriminatorBytes() {
 }
 function getInitCentralStateInstructionDataEncoder() {
   return transformEncoder22(
-    getStructEncoder53([
+    getStructEncoder55([
       ["discriminator", fixEncoderSize23(getBytesEncoder23(), 8)],
-      ["earlinessCutoffSeconds", getU64Encoder34()],
-      ["minOptionDeposit", getU64Encoder34()],
       ["protocolFeeBp", getU16Encoder4()],
-      ["feeRecipient", getAddressEncoder35()],
-      ["minimumInitialRevealPeriod", getU64Encoder34()]
+      ["feeRecipient", getAddressEncoder37()]
     ]),
     (value) => ({ ...value, discriminator: INIT_CENTRAL_STATE_DISCRIMINATOR })
   );
 }
 function getInitCentralStateInstructionDataDecoder() {
-  return getStructDecoder53([
+  return getStructDecoder55([
     ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)],
-    ["earlinessCutoffSeconds", getU64Decoder34()],
-    ["minOptionDeposit", getU64Decoder34()],
     ["protocolFeeBp", getU16Decoder4()],
-    ["feeRecipient", getAddressDecoder29()],
-    ["minimumInitialRevealPeriod", getU64Decoder34()]
+    ["feeRecipient", getAddressDecoder31()]
   ]);
 }
 function getInitCentralStateInstructionDataCodec() {
-  return combineCodec59(
+  return combineCodec61(
     getInitCentralStateInstructionDataEncoder(),
     getInitCentralStateInstructionDataDecoder()
   );
@@ -4965,15 +5006,15 @@ function parseInitCentralStateInstruction(instruction) {
 
 // src/generated/instructions/initStakeAccount.ts
 import {
-  combineCodec as combineCodec60,
+  combineCodec as combineCodec62,
   fixDecoderSize as fixDecoderSize23,
   fixEncoderSize as fixEncoderSize24,
-  getAddressEncoder as getAddressEncoder36,
+  getAddressEncoder as getAddressEncoder38,
   getBytesDecoder as getBytesDecoder23,
   getBytesEncoder as getBytesEncoder24,
   getProgramDerivedAddress as getProgramDerivedAddress10,
-  getStructDecoder as getStructDecoder54,
-  getStructEncoder as getStructEncoder54,
+  getStructDecoder as getStructDecoder56,
+  getStructEncoder as getStructEncoder56,
   getU128Decoder as getU128Decoder4,
   getU128Encoder as getU128Encoder4,
   getU32Decoder as getU32Decoder20,
@@ -4997,7 +5038,7 @@ function getInitStakeAccountDiscriminatorBytes() {
 }
 function getInitStakeAccountInstructionDataEncoder() {
   return transformEncoder23(
-    getStructEncoder54([
+    getStructEncoder56([
       ["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)],
       ["stateNonce", getU128Encoder4()],
       ["stakeAccountId", getU32Encoder20()]
@@ -5006,14 +5047,14 @@ function getInitStakeAccountInstructionDataEncoder() {
   );
 }
 function getInitStakeAccountInstructionDataDecoder() {
-  return getStructDecoder54([
+  return getStructDecoder56([
     ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)],
     ["stateNonce", getU128Decoder4()],
     ["stakeAccountId", getU32Decoder20()]
   ]);
 }
 function getInitStakeAccountInstructionDataCodec() {
-  return combineCodec60(
+  return combineCodec62(
     getInitStakeAccountInstructionDataEncoder(),
     getInitStakeAccountInstructionDataDecoder()
   );
@@ -5049,8 +5090,8 @@ async function getInitStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder36().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder38().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
         getU32Encoder20().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -5123,15 +5164,15 @@ function parseInitStakeAccountInstruction(instruction) {
 
 // src/generated/instructions/initTokenVault.ts
 import {
-  combineCodec as combineCodec61,
+  combineCodec as combineCodec63,
   fixDecoderSize as fixDecoderSize24,
   fixEncoderSize as fixEncoderSize25,
-  getAddressEncoder as getAddressEncoder37,
+  getAddressEncoder as getAddressEncoder39,
   getBytesDecoder as getBytesDecoder24,
   getBytesEncoder as getBytesEncoder25,
   getProgramDerivedAddress as getProgramDerivedAddress11,
-  getStructDecoder as getStructDecoder55,
-  getStructEncoder as getStructEncoder55,
+  getStructDecoder as getStructDecoder57,
+  getStructEncoder as getStructEncoder57,
   transformEncoder as transformEncoder24
 } from "@solana/kit";
 var INIT_TOKEN_VAULT_DISCRIMINATOR = new Uint8Array([
@@ -5151,17 +5192,17 @@ function getInitTokenVaultDiscriminatorBytes() {
 }
 function getInitTokenVaultInstructionDataEncoder() {
   return transformEncoder24(
-    getStructEncoder55([["discriminator", fixEncoderSize25(getBytesEncoder25(), 8)]]),
+    getStructEncoder57([["discriminator", fixEncoderSize25(getBytesEncoder25(), 8)]]),
     (value) => ({ ...value, discriminator: INIT_TOKEN_VAULT_DISCRIMINATOR })
   );
 }
 function getInitTokenVaultInstructionDataDecoder() {
-  return getStructDecoder55([
+  return getStructDecoder57([
     ["discriminator", fixDecoderSize24(getBytesDecoder24(), 8)]
   ]);
 }
 function getInitTokenVaultInstructionDataCodec() {
-  return combineCodec61(
+  return combineCodec63(
     getInitTokenVaultInstructionDataEncoder(),
     getInitTokenVaultInstructionDataDecoder()
   );
@@ -5183,7 +5224,7 @@ async function getInitTokenVaultInstructionAsync(input, config) {
         getBytesEncoder25().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder37().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder39().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5278,15 +5319,15 @@ function parseInitTokenVaultInstruction(instruction) {
 
 // src/generated/instructions/openMarket.ts
 import {
-  combineCodec as combineCodec62,
+  combineCodec as combineCodec64,
   fixDecoderSize as fixDecoderSize25,
   fixEncoderSize as fixEncoderSize26,
   getBytesDecoder as getBytesDecoder25,
   getBytesEncoder as getBytesEncoder26,
-  getStructDecoder as getStructDecoder56,
-  getStructEncoder as getStructEncoder56,
-  getU64Decoder as getU64Decoder35,
-  getU64Encoder as getU64Encoder35,
+  getStructDecoder as getStructDecoder58,
+  getStructEncoder as getStructEncoder58,
+  getU64Decoder as getU64Decoder32,
+  getU64Encoder as getU64Encoder32,
   transformEncoder as transformEncoder25
 } from "@solana/kit";
 var OPEN_MARKET_DISCRIMINATOR = new Uint8Array([
@@ -5304,21 +5345,21 @@ function getOpenMarketDiscriminatorBytes() {
 }
 function getOpenMarketInstructionDataEncoder() {
   return transformEncoder25(
-    getStructEncoder56([
+    getStructEncoder58([
       ["discriminator", fixEncoderSize26(getBytesEncoder26(), 8)],
-      ["openTimestamp", getU64Encoder35()]
+      ["openTimestamp", getU64Encoder32()]
     ]),
     (value) => ({ ...value, discriminator: OPEN_MARKET_DISCRIMINATOR })
   );
 }
 function getOpenMarketInstructionDataDecoder() {
-  return getStructDecoder56([
+  return getStructDecoder58([
     ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)],
-    ["openTimestamp", getU64Decoder35()]
+    ["openTimestamp", getU64Decoder32()]
   ]);
 }
 function getOpenMarketInstructionDataCodec() {
-  return combineCodec62(
+  return combineCodec64(
     getOpenMarketInstructionDataEncoder(),
     getOpenMarketInstructionDataDecoder()
   );
@@ -5360,20 +5401,97 @@ function parseOpenMarketInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/reclaimStake.ts
+// src/generated/instructions/pauseMarket.ts
 import {
-  combineCodec as combineCodec63,
+  combineCodec as combineCodec65,
   fixDecoderSize as fixDecoderSize26,
   fixEncoderSize as fixEncoderSize27,
-  getAddressEncoder as getAddressEncoder38,
   getBytesDecoder as getBytesDecoder26,
   getBytesEncoder as getBytesEncoder27,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
+  transformEncoder as transformEncoder26
+} from "@solana/kit";
+var PAUSE_MARKET_DISCRIMINATOR = new Uint8Array([
+  216,
+  238,
+  4,
+  164,
+  65,
+  11,
+  162,
+  91
+]);
+function getPauseMarketDiscriminatorBytes() {
+  return fixEncoderSize27(getBytesEncoder27(), 8).encode(
+    PAUSE_MARKET_DISCRIMINATOR
+  );
+}
+function getPauseMarketInstructionDataEncoder() {
+  return transformEncoder26(
+    getStructEncoder59([["discriminator", fixEncoderSize27(getBytesEncoder27(), 8)]]),
+    (value) => ({ ...value, discriminator: PAUSE_MARKET_DISCRIMINATOR })
+  );
+}
+function getPauseMarketInstructionDataDecoder() {
+  return getStructDecoder59([
+    ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)]
+  ]);
+}
+function getPauseMarketInstructionDataCodec() {
+  return combineCodec65(
+    getPauseMarketInstructionDataEncoder(),
+    getPauseMarketInstructionDataDecoder()
+  );
+}
+function getPauseMarketInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.market)
+    ],
+    data: getPauseMarketInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parsePauseMarketInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { authority: getNextAccount(), market: getNextAccount() },
+    data: getPauseMarketInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/reclaimStake.ts
+import {
+  combineCodec as combineCodec66,
+  fixDecoderSize as fixDecoderSize27,
+  fixEncoderSize as fixEncoderSize28,
+  getAddressEncoder as getAddressEncoder40,
+  getBytesDecoder as getBytesDecoder27,
+  getBytesEncoder as getBytesEncoder28,
   getProgramDerivedAddress as getProgramDerivedAddress12,
-  getStructDecoder as getStructDecoder57,
-  getStructEncoder as getStructEncoder57,
+  getStructDecoder as getStructDecoder60,
+  getStructEncoder as getStructEncoder60,
   getU32Decoder as getU32Decoder21,
   getU32Encoder as getU32Encoder21,
-  transformEncoder as transformEncoder26
+  transformEncoder as transformEncoder27
 } from "@solana/kit";
 var RECLAIM_STAKE_DISCRIMINATOR = new Uint8Array([
   237,
@@ -5386,27 +5504,27 @@ var RECLAIM_STAKE_DISCRIMINATOR = new Uint8Array([
   84
 ]);
 function getReclaimStakeDiscriminatorBytes() {
-  return fixEncoderSize27(getBytesEncoder27(), 8).encode(
+  return fixEncoderSize28(getBytesEncoder28(), 8).encode(
     RECLAIM_STAKE_DISCRIMINATOR
   );
 }
 function getReclaimStakeInstructionDataEncoder() {
-  return transformEncoder26(
-    getStructEncoder57([
-      ["discriminator", fixEncoderSize27(getBytesEncoder27(), 8)],
+  return transformEncoder27(
+    getStructEncoder60([
+      ["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)],
       ["stakeAccountId", getU32Encoder21()]
     ]),
     (value) => ({ ...value, discriminator: RECLAIM_STAKE_DISCRIMINATOR })
   );
 }
 function getReclaimStakeInstructionDataDecoder() {
-  return getStructDecoder57([
-    ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)],
+  return getStructDecoder60([
+    ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)],
     ["stakeAccountId", getU32Decoder21()]
   ]);
 }
 function getReclaimStakeInstructionDataCodec() {
-  return combineCodec63(
+  return combineCodec66(
     getReclaimStakeInstructionDataEncoder(),
     getReclaimStakeInstructionDataDecoder()
   );
@@ -5433,7 +5551,7 @@ async function getReclaimStakeInstructionAsync(input, config) {
     accounts.stakeAccount.value = await getProgramDerivedAddress12({
       programAddress,
       seeds: [
-        getBytesEncoder27().encode(
+        getBytesEncoder28().encode(
           new Uint8Array([
             115,
             116,
@@ -5450,8 +5568,8 @@ async function getReclaimStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder38().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
         getU32Encoder21().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -5460,9 +5578,9 @@ async function getReclaimStakeInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress12({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -5555,22 +5673,99 @@ function parseReclaimStakeInstruction(instruction) {
   };
 }
 
+// src/generated/instructions/resumeMarket.ts
+import {
+  combineCodec as combineCodec67,
+  fixDecoderSize as fixDecoderSize28,
+  fixEncoderSize as fixEncoderSize29,
+  getBytesDecoder as getBytesDecoder28,
+  getBytesEncoder as getBytesEncoder29,
+  getStructDecoder as getStructDecoder61,
+  getStructEncoder as getStructEncoder61,
+  transformEncoder as transformEncoder28
+} from "@solana/kit";
+var RESUME_MARKET_DISCRIMINATOR = new Uint8Array([
+  198,
+  120,
+  104,
+  87,
+  44,
+  103,
+  108,
+  143
+]);
+function getResumeMarketDiscriminatorBytes() {
+  return fixEncoderSize29(getBytesEncoder29(), 8).encode(
+    RESUME_MARKET_DISCRIMINATOR
+  );
+}
+function getResumeMarketInstructionDataEncoder() {
+  return transformEncoder28(
+    getStructEncoder61([["discriminator", fixEncoderSize29(getBytesEncoder29(), 8)]]),
+    (value) => ({ ...value, discriminator: RESUME_MARKET_DISCRIMINATOR })
+  );
+}
+function getResumeMarketInstructionDataDecoder() {
+  return getStructDecoder61([
+    ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)]
+  ]);
+}
+function getResumeMarketInstructionDataCodec() {
+  return combineCodec67(
+    getResumeMarketInstructionDataEncoder(),
+    getResumeMarketInstructionDataDecoder()
+  );
+}
+function getResumeMarketInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.market)
+    ],
+    data: getResumeMarketInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseResumeMarketInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { authority: getNextAccount(), market: getNextAccount() },
+    data: getResumeMarketInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
 // src/generated/instructions/revealStake.ts
 import {
-  combineCodec as combineCodec64,
-  fixDecoderSize as fixDecoderSize27,
-  fixEncoderSize as fixEncoderSize28,
-  getAddressEncoder as getAddressEncoder39,
-  getBytesDecoder as getBytesDecoder27,
-  getBytesEncoder as getBytesEncoder28,
+  combineCodec as combineCodec68,
+  fixDecoderSize as fixDecoderSize29,
+  fixEncoderSize as fixEncoderSize30,
+  getAddressEncoder as getAddressEncoder41,
+  getBytesDecoder as getBytesDecoder29,
+  getBytesEncoder as getBytesEncoder30,
   getProgramDerivedAddress as getProgramDerivedAddress13,
-  getStructDecoder as getStructDecoder58,
-  getStructEncoder as getStructEncoder58,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
   getU32Decoder as getU32Decoder22,
   getU32Encoder as getU32Encoder22,
-  getU64Decoder as getU64Decoder36,
-  getU64Encoder as getU64Encoder36,
-  transformEncoder as transformEncoder27
+  getU64Decoder as getU64Decoder33,
+  getU64Encoder as getU64Encoder33,
+  transformEncoder as transformEncoder29
 } from "@solana/kit";
 var REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   107,
@@ -5583,29 +5778,29 @@ var REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   188
 ]);
 function getRevealStakeDiscriminatorBytes() {
-  return fixEncoderSize28(getBytesEncoder28(), 8).encode(
+  return fixEncoderSize30(getBytesEncoder30(), 8).encode(
     REVEAL_STAKE_DISCRIMINATOR
   );
 }
 function getRevealStakeInstructionDataEncoder() {
-  return transformEncoder27(
-    getStructEncoder58([
-      ["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)],
-      ["computationOffset", getU64Encoder36()],
+  return transformEncoder29(
+    getStructEncoder62([
+      ["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)],
+      ["computationOffset", getU64Encoder33()],
       ["stakeAccountId", getU32Encoder22()]
     ]),
     (value) => ({ ...value, discriminator: REVEAL_STAKE_DISCRIMINATOR })
   );
 }
 function getRevealStakeInstructionDataDecoder() {
-  return getStructDecoder58([
-    ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)],
-    ["computationOffset", getU64Decoder36()],
+  return getStructDecoder62([
+    ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)],
+    ["computationOffset", getU64Decoder33()],
     ["stakeAccountId", getU32Decoder22()]
   ]);
 }
 function getRevealStakeInstructionDataCodec() {
-  return combineCodec64(
+  return combineCodec68(
     getRevealStakeInstructionDataEncoder(),
     getRevealStakeInstructionDataDecoder()
   );
@@ -5638,7 +5833,7 @@ async function getRevealStakeInstructionAsync(input, config) {
     accounts.stakeAccount.value = await getProgramDerivedAddress13({
       programAddress,
       seeds: [
-        getBytesEncoder28().encode(
+        getBytesEncoder30().encode(
           new Uint8Array([
             115,
             116,
@@ -5655,8 +5850,8 @@ async function getRevealStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder39().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder39().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
         getU32Encoder22().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -5665,7 +5860,7 @@ async function getRevealStakeInstructionAsync(input, config) {
     accounts.signPdaAccount.value = await getProgramDerivedAddress13({
       programAddress,
       seeds: [
-        getBytesEncoder28().encode(
+        getBytesEncoder30().encode(
           new Uint8Array([
             65,
             114,
@@ -5824,24 +6019,24 @@ function parseRevealStakeInstruction(instruction) {
 
 // src/generated/instructions/revealStakeCallback.ts
 import {
-  combineCodec as combineCodec65,
-  fixDecoderSize as fixDecoderSize28,
-  fixEncoderSize as fixEncoderSize29,
+  combineCodec as combineCodec69,
+  fixDecoderSize as fixDecoderSize30,
+  fixEncoderSize as fixEncoderSize31,
   getArrayDecoder as getArrayDecoder17,
   getArrayEncoder as getArrayEncoder17,
-  getBytesDecoder as getBytesDecoder28,
-  getBytesEncoder as getBytesEncoder29,
+  getBytesDecoder as getBytesDecoder30,
+  getBytesEncoder as getBytesEncoder31,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder4,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder4,
-  getStructDecoder as getStructDecoder59,
-  getStructEncoder as getStructEncoder59,
+  getStructDecoder as getStructDecoder63,
+  getStructEncoder as getStructEncoder63,
   getTupleDecoder as getTupleDecoder6,
   getTupleEncoder as getTupleEncoder6,
   getU8Decoder as getU8Decoder23,
   getU8Encoder as getU8Encoder23,
   getUnitDecoder,
   getUnitEncoder,
-  transformEncoder as transformEncoder28
+  transformEncoder as transformEncoder30
 } from "@solana/kit";
 var REVEAL_STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   79,
@@ -5854,20 +6049,20 @@ var REVEAL_STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   116
 ]);
 function getRevealStakeCallbackDiscriminatorBytes() {
-  return fixEncoderSize29(getBytesEncoder29(), 8).encode(
+  return fixEncoderSize31(getBytesEncoder31(), 8).encode(
     REVEAL_STAKE_CALLBACK_DISCRIMINATOR
   );
 }
 function getRevealStakeCallbackInstructionDataEncoder() {
-  return transformEncoder28(
-    getStructEncoder59([
-      ["discriminator", fixEncoderSize29(getBytesEncoder29(), 8)],
+  return transformEncoder30(
+    getStructEncoder63([
+      ["discriminator", fixEncoderSize31(getBytesEncoder31(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder4([
           [
             "Success",
-            getStructEncoder59([
+            getStructEncoder63([
               [
                 "fields",
                 getTupleEncoder6([
@@ -5880,7 +6075,7 @@ function getRevealStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder59([
+            getStructEncoder63([
               ["fields", getTupleEncoder6([getRevealStakeOutputEncoder()])]
             ])
           ]
@@ -5894,14 +6089,14 @@ function getRevealStakeCallbackInstructionDataEncoder() {
   );
 }
 function getRevealStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder59([
-    ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)],
+  return getStructDecoder63([
+    ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder4([
         [
           "Success",
-          getStructDecoder59([
+          getStructDecoder63([
             [
               "fields",
               getTupleDecoder6([
@@ -5914,7 +6109,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder59([
+          getStructDecoder63([
             ["fields", getTupleDecoder6([getRevealStakeOutputDecoder()])]
           ])
         ]
@@ -5923,7 +6118,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getRevealStakeCallbackInstructionDataCodec() {
-  return combineCodec65(
+  return combineCodec69(
     getRevealStakeCallbackInstructionDataEncoder(),
     getRevealStakeCallbackInstructionDataDecoder()
   );
@@ -5993,20 +6188,20 @@ function parseRevealStakeCallbackInstruction(instruction) {
     },
     data: getRevealStakeCallbackInstructionDataDecoder().decode(
       instruction.data
-    )
-  };
-}
-
-// src/generated/instructions/revealStakeCompDef.ts
-import {
-  combineCodec as combineCodec66,
-  fixDecoderSize as fixDecoderSize29,
-  fixEncoderSize as fixEncoderSize30,
-  getBytesDecoder as getBytesDecoder29,
-  getBytesEncoder as getBytesEncoder30,
-  getStructDecoder as getStructDecoder60,
-  getStructEncoder as getStructEncoder60,
-  transformEncoder as transformEncoder29
+    )
+  };
+}
+
+// src/generated/instructions/revealStakeCompDef.ts
+import {
+  combineCodec as combineCodec70,
+  fixDecoderSize as fixDecoderSize31,
+  fixEncoderSize as fixEncoderSize32,
+  getBytesDecoder as getBytesDecoder31,
+  getBytesEncoder as getBytesEncoder32,
+  getStructDecoder as getStructDecoder64,
+  getStructEncoder as getStructEncoder64,
+  transformEncoder as transformEncoder31
 } from "@solana/kit";
 var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   197,
@@ -6019,13 +6214,13 @@ var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   0
 ]);
 function getRevealStakeCompDefDiscriminatorBytes() {
-  return fixEncoderSize30(getBytesEncoder30(), 8).encode(
+  return fixEncoderSize32(getBytesEncoder32(), 8).encode(
     REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
   );
 }
 function getRevealStakeCompDefInstructionDataEncoder() {
-  return transformEncoder29(
-    getStructEncoder60([["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)]]),
+  return transformEncoder31(
+    getStructEncoder64([["discriminator", fixEncoderSize32(getBytesEncoder32(), 8)]]),
     (value) => ({
       ...value,
       discriminator: REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
@@ -6033,12 +6228,12 @@ function getRevealStakeCompDefInstructionDataEncoder() {
   );
 }
 function getRevealStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder60([
-    ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)]
+  return getStructDecoder64([
+    ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)]
   ]);
 }
 function getRevealStakeCompDefInstructionDataCodec() {
-  return combineCodec66(
+  return combineCodec70(
     getRevealStakeCompDefInstructionDataEncoder(),
     getRevealStakeCompDefInstructionDataDecoder()
   );
@@ -6111,16 +6306,16 @@ function parseRevealStakeCompDefInstruction(instruction) {
 
 // src/generated/instructions/selectWinningOptions.ts
 import {
-  combineCodec as combineCodec67,
-  fixDecoderSize as fixDecoderSize30,
-  fixEncoderSize as fixEncoderSize31,
+  combineCodec as combineCodec71,
+  fixDecoderSize as fixDecoderSize32,
+  fixEncoderSize as fixEncoderSize33,
   getArrayDecoder as getArrayDecoder18,
   getArrayEncoder as getArrayEncoder18,
-  getBytesDecoder as getBytesDecoder30,
-  getBytesEncoder as getBytesEncoder31,
-  getStructDecoder as getStructDecoder61,
-  getStructEncoder as getStructEncoder61,
-  transformEncoder as transformEncoder30
+  getBytesDecoder as getBytesDecoder32,
+  getBytesEncoder as getBytesEncoder33,
+  getStructDecoder as getStructDecoder65,
+  getStructEncoder as getStructEncoder65,
+  transformEncoder as transformEncoder32
 } from "@solana/kit";
 var SELECT_WINNING_OPTIONS_DISCRIMINATOR = new Uint8Array([
   56,
@@ -6133,14 +6328,14 @@ var SELECT_WINNING_OPTIONS_DISCRIMINATOR = new Uint8Array([
   20
 ]);
 function getSelectWinningOptionsDiscriminatorBytes() {
-  return fixEncoderSize31(getBytesEncoder31(), 8).encode(
+  return fixEncoderSize33(getBytesEncoder33(), 8).encode(
     SELECT_WINNING_OPTIONS_DISCRIMINATOR
   );
 }
 function getSelectWinningOptionsInstructionDataEncoder() {
-  return transformEncoder30(
-    getStructEncoder61([
-      ["discriminator", fixEncoderSize31(getBytesEncoder31(), 8)],
+  return transformEncoder32(
+    getStructEncoder65([
+      ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
       ["selections", getArrayEncoder18(getWinningOptionEncoder())]
     ]),
     (value) => ({
@@ -6150,13 +6345,13 @@ function getSelectWinningOptionsInstructionDataEncoder() {
   );
 }
 function getSelectWinningOptionsInstructionDataDecoder() {
-  return getStructDecoder61([
-    ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)],
+  return getStructDecoder65([
+    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
     ["selections", getArrayDecoder18(getWinningOptionDecoder())]
   ]);
 }
 function getSelectWinningOptionsInstructionDataCodec() {
-  return combineCodec67(
+  return combineCodec71(
     getSelectWinningOptionsInstructionDataEncoder(),
     getSelectWinningOptionsInstructionDataDecoder()
   );
@@ -6202,26 +6397,26 @@ function parseSelectWinningOptionsInstruction(instruction) {
 
 // src/generated/instructions/stake.ts
 import {
-  combineCodec as combineCodec68,
-  fixDecoderSize as fixDecoderSize31,
-  fixEncoderSize as fixEncoderSize32,
-  getAddressEncoder as getAddressEncoder40,
+  combineCodec as combineCodec72,
+  fixDecoderSize as fixDecoderSize33,
+  fixEncoderSize as fixEncoderSize34,
+  getAddressEncoder as getAddressEncoder42,
   getArrayDecoder as getArrayDecoder19,
   getArrayEncoder as getArrayEncoder19,
-  getBytesDecoder as getBytesDecoder31,
-  getBytesEncoder as getBytesEncoder32,
+  getBytesDecoder as getBytesDecoder33,
+  getBytesEncoder as getBytesEncoder34,
   getProgramDerivedAddress as getProgramDerivedAddress14,
-  getStructDecoder as getStructDecoder62,
-  getStructEncoder as getStructEncoder62,
+  getStructDecoder as getStructDecoder66,
+  getStructEncoder as getStructEncoder66,
   getU128Decoder as getU128Decoder5,
   getU128Encoder as getU128Encoder5,
   getU32Decoder as getU32Decoder23,
   getU32Encoder as getU32Encoder23,
-  getU64Decoder as getU64Decoder37,
-  getU64Encoder as getU64Encoder37,
+  getU64Decoder as getU64Decoder34,
+  getU64Encoder as getU64Encoder34,
   getU8Decoder as getU8Decoder24,
   getU8Encoder as getU8Encoder24,
-  transformEncoder as transformEncoder31
+  transformEncoder as transformEncoder33
 } from "@solana/kit";
 var STAKE_DISCRIMINATOR = new Uint8Array([
   206,
@@ -6234,15 +6429,15 @@ var STAKE_DISCRIMINATOR = new Uint8Array([
   108
 ]);
 function getStakeDiscriminatorBytes() {
-  return fixEncoderSize32(getBytesEncoder32(), 8).encode(STAKE_DISCRIMINATOR);
+  return fixEncoderSize34(getBytesEncoder34(), 8).encode(STAKE_DISCRIMINATOR);
 }
 function getStakeInstructionDataEncoder() {
-  return transformEncoder31(
-    getStructEncoder62([
-      ["discriminator", fixEncoderSize32(getBytesEncoder32(), 8)],
-      ["computationOffset", getU64Encoder37()],
+  return transformEncoder33(
+    getStructEncoder66([
+      ["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)],
+      ["computationOffset", getU64Encoder34()],
       ["stakeAccountId", getU32Encoder23()],
-      ["amount", getU64Encoder37()],
+      ["amount", getU64Encoder34()],
       [
         "selectedOptionCiphertext",
         getArrayEncoder19(getU8Encoder24(), { size: 32 })
@@ -6255,11 +6450,11 @@ function getStakeInstructionDataEncoder() {
   );
 }
 function getStakeInstructionDataDecoder() {
-  return getStructDecoder62([
-    ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)],
-    ["computationOffset", getU64Decoder37()],
+  return getStructDecoder66([
+    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)],
+    ["computationOffset", getU64Decoder34()],
     ["stakeAccountId", getU32Decoder23()],
-    ["amount", getU64Decoder37()],
+    ["amount", getU64Decoder34()],
     ["selectedOptionCiphertext", getArrayDecoder19(getU8Decoder24(), { size: 32 })],
     ["inputNonce", getU128Decoder5()],
     ["authorizedReaderNonce", getU128Decoder5()],
@@ -6267,7 +6462,7 @@ function getStakeInstructionDataDecoder() {
   ]);
 }
 function getStakeInstructionDataCodec() {
-  return combineCodec68(
+  return combineCodec72(
     getStakeInstructionDataEncoder(),
     getStakeInstructionDataDecoder()
   );
@@ -6309,7 +6504,7 @@ async function getStakeInstructionAsync(input, config) {
     accounts.stakeAccount.value = await getProgramDerivedAddress14({
       programAddress,
       seeds: [
-        getBytesEncoder32().encode(
+        getBytesEncoder34().encode(
           new Uint8Array([
             115,
             116,
@@ -6326,8 +6521,8 @@ async function getStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
         getU32Encoder23().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -6336,9 +6531,9 @@ async function getStakeInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress14({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6346,10 +6541,10 @@ async function getStakeInstructionAsync(input, config) {
     accounts.tokenVault.value = await getProgramDerivedAddress14({
       programAddress,
       seeds: [
-        getBytesEncoder32().encode(
+        getBytesEncoder34().encode(
           new Uint8Array([116, 111, 107, 101, 110, 95, 118, 97, 117, 108, 116])
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6357,9 +6552,9 @@ async function getStakeInstructionAsync(input, config) {
     accounts.tokenVaultAta.value = await getProgramDerivedAddress14({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder40().encode(expectAddress(accounts.tokenVault.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder42().encode(expectAddress(accounts.tokenVault.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6367,7 +6562,7 @@ async function getStakeInstructionAsync(input, config) {
     accounts.signPdaAccount.value = await getProgramDerivedAddress14({
       programAddress,
       seeds: [
-        getBytesEncoder32().encode(
+        getBytesEncoder34().encode(
           new Uint8Array([
             65,
             114,
@@ -6553,24 +6748,24 @@ function parseStakeInstruction(instruction) {
 
 // src/generated/instructions/stakeCallback.ts
 import {
-  combineCodec as combineCodec69,
-  fixDecoderSize as fixDecoderSize32,
-  fixEncoderSize as fixEncoderSize33,
+  combineCodec as combineCodec73,
+  fixDecoderSize as fixDecoderSize34,
+  fixEncoderSize as fixEncoderSize35,
   getArrayDecoder as getArrayDecoder20,
   getArrayEncoder as getArrayEncoder20,
-  getBytesDecoder as getBytesDecoder32,
-  getBytesEncoder as getBytesEncoder33,
+  getBytesDecoder as getBytesDecoder34,
+  getBytesEncoder as getBytesEncoder35,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder5,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder5,
-  getStructDecoder as getStructDecoder63,
-  getStructEncoder as getStructEncoder63,
+  getStructDecoder as getStructDecoder67,
+  getStructEncoder as getStructEncoder67,
   getTupleDecoder as getTupleDecoder7,
   getTupleEncoder as getTupleEncoder7,
   getU8Decoder as getU8Decoder25,
   getU8Encoder as getU8Encoder25,
   getUnitDecoder as getUnitDecoder2,
   getUnitEncoder as getUnitEncoder2,
-  transformEncoder as transformEncoder32
+  transformEncoder as transformEncoder34
 } from "@solana/kit";
 var STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   40,
@@ -6583,20 +6778,20 @@ var STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   89
 ]);
 function getStakeCallbackDiscriminatorBytes() {
-  return fixEncoderSize33(getBytesEncoder33(), 8).encode(
+  return fixEncoderSize35(getBytesEncoder35(), 8).encode(
     STAKE_CALLBACK_DISCRIMINATOR
   );
 }
 function getStakeCallbackInstructionDataEncoder() {
-  return transformEncoder32(
-    getStructEncoder63([
-      ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
+  return transformEncoder34(
+    getStructEncoder67([
+      ["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder5([
           [
             "Success",
-            getStructEncoder63([
+            getStructEncoder67([
               [
                 "fields",
                 getTupleEncoder7([
@@ -6609,7 +6804,7 @@ function getStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder2()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder63([
+            getStructEncoder67([
               ["fields", getTupleEncoder7([getStakeOutputEncoder()])]
             ])
           ]
@@ -6620,14 +6815,14 @@ function getStakeCallbackInstructionDataEncoder() {
   );
 }
 function getStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder63([
-    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
+  return getStructDecoder67([
+    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder5([
         [
           "Success",
-          getStructDecoder63([
+          getStructDecoder67([
             [
               "fields",
               getTupleDecoder7([
@@ -6640,7 +6835,7 @@ function getStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder2()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder63([
+          getStructDecoder67([
             ["fields", getTupleDecoder7([getStakeOutputDecoder()])]
           ])
         ]
@@ -6649,7 +6844,7 @@ function getStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getStakeCallbackInstructionDataCodec() {
-  return combineCodec69(
+  return combineCodec73(
     getStakeCallbackInstructionDataEncoder(),
     getStakeCallbackInstructionDataDecoder()
   );
@@ -6729,14 +6924,14 @@ function parseStakeCallbackInstruction(instruction) {
 
 // src/generated/instructions/stakeCompDef.ts
 import {
-  combineCodec as combineCodec70,
-  fixDecoderSize as fixDecoderSize33,
-  fixEncoderSize as fixEncoderSize34,
-  getBytesDecoder as getBytesDecoder33,
-  getBytesEncoder as getBytesEncoder34,
-  getStructDecoder as getStructDecoder64,
-  getStructEncoder as getStructEncoder64,
-  transformEncoder as transformEncoder33
+  combineCodec as combineCodec74,
+  fixDecoderSize as fixDecoderSize35,
+  fixEncoderSize as fixEncoderSize36,
+  getBytesDecoder as getBytesDecoder35,
+  getBytesEncoder as getBytesEncoder36,
+  getStructDecoder as getStructDecoder68,
+  getStructEncoder as getStructEncoder68,
+  transformEncoder as transformEncoder35
 } from "@solana/kit";
 var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   156,
@@ -6749,23 +6944,23 @@ var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   130
 ]);
 function getStakeCompDefDiscriminatorBytes() {
-  return fixEncoderSize34(getBytesEncoder34(), 8).encode(
+  return fixEncoderSize36(getBytesEncoder36(), 8).encode(
     STAKE_COMP_DEF_DISCRIMINATOR
   );
 }
 function getStakeCompDefInstructionDataEncoder() {
-  return transformEncoder33(
-    getStructEncoder64([["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)]]),
+  return transformEncoder35(
+    getStructEncoder68([["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)]]),
     (value) => ({ ...value, discriminator: STAKE_COMP_DEF_DISCRIMINATOR })
   );
 }
 function getStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder64([
-    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)]
+  return getStructDecoder68([
+    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)]
   ]);
 }
 function getStakeCompDefInstructionDataCodec() {
-  return combineCodec70(
+  return combineCodec74(
     getStakeCompDefInstructionDataEncoder(),
     getStakeCompDefInstructionDataDecoder()
   );
@@ -6836,17 +7031,17 @@ function parseStakeCompDefInstruction(instruction) {
 
 // src/generated/instructions/transferCentralStateAuthority.ts
 import {
-  combineCodec as combineCodec71,
-  fixDecoderSize as fixDecoderSize34,
-  fixEncoderSize as fixEncoderSize35,
-  getAddressDecoder as getAddressDecoder30,
-  getAddressEncoder as getAddressEncoder41,
-  getBytesDecoder as getBytesDecoder34,
-  getBytesEncoder as getBytesEncoder35,
+  combineCodec as combineCodec75,
+  fixDecoderSize as fixDecoderSize36,
+  fixEncoderSize as fixEncoderSize37,
+  getAddressDecoder as getAddressDecoder32,
+  getAddressEncoder as getAddressEncoder43,
+  getBytesDecoder as getBytesDecoder36,
+  getBytesEncoder as getBytesEncoder37,
   getProgramDerivedAddress as getProgramDerivedAddress15,
-  getStructDecoder as getStructDecoder65,
-  getStructEncoder as getStructEncoder65,
-  transformEncoder as transformEncoder34
+  getStructDecoder as getStructDecoder69,
+  getStructEncoder as getStructEncoder69,
+  transformEncoder as transformEncoder36
 } from "@solana/kit";
 var TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   237,
@@ -6859,15 +7054,15 @@ var TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   90
 ]);
 function getTransferCentralStateAuthorityDiscriminatorBytes() {
-  return fixEncoderSize35(getBytesEncoder35(), 8).encode(
+  return fixEncoderSize37(getBytesEncoder37(), 8).encode(
     TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR
   );
 }
 function getTransferCentralStateAuthorityInstructionDataEncoder() {
-  return transformEncoder34(
-    getStructEncoder65([
-      ["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)],
-      ["newAuthority", getAddressEncoder41()]
+  return transformEncoder36(
+    getStructEncoder69([
+      ["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)],
+      ["newAuthority", getAddressEncoder43()]
     ]),
     (value) => ({
       ...value,
@@ -6876,13 +7071,13 @@ function getTransferCentralStateAuthorityInstructionDataEncoder() {
   );
 }
 function getTransferCentralStateAuthorityInstructionDataDecoder() {
-  return getStructDecoder65([
-    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
-    ["newAuthority", getAddressDecoder30()]
+  return getStructDecoder69([
+    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)],
+    ["newAuthority", getAddressDecoder32()]
   ]);
 }
 function getTransferCentralStateAuthorityInstructionDataCodec() {
-  return combineCodec71(
+  return combineCodec75(
     getTransferCentralStateAuthorityInstructionDataEncoder(),
     getTransferCentralStateAuthorityInstructionDataDecoder()
   );
@@ -6899,7 +7094,7 @@ async function getTransferCentralStateAuthorityInstructionAsync(input, config) {
     accounts.centralState.value = await getProgramDerivedAddress15({
       programAddress,
       seeds: [
-        getBytesEncoder35().encode(
+        getBytesEncoder37().encode(
           new Uint8Array([
             99,
             101,
@@ -6972,18 +7167,18 @@ function parseTransferCentralStateAuthorityInstruction(instruction) {
 
 // src/generated/instructions/unstakeEarly.ts
 import {
-  combineCodec as combineCodec72,
-  fixDecoderSize as fixDecoderSize35,
-  fixEncoderSize as fixEncoderSize36,
-  getAddressEncoder as getAddressEncoder42,
-  getBytesDecoder as getBytesDecoder35,
-  getBytesEncoder as getBytesEncoder36,
+  combineCodec as combineCodec76,
+  fixDecoderSize as fixDecoderSize37,
+  fixEncoderSize as fixEncoderSize38,
+  getAddressEncoder as getAddressEncoder44,
+  getBytesDecoder as getBytesDecoder37,
+  getBytesEncoder as getBytesEncoder38,
   getProgramDerivedAddress as getProgramDerivedAddress16,
-  getStructDecoder as getStructDecoder66,
-  getStructEncoder as getStructEncoder66,
+  getStructDecoder as getStructDecoder70,
+  getStructEncoder as getStructEncoder70,
   getU32Decoder as getU32Decoder24,
   getU32Encoder as getU32Encoder24,
-  transformEncoder as transformEncoder35
+  transformEncoder as transformEncoder37
 } from "@solana/kit";
 var UNSTAKE_EARLY_DISCRIMINATOR = new Uint8Array([
   246,
@@ -6996,27 +7191,27 @@ var UNSTAKE_EARLY_DISCRIMINATOR = new Uint8Array([
   125
 ]);
 function getUnstakeEarlyDiscriminatorBytes() {
-  return fixEncoderSize36(getBytesEncoder36(), 8).encode(
+  return fixEncoderSize38(getBytesEncoder38(), 8).encode(
     UNSTAKE_EARLY_DISCRIMINATOR
   );
 }
 function getUnstakeEarlyInstructionDataEncoder() {
-  return transformEncoder35(
-    getStructEncoder66([
-      ["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)],
+  return transformEncoder37(
+    getStructEncoder70([
+      ["discriminator", fixEncoderSize38(getBytesEncoder38(), 8)],
       ["stakeAccountId", getU32Encoder24()]
     ]),
     (value) => ({ ...value, discriminator: UNSTAKE_EARLY_DISCRIMINATOR })
   );
 }
 function getUnstakeEarlyInstructionDataDecoder() {
-  return getStructDecoder66([
-    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
+  return getStructDecoder70([
+    ["discriminator", fixDecoderSize37(getBytesDecoder37(), 8)],
     ["stakeAccountId", getU32Decoder24()]
   ]);
 }
 function getUnstakeEarlyInstructionDataCodec() {
-  return combineCodec72(
+  return combineCodec76(
     getUnstakeEarlyInstructionDataEncoder(),
     getUnstakeEarlyInstructionDataDecoder()
   );
@@ -7034,7 +7229,7 @@ async function getUnstakeEarlyInstructionAsync(input, config) {
     accounts.stakeAccount.value = await getProgramDerivedAddress16({
       programAddress,
       seeds: [
-        getBytesEncoder36().encode(
+        getBytesEncoder38().encode(
           new Uint8Array([
             115,
             116,
@@ -7051,8 +7246,8 @@ async function getUnstakeEarlyInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder42().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder44().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder44().encode(expectAddress(accounts.market.value)),
         getU32Encoder24().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -7115,21 +7310,19 @@ function parseUnstakeEarlyInstruction(instruction) {
 
 // src/generated/instructions/updateCentralState.ts
 import {
-  combineCodec as combineCodec73,
-  fixDecoderSize as fixDecoderSize36,
-  fixEncoderSize as fixEncoderSize37,
-  getAddressDecoder as getAddressDecoder31,
-  getAddressEncoder as getAddressEncoder43,
-  getBytesDecoder as getBytesDecoder36,
-  getBytesEncoder as getBytesEncoder37,
+  combineCodec as combineCodec77,
+  fixDecoderSize as fixDecoderSize38,
+  fixEncoderSize as fixEncoderSize39,
+  getAddressDecoder as getAddressDecoder33,
+  getAddressEncoder as getAddressEncoder45,
+  getBytesDecoder as getBytesDecoder38,
+  getBytesEncoder as getBytesEncoder39,
   getProgramDerivedAddress as getProgramDerivedAddress17,
-  getStructDecoder as getStructDecoder67,
-  getStructEncoder as getStructEncoder67,
+  getStructDecoder as getStructDecoder71,
+  getStructEncoder as getStructEncoder71,
   getU16Decoder as getU16Decoder5,
   getU16Encoder as getU16Encoder5,
-  getU64Decoder as getU64Decoder38,
-  getU64Encoder as getU64Encoder38,
-  transformEncoder as transformEncoder36
+  transformEncoder as transformEncoder38
 } from "@solana/kit";
 var UPDATE_CENTRAL_STATE_DISCRIMINATOR = new Uint8Array([
   228,
@@ -7142,35 +7335,29 @@ var UPDATE_CENTRAL_STATE_DISCRIMINATOR = new Uint8Array([
   194
 ]);
 function getUpdateCentralStateDiscriminatorBytes() {
-  return fixEncoderSize37(getBytesEncoder37(), 8).encode(
+  return fixEncoderSize39(getBytesEncoder39(), 8).encode(
     UPDATE_CENTRAL_STATE_DISCRIMINATOR
   );
 }
 function getUpdateCentralStateInstructionDataEncoder() {
-  return transformEncoder36(
-    getStructEncoder67([
-      ["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)],
-      ["earlinessCutoffSeconds", getU64Encoder38()],
-      ["minOptionDeposit", getU64Encoder38()],
+  return transformEncoder38(
+    getStructEncoder71([
+      ["discriminator", fixEncoderSize39(getBytesEncoder39(), 8)],
       ["protocolFeeBp", getU16Encoder5()],
-      ["feeRecipient", getAddressEncoder43()],
-      ["minimumInitialRevealPeriod", getU64Encoder38()]
+      ["feeRecipient", getAddressEncoder45()]
     ]),
     (value) => ({ ...value, discriminator: UPDATE_CENTRAL_STATE_DISCRIMINATOR })
   );
 }
 function getUpdateCentralStateInstructionDataDecoder() {
-  return getStructDecoder67([
-    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)],
-    ["earlinessCutoffSeconds", getU64Decoder38()],
-    ["minOptionDeposit", getU64Decoder38()],
+  return getStructDecoder71([
+    ["discriminator", fixDecoderSize38(getBytesDecoder38(), 8)],
     ["protocolFeeBp", getU16Decoder5()],
-    ["feeRecipient", getAddressDecoder31()],
-    ["minimumInitialRevealPeriod", getU64Decoder38()]
+    ["feeRecipient", getAddressDecoder33()]
   ]);
 }
 function getUpdateCentralStateInstructionDataCodec() {
-  return combineCodec73(
+  return combineCodec77(
     getUpdateCentralStateInstructionDataEncoder(),
     getUpdateCentralStateInstructionDataDecoder()
   );
@@ -7187,7 +7374,7 @@ async function getUpdateCentralStateInstructionAsync(input, config) {
     accounts.centralState.value = await getProgramDerivedAddress17({
       programAddress,
       seeds: [
-        getBytesEncoder37().encode(
+        getBytesEncoder39().encode(
           new Uint8Array([
             99,
             101,
@@ -7260,16 +7447,16 @@ function parseUpdateCentralStateInstruction(instruction) {
 
 // src/generated/instructions/withdrawReward.ts
 import {
-  combineCodec as combineCodec74,
-  fixDecoderSize as fixDecoderSize37,
-  fixEncoderSize as fixEncoderSize38,
-  getAddressEncoder as getAddressEncoder44,
-  getBytesDecoder as getBytesDecoder37,
-  getBytesEncoder as getBytesEncoder38,
+  combineCodec as combineCodec78,
+  fixDecoderSize as fixDecoderSize39,
+  fixEncoderSize as fixEncoderSize40,
+  getAddressEncoder as getAddressEncoder46,
+  getBytesDecoder as getBytesDecoder39,
+  getBytesEncoder as getBytesEncoder40,
   getProgramDerivedAddress as getProgramDerivedAddress18,
-  getStructDecoder as getStructDecoder68,
-  getStructEncoder as getStructEncoder68,
-  transformEncoder as transformEncoder37
+  getStructDecoder as getStructDecoder72,
+  getStructEncoder as getStructEncoder72,
+  transformEncoder as transformEncoder39
 } from "@solana/kit";
 var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   191,
@@ -7282,23 +7469,23 @@ var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   244
 ]);
 function getWithdrawRewardDiscriminatorBytes() {
-  return fixEncoderSize38(getBytesEncoder38(), 8).encode(
+  return fixEncoderSize40(getBytesEncoder40(), 8).encode(
     WITHDRAW_REWARD_DISCRIMINATOR
   );
 }
 function getWithdrawRewardInstructionDataEncoder() {
-  return transformEncoder37(
-    getStructEncoder68([["discriminator", fixEncoderSize38(getBytesEncoder38(), 8)]]),
+  return transformEncoder39(
+    getStructEncoder72([["discriminator", fixEncoderSize40(getBytesEncoder40(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_REWARD_DISCRIMINATOR })
   );
 }
 function getWithdrawRewardInstructionDataDecoder() {
-  return getStructDecoder68([
-    ["discriminator", fixDecoderSize37(getBytesDecoder37(), 8)]
+  return getStructDecoder72([
+    ["discriminator", fixDecoderSize39(getBytesDecoder39(), 8)]
   ]);
 }
 function getWithdrawRewardInstructionDataCodec() {
-  return combineCodec74(
+  return combineCodec78(
     getWithdrawRewardInstructionDataEncoder(),
     getWithdrawRewardInstructionDataDecoder()
   );
@@ -7322,11 +7509,11 @@ async function getWithdrawRewardInstructionAsync(input, config) {
     accounts.sponsorAccount.value = await getProgramDerivedAddress18({
       programAddress,
       seeds: [
-        getBytesEncoder38().encode(
+        getBytesEncoder40().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        getAddressEncoder44().encode(expectAddress(accounts.sponsor.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.market.value))
+        getAddressEncoder46().encode(expectAddress(accounts.sponsor.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.market.value))
       ]
     });
   }
@@ -7334,9 +7521,9 @@ async function getWithdrawRewardInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress18({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder44().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder46().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7451,6 +7638,7 @@ async function createMarket(input) {
     authorizedReaderPubkey,
     allowClosingEarly,
     revealPeriodAuthority,
+    earlinessCutoffSeconds,
     programAddress
   } = input;
   return getCreateMarketInstructionAsync(
@@ -7465,7 +7653,8 @@ async function createMarket(input) {
       unstakeDelaySeconds,
       authorizedReaderPubkey: toNumberArray(authorizedReaderPubkey),
       allowClosingEarly,
-      revealPeriodAuthority
+      revealPeriodAuthority,
+      earlinessCutoffSeconds
     },
     programAddress ? { programAddress } : void 0
   );
@@ -7651,6 +7840,24 @@ function openMarket(input) {
   );
 }
 
+// src/instructions/pauseMarket.ts
+function pauseMarket(input) {
+  const { programAddress, ...params } = input;
+  return getPauseMarketInstruction(
+    params,
+    programAddress ? { programAddress } : void 0
+  );
+}
+
+// src/instructions/resumeMarket.ts
+function resumeMarket(input) {
+  const { programAddress, ...params } = input;
+  return getResumeMarketInstruction(
+    params,
+    programAddress ? { programAddress } : void 0
+  );
+}
+
 // src/instructions/selectWinningOptions.ts
 function selectWinningOptions(input) {
   const { programAddress, ...params } = input;
@@ -7761,7 +7968,7 @@ async function ensureCentralState(rpc, params) {
   const existing = await fetchMaybeCentralState(rpc, centralStateAddress);
   if (existing.exists) {
     const s = existing.data;
-    if (s.earlinessCutoffSeconds === BigInt(args.earlinessCutoffSeconds) && s.minOptionDeposit === BigInt(args.minOptionDeposit) && s.protocolFeeBp === args.protocolFeeBp && s.feeRecipient === args.feeRecipient && s.minimumInitialRevealPeriod === BigInt(args.minimumInitialRevealPeriod)) {
+    if (s.protocolFeeBp === args.protocolFeeBp && s.feeRecipient === args.feeRecipient) {
       return null;
     }
     return getUpdateCentralStateInstructionAsync(
@@ -7786,8 +7993,8 @@ async function withdrawReward(input) {
 
 // src/accounts/opportunityMarket.ts
 import {
-  getAddressEncoder as getAddressEncoder45,
-  getU64Encoder as getU64Encoder39,
+  getAddressEncoder as getAddressEncoder47,
+  getU64Encoder as getU64Encoder35,
   getProgramDerivedAddress as getProgramDerivedAddress20
 } from "@solana/kit";
 var OPPORTUNITY_MARKET_SEED = "opportunity_market";
@@ -7796,16 +8003,16 @@ async function getOpportunityMarketAddress(creator, marketIndex, programId = OPP
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_SEED,
-      getAddressEncoder45().encode(creator),
-      getU64Encoder39().encode(BigInt(marketIndex))
+      getAddressEncoder47().encode(creator),
+      getU64Encoder35().encode(BigInt(marketIndex))
     ]
   });
 }
 
 // src/accounts/opportunityMarketOption.ts
 import {
-  getAddressEncoder as getAddressEncoder46,
-  getU64Encoder as getU64Encoder40,
+  getAddressEncoder as getAddressEncoder48,
+  getU64Encoder as getU64Encoder36,
   getProgramDerivedAddress as getProgramDerivedAddress21
 } from "@solana/kit";
 var OPPORTUNITY_MARKET_OPTION_SEED = "option";
@@ -7814,20 +8021,20 @@ async function getOpportunityMarketOptionAddress(market, optionId, programId = O
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_OPTION_SEED,
-      getAddressEncoder46().encode(market),
-      getU64Encoder40().encode(optionId)
+      getAddressEncoder48().encode(market),
+      getU64Encoder36().encode(optionId)
     ]
   });
 }
 
 // src/accounts/opportunityMarketSponsor.ts
 import {
-  getAddressEncoder as getAddressEncoder47,
+  getAddressEncoder as getAddressEncoder49,
   getProgramDerivedAddress as getProgramDerivedAddress22
 } from "@solana/kit";
 var SPONSOR_SEED = "sponsor";
 async function getOpportunityMarketSponsorAddress(sponsor, market, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = getAddressEncoder47();
+  const addressEncoder = getAddressEncoder49();
   return getProgramDerivedAddress22({
     programAddress: programId,
     seeds: [
@@ -7840,12 +8047,12 @@ async function getOpportunityMarketSponsorAddress(sponsor, market, programId = O
 
 // src/accounts/stakeAccount.ts
 import {
-  getAddressEncoder as getAddressEncoder48,
+  getAddressEncoder as getAddressEncoder50,
   getProgramDerivedAddress as getProgramDerivedAddress23
 } from "@solana/kit";
 var STAKE_ACCOUNT_SEED = "stake_account";
 async function getStakeAccountAddress(owner, market, stakeAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = getAddressEncoder48();
+  const addressEncoder = getAddressEncoder50();
   const idBytes = new Uint8Array(4);
   new DataView(idBytes.buffer).setUint32(0, stakeAccountId, true);
   return getProgramDerivedAddress23({
@@ -7861,19 +8068,19 @@ async function getStakeAccountAddress(owner, market, stakeAccountId, programId =
 
 // src/accounts/tokenVault.ts
 import {
-  getAddressEncoder as getAddressEncoder49,
+  getAddressEncoder as getAddressEncoder51,
   getProgramDerivedAddress as getProgramDerivedAddress24
 } from "@solana/kit";
 var TOKEN_VAULT_SEED = "token_vault";
 async function getTokenVaultAddress(mint, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
   return getProgramDerivedAddress24({
     programAddress: programId,
-    seeds: [TOKEN_VAULT_SEED, getAddressEncoder49().encode(mint)]
+    seeds: [TOKEN_VAULT_SEED, getAddressEncoder51().encode(mint)]
   });
 }
 
 // src/arcium/awaitFinalizeComputation.ts
-import { getAddressEncoder as getAddressEncoder50 } from "@solana/kit";
+import { getAddressEncoder as getAddressEncoder52 } from "@solana/kit";
 
 // src/arcium/constants.ts
 var ARCIUM_PROGRAM_ID = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
@@ -7902,7 +8109,7 @@ var awaitBatchComputationFinalization = async (rpc, computationOffsets, options)
   }
   const mxeProgramId = options?.mxeProgramId ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const commitment = options?.commitment ?? "confirmed";
-  const mxeProgramIdBytes = getAddressEncoder50().encode(mxeProgramId);
+  const mxeProgramIdBytes = getAddressEncoder52().encode(mxeProgramId);
   const transactionCountLimit = options?.transactionCountLimit ?? 100;
   const pollInterval = options?.pollInterval ?? 1e3;
   const maxAttempts = options?.maxAttempts ?? 120;
@@ -8039,6 +8246,7 @@ export {
   OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED,
   OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET,
   OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM,
+  OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE,
   OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE,
   OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING,
   OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE,
@@ -8049,10 +8257,13 @@ export {
   OPPORTUNITY_MARKET_ERROR__LOCKED,
   OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN,
   OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN,
+  OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED,
   OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED,
+  OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED,
   OPPORTUNITY_MARKET_ERROR__NOT_REVEALED,
   OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM,
   OPPORTUNITY_MARKET_ERROR__OVERFLOW,
+  OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH,
   OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED,
   OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK,
   OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE,
@@ -8069,8 +8280,10 @@ export {
   OpportunityMarketAccount,
   OpportunityMarketInstruction,
   Output,
+  PAUSE_MARKET_DISCRIMINATOR,
   Parameter,
   RECLAIM_STAKE_DISCRIMINATOR,
+  RESUME_MARKET_DISCRIMINATOR,
   REVEAL_STAKE_CALLBACK_DISCRIMINATOR,
   REVEAL_STAKE_COMP_DEF_DISCRIMINATOR,
   REVEAL_STAKE_DISCRIMINATOR,
@@ -8298,6 +8511,12 @@ export {
   getMarketOptionCreatedEventCodec,
   getMarketOptionCreatedEventDecoder,
   getMarketOptionCreatedEventEncoder,
+  getMarketPausedEventCodec,
+  getMarketPausedEventDecoder,
+  getMarketPausedEventEncoder,
+  getMarketResumedEventCodec,
+  getMarketResumedEventDecoder,
+  getMarketResumedEventEncoder,
   getMxeAccount,
   getMxeStatusCodec,
   getMxeStatusDecoder,
@@ -8341,15 +8560,25 @@ export {
   getParameterCodec,
   getParameterDecoder,
   getParameterEncoder,
+  getPauseMarketDiscriminatorBytes,
+  getPauseMarketInstruction,
+  getPauseMarketInstructionDataCodec,
+  getPauseMarketInstructionDataDecoder,
+  getPauseMarketInstructionDataEncoder,
   getReclaimStakeDiscriminatorBytes,
   getReclaimStakeInstruction,
   getReclaimStakeInstructionAsync,
   getReclaimStakeInstructionDataCodec,
   getReclaimStakeInstructionDataDecoder,
   getReclaimStakeInstructionDataEncoder,
-  getRevealPeriodExtendedEventCodec,
-  getRevealPeriodExtendedEventDecoder,
-  getRevealPeriodExtendedEventEncoder,
+  getResumeMarketDiscriminatorBytes,
+  getResumeMarketInstruction,
+  getResumeMarketInstructionDataCodec,
+  getResumeMarketInstructionDataDecoder,
+  getResumeMarketInstructionDataEncoder,
+  getRevealPeriodEndedEventCodec,
+  getRevealPeriodEndedEventDecoder,
+  getRevealPeriodEndedEventEncoder,
   getRevealStakeCallbackDiscriminatorBytes,
   getRevealStakeCallbackInstruction,
   getRevealStakeCallbackInstructionDataCodec,
@@ -8497,7 +8726,9 @@ export {
   parseInitStakeAccountInstruction,
   parseInitTokenVaultInstruction,
   parseOpenMarketInstruction,
+  parsePauseMarketInstruction,
   parseReclaimStakeInstruction,
+  parseResumeMarketInstruction,
   parseRevealStakeCallbackInstruction,
   parseRevealStakeCompDefInstruction,
   parseRevealStakeInstruction,
@@ -8509,9 +8740,11 @@ export {
   parseUnstakeEarlyInstruction,
   parseUpdateCentralStateInstruction,
   parseWithdrawRewardInstruction,
+  pauseMarket,
   randomComputationOffset,
   randomStateNonce,
   reclaimStake,
+  resumeMarket,
   revealStake,
   selectWinningOptions,
   stake,